# Daintree

> A review-first workspace for AI coding agents. Daintree is an Electron desktop app that provides a habitat for parallel AI coding agent delegation, built for Claude Code, Codex, Antigravity, Cursor, and OpenCode.

This index lists the official Daintree documentation. Nested entries are subpages of the entry above them. For the full prose corpus concatenated as plain Markdown, see /llms-full.txt.

## Start Here

Section index: https://daintree.org/docs/start-here

Install Daintree and learn the mental model behind the habitat.

- [Installation & Setup](https://daintree.org/docs/getting-started): Install Daintree, set up your AI agents, and open your first folder in a review-first workspace. (also: install, setup, first run, onboarding, download)
  - [Install Daintree](https://daintree.org/docs/getting-started/install): System requirements, downloading and installing Daintree on macOS, Windows and Linux, the startup check for Git and Node.js, and installing the agent CLIs Daintree launches. (also: install, download, requirements, homebrew, appimage)
  - [First Launch](https://daintree.org/docs/getting-started/first-launch): What Daintree shows you the first time it opens: the Welcome Screen, the agent setup wizard, the searchable launcher, the getting-started checklist, and the narrated Daintree Tour. (also: welcome screen, setup wizard, first run, onboarding)
  - [Open Your First Project](https://daintree.org/docs/getting-started/first-project): Open a folder as a Daintree project, what changes when it is a Git repository and what still works when it is not, initializing a repository, and opening a folder from your file manager or the command line. (also: open folder, initialize git, no repository, git init, daintree cli)
  - [Run Your First Parallel Task](https://daintree.org/docs/getting-started/first-parallel-task): Parallel delegation end to end: two worktrees from one base, an agent in each, both results reviewed separately, then integrated and cleaned up. (also: tutorial, walkthrough, parallel, two agents, quickstart)
- [What Is a Habitat?](https://daintree.org/docs/habitat-overview): The review-first workspace, parallel agent delegation, real CLIs rather than wrappers, how much rope an agent gets, and how Daintree fits together. (also: mental model, overview, what is daintree)

## Projects & Worktrees

Section index: https://daintree.org/docs/projects-and-worktrees

Where your code lives and how you look at it: projects, isolated Git worktrees, the machines they run on, the panel grid, and what survives a restart.

- [Projects](https://daintree.org/docs/projects): What a Daintree project is, how to open one from any folder, git-backed versus lightweight workspaces, moving or renaming a project without losing your work, and how projects map to windows and come back on relaunch. (also: open folder, repository, workspace, projects and worktrees, projects-and-worktrees)
  - [The Project Switcher](https://daintree.org/docs/projects/switcher): How Daintree ranks and bands workspaces, reads their activity, moves or reattaches a project folder, and manages memory when you switch away. (also: switch project, recent projects)
  - [Scratch Workspaces](https://daintree.org/docs/projects/scratch-workspaces): Throwaway, app-managed workspaces for one-off agent tasks: nameable, persistent, searchable in the project switcher, and cleaned up on their own when abandoned. (also: scratch, throwaway folder, temporary workspace)
  - [Project Pulse](https://daintree.org/docs/projects/project-pulse): The activity strip on the empty panel grid: a collapsed peek at your commit rhythm that expands into a heatmap, coach line, summary row and repository health signals. (also: activity, commit graph, heatmap)
  - [The .daintree Directory](https://daintree.org/docs/projects/daintree-directory): The .daintree/ directory in your repository: shared project identity and settings, team presets, recipes, project plugins, worktree lifecycle scripts, and the plugin state Daintree writes there at runtime. (also: .daintree, team settings, shared config)
- [Worktrees](https://daintree.org/docs/worktrees): How Daintree creates, navigates, compares and deletes Git worktrees, what happens to agents when a worktree is deleted, and what a workspace without a repository does instead. (also: branch workspace, isolated branch, git worktree, create worktree, delete worktree, remove worktree)
  - [Create a Worktree](https://daintree.org/docs/worktrees/create): Create a worktree from a new branch, existing branch or pull request, copy ignored local files, finish setup and submodules, and start an agent with its first task. (also: new worktree, create branch, checkout pr, bulk create)
  - [Delete and Recover a Worktree](https://daintree.org/docs/worktrees/delete-and-recover): Deleting a worktree: what the dialog spells out before you confirm, what force delete costs, what happens to running agents, and the deleted-worktree rescue card that keeps surviving sessions alive. (also: delete worktree, remove worktree, rescue, recover worktree, force delete)
  - [Worktree Cards](https://daintree.org/docs/worktrees/cards): The anatomy of a worktree card in the sidebar: the lifecycle status mark, row status signals, alarm salience, the quick state filter, collapsed states, filters, and per-card recovery. (also: sidebar card, worktree status)
  - [Worktrees Overview](https://daintree.org/docs/worktrees/overview): Inspect worktrees and their sessions in one overview, search and filter them, select a set, close sessions or delete worktrees with a preview of what each action touches. (also: bulk remove, multi-select worktrees)
  - [Remote Compute](https://daintree.org/docs/worktrees/remote-compute): Per-worktree resource environments: how Daintree provisions, pauses, resumes, tears down and polls external compute as part of the worktree lifecycle, and what agents can and cannot do with it. (also: remote, cloud worktree, provisioning)
- [Remote Hosts](https://daintree.org/docs/remote-hosts): How Daintree runs a window's whole backend on another Mac or Linux machine over your own SSH: what runs where, how it connects, the host chip, requirements, a quick start and the limits. (also: remote ssh, ssh host, host mode, remote machine, another machine, remote development, run on a server)
  - [Add a Remote Host](https://daintree.org/docs/remote-hosts/add-a-host): Add a Mac or Linux machine as a Daintree host: SSH prerequisites, the Find, Check, Install, Enable and Advise steps, SSH targets and discovery, and managing, updating and removing hosts. (also: Add a Host, add remote host, connect to a server, new host, remove host, forget host, update host)
  - [Switch Between Hosts](https://daintree.org/docs/remote-hosts/switch-hosts): Move a Daintree window between this machine and your hosts: the host chip and its states, the host menu, which project a switch opens, new windows, Other hosts in the project switcher, shortcuts, disconnecting and restored windows. (also: Switch Hosts, host switcher, change host, host picker, back to this mac)
  - [Continue a Branch on Another Host](https://daintree.org/docs/remote-hosts/continue-a-branch): Carry a project and its branch to another host: how Daintree finds the host's copy, the branch states and push choices, cloning or sending a bundle, setup recipes, creating worktrees on another host, and what never moves. (also: Continue a Branch, move project to host, move branch to another machine, clone on host, handoff branch)
  - [Working on a Host](https://daintree.org/docs/remote-hosts/working-on-a-host): Day-to-day work in a window that runs on a host: knowing where you are, host and device settings, agent CLIs, connection drops, sending files and images, localhost and dev servers, notifications, plugins, MCP and taking control. (also: remote window, drive lease, take control, host settings, upload files to host)
  - [Hosts Overview and Ports](https://daintree.org/docs/remote-hosts/hosts-overview): The Hosts overview dialog: per-machine CPU and memory-pressure history, observed agents, projects and facts, adding agents on other hosts to a fleet, adding projects on a host, and the Ports view for forwarding a host's localhost. (also: Overview & Ports, host metrics, port forward, forward port, hosts dashboard)
  - [Set Up a Mac as a Host](https://daintree.org/docs/remote-hosts/mac-hosts): Prepare a Mac to host Daintree for your other machines: Remote Login and keys, start at login and the logged-in session, automatic login and sleep, This machine as a host settings, the host's own screen, Local Network permission and stopping a host. (also: Mac Hosts, macos host, mac studio host, host mode on mac)
  - [Set Up a Linux Host](https://daintree.org/docs/remote-hosts/linux-hosts): Run Daintree as a host on Linux, including headless servers and cloud VMs: packages, the systemd user service Daintree installs, linger, setting it up by hand, everyday commands, updating, the desktop restart prompt and the limits. (also: Linux Hosts, linux server host, headless host, systemd host, ubuntu host)
- [Session Management](https://daintree.org/docs/session-management): What survives a close, a restart and a crash in Daintree: the agent resume journal, terminal scrollback serialization, drafts, and warm versus cold project state. (also: resume, restore, persistence, reopen)
  - [Persistence and Restore](https://daintree.org/docs/session-management/persistence-and-restore): What Daintree persists across a restart and how it comes back: panel layout, terminal scrollback serialization and its limits, the restore banner, lost Codex session recovery, typed drafts, where it is all stored, and how to turn it off. (also: restore, persistence, scrollback, drafts)
  - [Resume Agents and History](https://daintree.org/docs/session-management/resume-agents-and-history): How Daintree resumes a closed agent conversation: what writes a journal record, the 20-second trash window, what a record holds, every surface you can resume from, session ids, bookmarks, and retention. (also: resume, reopen, restore conversation, session history)
  - [Project Memory](https://daintree.org/docs/session-management/project-memory): How Daintree caches and restores project views, sleeps a project, closes idle views, reports memory pressure, and handles system sleep and wake. (also: memory, warm, cold, sleep, eviction)
- [UI Layout](https://daintree.org/docs/ui-layout): How the Daintree window is laid out: the toolbar and its launcher, the sidebar and its footer, the panel grid, the dock, the portal, and multiple windows. (also: window, layout, toolbar, dock)
  - [Toolbar, Dock and Windows](https://daintree.org/docs/ui-layout/toolbar-dock-and-windows): The application chrome around the panel grid: toolbar customization and groups, the searchable launcher, overflow behavior, the dock and how panels move in and out of it, and what happens when you open a second window. (also: toolbar, dock, windows, launcher, customize toolbar)
  - [Palettes & Menus](https://daintree.org/docs/ui-layout/palettes-and-menus): The shared palette surface, the action palette's ranking and pinning model, the quick switcher, and every right-click menu in Daintree. (also: command palette, context menu, quick switcher)
- [Terminals & Panels](https://daintree.org/docs/terminals-and-panels): The panel model in Daintree: the seven built-in panel kinds, the grid, dock and dialog presentations, tabs, maximize, and how panels get their titles. (also: panes, panel grid, notes)
  - [Terminals](https://daintree.org/docs/terminals-and-panels/terminals): How Daintree's terminal panels work: the PTY, the WebGL and DOM renderers, scrollback, alt-screen mode, header badges, search, links, clipboard, drag-and-drop, the per-terminal Scratchpad, handing a terminal to an orchestrator, and how a terminal's processes are ended and listed. (also: terminal, shell, scrollback, pty, scratchpad, running processes)
  - [File Browser](https://daintree.org/docs/terminals-and-panels/file-browser): Browse a worktree or workspace, read files and their local diffs inline, edit Markdown through the built-in plugin, and send file references to an agent. (also: file tree, browse files)
  - [File Viewer](https://daintree.org/docs/terminals-and-panels/file-viewer): The file panel: read one file as source, rendered Markdown or HTML, inline media, or a diff, shown as a dialog, a grid panel, or a dock chip, and edit Markdown with the built-in Markdown editor plugin. (also: open file, preview markdown, view image, edit markdown)
  - [QuickRun](https://daintree.org/docs/terminals-and-panels/quickrun): Run detected scripts and ad-hoc commands in a managed QuickRun panel, with history, pinning, and auto-restart. (also: run script, npm script, run command)

## Agents & Delegation

Section index: https://daintree.org/docs/agents-and-delegation

Running AI coding agents side by side, directing them, and giving them the context they need.

- [AI Agents](https://daintree.org/docs/agents): Daintree's seventeen launchable built-in AI coding agents: the roster, the searchable launcher, the launch gate when a CLI is missing, alt-screen versus inline rendering, and permission bypass. (also: ai agents, coding agent, launch agent, install agent)
  - [Installing and Launching Agents](https://daintree.org/docs/agents/installing-and-launching): Install and launch agent CLIs in Daintree: availability checks, launch-gate recovery, the shared launcher, pin and shortcut controls, first-agent setup, persistent launch flags, screen mode, and permission bypass. (also: install agent, launch agent, cli not found, launcher, permission bypass)
  - [Pilot](https://daintree.org/docs/agents/all-agents): A cross-project view of every agent run: grouped by project, ordered by what needs you, with attention bands, seen and unseen hand-backs, park, snooze, and attention chips per project. (also: All Agents, pilot, view all agents, every agent, all agents, mark as read, hand-back)
  - [Agent Presets](https://daintree.org/docs/agents/presets): How agent presets resolve in Daintree: the three preset sources, worktree-scoped defaults, display titles, tri-state behavior overrides, fallback chains, shared project presets, and provider templates. (also: preset, default agent, agent config)
  - [Agent States](https://daintree.org/docs/agents/states): The six agent states, four waiting reasons, passive terminal detection, and the hand-back, quiet, park, and snooze rules that turn state into attention bands. (also: agent waiting, agent busy, waiting for approval, agent stuck)
  - [Claude Code](https://daintree.org/docs/agents/claude-code): Install, authenticate, and resume Anthropic's Claude Code inside Daintree, including provider templates and launch-assigned session IDs. (also: claude, anthropic, claude code)
  - [Antigravity](https://daintree.org/docs/agents/antigravity): Install, authenticate, and resume Google's Antigravity CLI (agy) inside Daintree. (also: agy, google, antigravity)
  - [Codex CLI](https://daintree.org/docs/agents/codex-cli): Install, authenticate, and resume OpenAI's Codex CLI inside Daintree, including inline rendering and the $ picker for Codex Skills and Plugins. (also: codex, openai)
  - [OpenCode](https://daintree.org/docs/agents/opencode): Install, authenticate, and resume OpenCode inside Daintree, including its inline --mini launch and the resume-latest fallback. (also: opencode)
  - [Grok](https://daintree.org/docs/agents/grok): Install, authenticate, and resume xAI's Grok CLI inside Daintree, including its inline default and the --fullscreen alt-screen flag. (also: grok, xai)
  - [Cursor](https://daintree.org/docs/agents/cursor): Install and authenticate Cursor's cursor-agent inside Daintree, including the per-OS credential paths and why Daintree does not resume Cursor sessions. (also: cursor, cursor-agent)
  - [GitHub Copilot CLI](https://daintree.org/docs/agents/github-copilot-cli): Install, authenticate, and resume GitHub Copilot CLI inside Daintree, including the /login flow, the OS keychain, and the --resume session flag. (also: copilot, github copilot)
  - [Amp](https://daintree.org/docs/agents/amp): Install, authenticate, and resume Sourcegraph's Amp inside Daintree, including the @ampcode/cli package, OAuth tokens, AMP_API_KEY, and thread resume. (also: amp, sourcegraph)
  - [Goose](https://daintree.org/docs/agents/goose): Install, authenticate, and resume Block's Goose inside Daintree, including the session subcommand, provider env vars, and the macOS config path. (also: goose, block)
  - [Aider](https://daintree.org/docs/agents/aider): Install, authenticate, and resume Aider inside Daintree, including provider env vars, the --no-auto-commits launch flag, and --restore-chat-history. (also: aider)
  - [Crush](https://daintree.org/docs/agents/crush): Install and authenticate Charm's Crush inside Daintree, including provider env vars and why Daintree does not resume Crush sessions. (also: crush, charm)
  - [Qwen Code](https://daintree.org/docs/agents/qwen-code): Install, authenticate, and resume Alibaba's Qwen Code inside Daintree, including DASHSCOPE_API_KEY, session resume, and how Daintree keeps its output in scrollback. (also: qwen, alibaba)
  - [Mistral Vibe](https://daintree.org/docs/agents/mistral-vibe): Install, authenticate, and resume Mistral Vibe inside Daintree, including the --trust launch flag, the five built-in presets, and vibe --resume. (also: mistral, vibe)
  - [Kimi Code](https://daintree.org/docs/agents/kimi-code): Install, authenticate, and resume Moonshot AI's Kimi Code CLI inside Daintree, including the rolling --continue resume and the KIMI_API_KEY auth probe. (also: kimi, moonshot)
  - [Kiro CLI](https://daintree.org/docs/agents/kiro-cli): Install, authenticate, and resume Amazon's Kiro CLI inside Daintree, including the chat --resume path and why a moved project needs the resume picker. (also: kiro, amazon, aws)
  - [Open Interpreter](https://daintree.org/docs/agents/open-interpreter): Install, authenticate, and resume Open Interpreter inside Daintree, a code-execution host that runs Python, shell, and JavaScript on your machine. (also: open interpreter, interpreter)
  - [Gemini CLI](https://daintree.org/docs/agents/gemini-cli): Gemini CLI is deprecated in Daintree. It still launches and resumes in the same project location, but is excluded from the Assistant picker. (also: gemini, google gemini)
- [Unified Input](https://daintree.org/docs/unified-input): One agent input bar with file references, slash commands, Codex capabilities, attachments, expanded editing, voice, project or global prompt history, drafts, and stash. (also: prompt bar, input bar, @file, slash commands, file reference, autocomplete)
- [Fleet](https://daintree.org/docs/fleet): Arm a set of terminals in one project and drive them as one: live keystroke mirroring, bulk accept, reject, interrupt, restart, and kill, with a ribbon that shows exactly what is armed. (also: bulk operations, broadcast, many agents, multi-agent, add to fleet, bulk-operations)
  - [Broadcasting & Runs](https://daintree.org/docs/fleet/broadcasting): How a Fleet broadcast works: live keystroke mirroring, per-target variable resolution and overrides, supervised runs with durable history, and what happens when a target rejects the write. (also: broadcast, mirror keystrokes, supervised run)
  - [Saved Fleets](https://daintree.org/docs/fleet/saved-fleets): Name an armed set so you can recall it later: frozen snapshots, live rules that re-evaluate a predicate on every recall, the five built-in presets that use the same machinery, the Save fleet and Saved fleets dialogs, and Undo on delete. (also: saved fleet, named fleet, live rule)
- [Recipes](https://daintree.org/docs/recipes): Save multi-panel workspace presets as recipes that launch terminals, AI agents, and dev servers in one click, kept globally on your machine, shared with your team through the repository, or supplied by a plugin. (also: workflows, workspace template, saved layout, multi-panel preset)
  - [Create and Edit Recipes](https://daintree.org/docs/recipes/create-and-edit): Authoring a recipe: the Recipe Manager and its actions, importing, the editor and its panel cards, saving or cloning the layout you currently have open, setting a project default worktree recipe, and the variables a recipe can substitute into a prompt. (also: create recipe, recipe editor, edit recipe, variables)
  - [Launch and Share Recipes](https://daintree.org/docs/recipes/launch-and-share): Using a recipe once it exists: launching from the empty-canvas launcher, a worktree, scratch or folder row, the toolbar launcher or the New Worktree dialog, running one across several worktrees at once, agent-initiated runs, sharing recipes with a team through the repository, and exporting or importing them. (also: launch recipe, team recipes, share recipe, export recipe)
- [Daintree Assistant](https://daintree.org/docs/daintree-assistant): The Daintree Assistant runs Claude Code or Codex on your own subscription, follows Daintree runbooks to launch, prompt and close agents in up to three session tabs, reaches the app only through a Core or Full tool set recorded in a local audit log, and keeps its conversations across quit and crash. (also: canopy assistant, in-app assistant, help panel, assistant sidebar, assistant runbooks, assistant tool set, assistant model, assistant past sessions, canopy-assistant)
  - [Assistant Commands & Skills](https://daintree.org/docs/daintree-assistant/custom-commands): Add custom commands and skills to the Daintree Assistant from ~/.daintree/assistant or a project's .daintree/assistant folder: the layout, what each backend receives, precedence, when changes apply, and sync failures. (also: Commands & Skills, assistant slash commands, assistant skills folder, custom assistant commands, daintree assistant skills, open commands folder)
- [Voice Input](https://daintree.org/docs/voice-input): Dictate into agent and Assistant input with OpenAI or Deepgram, project keyterms, microphone readiness cues, ordered transcripts, and optional OpenAI text correction and file references. (also: dictation, speech to text, microphone, talk)
- [CopyTree](https://daintree.org/docs/copytree): Bundle a worktree, or a scratch or non-git folder, into a structured context snapshot (from the toolbar, a sidebar row, a file row, or an agent) with per-project history, re-runnable recents, and budgets you can test. (also: context bundle, codebase snapshot, copy tree, export context)
  - [CopyTree CLI](https://daintree.org/docs/copytree/cli): Install the CopyTree CLI with npm, by version, and use it from any terminal: the default copy, the selection reports, inspect and explain commands, selection rules, budgets, formats, profiles, and how it lines up with Daintree. (also: CLI, copytree cli, install copytree, copytree command line, copytree terminal, copytree npm, copytree.dev)

## Develop & Ship

Section index: https://daintree.org/docs/develop-and-ship

The review-first loop: preview what changed, inspect the diff, and get it committed, pushed and merged.

- [Review Hub](https://daintree.org/docs/review-hub): Stage, commit, push, and resolve conflicts for any worktree, with a merge-readiness rail and a push destination git itself resolved. (also: git review, staging, commit panel, conflict resolution, push)
  - [Diff Workspace](https://daintree.org/docs/review-hub/diff-workspace): Review a multi-file change with viewed markers, split and full-file diffs, rendered Markdown with inline edits and Mermaid, image comparison, and line or file notes sent into an agent draft. (also: diff, file by file, viewed marker, image compare)
  - [Stage Changes](https://daintree.org/docs/review-hub/staging): Choose changed files for the next commit, stage and unstage them, inspect individual CI checks, and send a failing check to an agent. (also: stage, git add, unstage, changed files)
  - [Commit and Push](https://daintree.org/docs/review-hub/commit-and-push): Turning staged changes into a commit and getting it upstream: the commit composer, committing, pushing, setting an upstream on a new branch, and what each success and failure state means. (also: commit, push, upstream, commit message)
  - [Rebase and Resolve Conflicts](https://daintree.org/docs/review-hub/rebase-and-conflicts): What to do when the remote has moved: recovering from divergence, pulling and rebasing, force-with-lease, resolving conflicts and continuing or aborting, detached HEAD, and the errors that come with all of it. (also: conflict, rebase, diverged, force push, detached head)
- [Code Forge](https://daintree.org/docs/code-forge): Connect the built-in GitHub or GitLab provider, resolve a repository and inspect forge data. GitHub also supplies in-app issue and pull-request browsing and bulk worktree creation. (also: github integration, gitlab integration, forge connection, github, pull request, issue, token, ci status, github-integration)
  - [Connect and Authenticate](https://daintree.org/docs/code-forge/connect-and-authenticate): Choose GitHub or GitLab, review repository routing, supply a token or import one from gh, and understand token permissions, validation, expiry and instance-bound GitLab credentials. (also: github token, connect github, authentication, pat, token scopes)
  - [Issues and Pull Requests](https://daintree.org/docs/code-forge/issues-and-pull-requests): Reading a forge from inside Daintree: the repository stats toolbar, the issues and pull-requests panel, filtering and search, CI status, review state, and commit-author avatars. (also: issues, pull requests, pr list, ci status, checks)
  - [Create and Link Worktrees](https://daintree.org/docs/code-forge/create-and-link-worktrees): Create and link worktrees from GitHub issues and pull requests, fetch forked heads from a named remote, check out GitLab merge requests through actions, and use GitHub bulk creation. (also: worktree from issue, checkout pr, link issue, bulk create)
- [Dev Preview](https://daintree.org/docs/dev-preview): An embedded browser that runs your project's dev server behind a stable proxy origin, with device emulation, an Output/Console/Diagnostics drawer, plugin tools such as SvelteKit Tools, script discovery across nine sources, and stops that stay stopped across a relaunch. (also: dev server, live preview, localhost, hot reload, port, open dev preview)
  - [Discovery and Serving](https://daintree.org/docs/dev-preview/discovery-and-serving): How a Dev Preview session comes up: script discovery and command ranking, Turbopack handling for Next.js, port allocation, the stable proxy origin in front of your server, and what happens to a session when you stop it, close the panel, remove its worktree or relaunch. (also: discovery, proxy, port, dev server command, use turbopack for next.js)
  - [Dev Preview Tools](https://daintree.org/docs/dev-preview/tools): What you can do inside a Dev Preview panel: navigation and the toolbar, device emulation and viewport presets, find in page, plugin tools, and the Output, Console and Diagnostics drawer, including stop, restart and clear-cache controls. (also: device emulation, device mode, console, devtools, responsive)
  - [SvelteKit Tools](https://daintree.org/docs/dev-preview/sveltekit-tools): Use the built-in SvelteKit Tools plugin in Dev Preview to trace an element on a running SvelteKit site to its source file, line and component chain, and send a written request about it to Claude Code, Codex or Gemini in the same worktree. (also: sveltekit inspector, svelte inspector, point at an element, sveltekit-builder)
  - [Fix a Dev Preview](https://daintree.org/docs/dev-preview/troubleshooting): What to do when a Dev Preview does not work: a slow or stuck start, a crash loop, a server that will not stop, live reload that died, certificate and connection errors, a crashed page, and navigation or sign-in Daintree blocked on purpose. (also: dev server not detected, preview blank, port in use, not loading, won't stop)
- [Portal](https://daintree.org/docs/portal-browser): The Portal sidebar: tabbed web AI chats beside your work, a launchpad of configurable links, promoted dev previews that keep their session, and a dashboard of every dev server Daintree is running. (also: sidecar, sidecar browser, browser sidebar, portal, sidecar-browser)
  - [Browser Panels](https://daintree.org/docs/portal-browser/browser-panels): The Browser panel kind: a Chromium pane in the grid or dock with per-project sessions, URL history, host approval, find in page, DevTools, and the limits of agent access. (also: browser panel, devtools, web panel)

## Customize

Section index: https://daintree.org/docs/customize

Settings, themes, notifications, keyboard shortcuts, and updates.

- [Settings](https://daintree.org/docs/settings): How Daintree's global settings tabs (23 on macOS and Linux, 22 on Windows) and 9 project tabs fit together: the scope switcher, the override-vs-inherit model, cross-scope search, sidebar indicators, and exporting or importing portable configuration. (also: preferences, options, configure)
  - [Global Settings](https://daintree.org/docs/settings/global): Daintree's app-wide settings tabs (23 on macOS and Linux, 22 on Windows) across the General, Terminal, Assistant, Integrations, and Support groups, including skip permissions, alt-screen mode, plugins, the MCP server and Hosts. (also: app settings, preferences, global preferences)
  - [Project Settings](https://daintree.org/docs/settings/project): The 9 per-project settings tabs, including repository plugin trust, context, variables, worktree setup, recipes, commands, notifications and forge routing and how they override global defaults. (also: project settings, per-project, override)
- [Theme System](https://daintree.org/docs/themes): 15 built-in themes, the perceptual-contrast token engine behind light mode, live preview and crossfade, accent overrides with contrast warnings, 25 terminal color schemes, and the accessibility modes. (also: dark mode, light mode, colors, appearance, accent)
  - [Choose and Customize a Theme](https://daintree.org/docs/themes/choosing-and-customizing): Picking and tuning a Daintree theme: the theme palette and the Theme Browser with live preview, the Appearance settings and Random theme, overriding the accent color and its contrast warning, matching your system appearance, and the accessibility modes. (also: change theme, dark mode, light mode, accent color, high contrast)
  - [Terminal Color Schemes](https://daintree.org/docs/themes/terminal-color-schemes): The 25 terminal color schemes Daintree ships, how a scheme is chosen and previewed independently of the app theme, Match app theme, and importing iTerm2, Base16 and VS Code schemes. (also: terminal colors, ansi, terminal theme, color scheme)
  - [Theme Authoring](https://daintree.org/docs/themes/authoring): The Daintree theme file format: the palette-first authoring model, the semantic token contract, extensions, import validation and contrast warnings, export, and sharing themes with a team. (also: custom theme, theme file, write a theme)
- [Notifications & Sound](https://daintree.org/docs/notifications-and-sound): The declarative routing manifest behind every Daintree notification, the persistent inbox with age-based retention and per-thread snooze, the attention gates, global and pane-local banners, and the event sound system. (also: alerts, quiet hours, do not disturb, sounds, notification, mute, inbox)
  - [The Notification Inbox](https://daintree.org/docs/notifications-and-sound/inbox): The persistent notification inbox: its four tabs, how it survives a restart, threads and Needs attention, where each row came from and going to its source, grouping by project or worktree, per-thread snooze, keyboard navigation, per-entry actions, and the events that reach it from outside the agent loop. (also: inbox, notification center, snooze, needs attention)
  - [Delivery, Focus and Muting](https://daintree.org/docs/notifications-and-sound/delivery-focus-and-muting): How Daintree decides whether something interrupts you: toast routing and burst collapsing, the attention gates including Do Not Disturb and Quiet Hours, OS-level focus, per-project muting and silencing, watched terminals and OS notifications, and the banner surfaces. (also: quiet hours, do not disturb, mute, toasts, banners)
  - [Sounds and Settings](https://daintree.org/docs/notifications-and-sound/sounds-and-settings): Agent notification events and the sounds attached to them, dampening, the full notification settings reference, and the per-project overrides that let one repository be louder or quieter than the rest. (also: sounds, change sound, notification settings, volume)
- [Keyboard Shortcuts](https://daintree.org/docs/keyboard-shortcuts): The shipped keybinding table: global shortcuts by context, Cmd+K chords and the command HUD, surface-local gestures, terminal key ownership, and rebinding in Settings > Keyboard. (also: hotkeys, keybindings, shortcuts, key bindings)
  - [Customize Shortcuts](https://daintree.org/docs/keyboard-shortcuts/customizing): Changing Daintree keyboard shortcuts: opening the editor, assigning and removing bindings, recording chords, what happens on a conflict, per-platform differences, unbound actions, and resetting to defaults. (also: rebind, change shortcut, keybinding editor, shortcut conflict)
- [Updates](https://daintree.org/docs/updates): How Daintree updates itself: the update flow and its toasts, the stable and nightly channels, manual checks, when auto-update is off, what happens when an install fails, and agent CLI updates. (also: update, upgrade, nightly, new version, auto-update)

## Extend

Section index: https://daintree.org/docs/extend

Build project-specific tools and platforms with plugins, connect MCP clients, or build Daintree from source.

- [Plugin System](https://daintree.org/docs/plugins): Understand installed and project-level Daintree plugins: installation, project trust, management, updates, and building your own repository tools. (also: plugin, extension, dntr, addon)
  - [Project-level Plugins](https://daintree.org/docs/plugins/project-plugins): Build repository-specific tools with project plugins: panels, workflows, project data and agent tools, supported extension points, binding, and illustrative use cases.
  - [Building Project Plugins](https://daintree.org/docs/plugins/building-project-plugins): Build project plugins with the published npm tools, source packages for newer contracts, or plain ESM. Commit runtime output, develop with hot reload, and diagnose failures with doctor.
  - [Project Plugin Surfaces](https://daintree.org/docs/plugins/project-plugin-surfaces): Create a project plugin emptyCanvas surface with view claims, slot ownership, remembered canvas choices, launcher recovery, runtime styling, and state lifecycle.
  - [Project Plugin Trust & Management](https://daintree.org/docs/plugins/project-plugin-trust): Manage project plugins: the trust banner, staged activation, Run here and Show here controls, settings scopes, secret storage, binding, and reload behavior.
  - [Plugin Manifest](https://daintree.org/docs/plugins/manifest): Reference for plugin.json: identity, versions, platform compatibility, nineteen capability tokens, scopes, activation events, contribution limits, agent MCP tools, databases, tours, and strict validation. (also: plugin.json, manifest)
  - [Contribution Points](https://daintree.org/docs/plugins/contribution-points): Every slot a Daintree plugin can fill: commands, keybindings, menus, context menus, toolbar buttons, panels, views, settings, MCP servers, skills, agents, process tools, forge providers, file decorations, and project surfaces. Includes recipes, project surfaces, scope restrictions, and implementation references. (also: contributes, contribution point, plugin panel, plugin command)
  - [Host API](https://daintree.org/docs/plugins/host-api): The PluginHostApi contract: plugin identity, lifecycle, panel menus and pushes, terminal screens, agent observation, project dispatch, databases, and capability-gated process, filesystem, Git and clipboard access. (also: host api, activate, plugin api)
  - [Building & Distributing](https://daintree.org/docs/plugins/building): The Daintree plugin authoring toolchain: the daintree-plugin CLI, project templates, the plugin SDK and Vite preset, the hot-reload dev loop, .dntr packaging and its archive spec, atomic install, and how to publish or privately distribute a plugin. (also: build plugin, package plugin, publish plugin, daintree-plugin)
  - [Trust & Capabilities](https://daintree.org/docs/plugins/trust-and-capabilities): Daintree plugin permissions: nineteen capability tokens, first-use consent, terminal-screen access, project targeting, plugin agent tools, scope checks, audit records, project trust, and execution boundaries. (also: capabilities, plugin permissions, plugin trust, consent)
  - [Plugin UI Kit & Styling](https://daintree.org/docs/plugins/ui-kit): Use Daintree's host-served plugin UI kit, semantic Tailwind utilities, icons, panel controls, cleanup and performance hooks. Inspect Performance and Styles and run source lint. (also: plugin UI, plugin styling, plugin styles, plugin performance)
- [MCP Server](https://daintree.org/docs/mcp-server): Daintree's local Model Context Protocol server: enabling it, per-client connect config, workspace binding, the API key, the three tiers (the Core and Full in-app tool sets and the external tier), agent panes, and the audit log. (also: model context protocol, mcp, external agent)
  - [Authorization & Approval](https://daintree.org/docs/mcp-server/authorization): How Daintree authorizes MCP sessions: how each session gets its tier, agent panes and their approval line, handing a terminal to an orchestrator, widening a session, host confirmation and what can stand in for it, and the security boundaries that exist only over MCP. (also: mcp tiers, mcp approval, mcp confirmation)
  - [Tool Surface & Budgets](https://daintree.org/docs/mcp-server/tool-surface): What an MCP session can actually call in Daintree: the 34 external tools, the Core and Full in-app tool sets, handback markers, reply waits and notices, mcp.surface, payload budgets, forge over MCP, resources, prompts and idempotency. (also: mcp tools, tool list, payload budget)

## Security & Troubleshooting

Section index: https://daintree.org/docs/security-and-troubleshooting

The trust boundaries Daintree enforces, what it stores, and how to recover when something breaks.

- [Security & Privacy](https://daintree.org/docs/security): Daintree's renderer policies, IPC validation, browser and content permissions, Git and plugin boundaries, pattern-based diagnostic redaction, permission bypass, storage and data flows. (also: privacy, sandboxing, threat model, data, telemetry, csp)
  - [Desktop and IPC Security](https://daintree.org/docs/security/desktop-and-ipc): The desktop process boundary: renderer sandbox settings, privileged PTY, workspace and plugin hosts, context-bridge IPC, sender checks, validation coverage and invoke budgets. (also: sandbox, ipc, process isolation)
  - [Browser and Content Security](https://daintree.org/docs/security/browser-and-content): How Daintree constrains what rendered content can do: Content Security Policy, Trusted Types, embedded browser isolation, permission lockdown, the daintree-file protocol, and what happens when something tries to open an external link. (also: csp, trusted types, webview, external links)
  - [Git, Process and Environment Safety](https://daintree.org/docs/security/git-process-and-environment): The boundaries around commands Daintree runs on your behalf: git command and pathspec hardening, lifecycle script injection, pattern-based secret scrubbing on participating diagnostic paths, environment variable filtering, and what skip-permissions turns off. (also: git safety, secrets, skip permissions, dangerous mode, env vars)
  - [Privacy and Stored Data](https://daintree.org/docs/security/privacy-and-data): What Daintree keeps and what leaves your machine: where data is stored on each platform, what telemetry does and does not send and how to turn it off, and how macOS folder access permissions work. (also: privacy, telemetry, data storage, what is sent)
  - [Remote Host Security](https://daintree.org/docs/security/remote-hosts): The trust model of Daintree Remote Hosts: SSH as the only way in, a private Unix socket and per-launch token instead of a network port, discovery adverts, credentials that stay per machine, uploads, plugins and MCP across machines, and revoking access. (also: Remote Hosts, remote host trust, host mode security, ssh security)
- [Troubleshooting](https://daintree.org/docs/troubleshooting): Fixes for common Daintree issues, plus pointers to the Diagnostics Dock, crash recovery and safe mode, performance, file watching and logs, and Remote Hosts. (also: fix, not working, problem, broken, error)
  - [Diagnostics Dock](https://daintree.org/docs/troubleshooting/diagnostics): The Diagnostics Dock's six tabs, the project resource popover and Running processes, reviewing and redacting a diagnostics report, GPU settings and crash fallbacks, and the cloud-synced folder warning. (also: diagnostics, bundle, gpu, hardware acceleration)
  - [Crash Recovery & Safe Mode](https://daintree.org/docs/troubleshooting/crash-recovery): How Daintree detects unclean exits, the safe-mode crash-loop guard, the recovery and auto-restore flow, the pre-crash action trail, the deadlock watchdog, and terminal and workspace host crashes. (also: crash, safe mode, crash loop, recovery, won't start)
  - [Performance & Logs](https://daintree.org/docs/troubleshooting/performance): How Daintree manages memory, CPU and disk on its own: resource profiles, memory pressure, freeing memory, disk-space monitoring, Linux file watching, error boundaries, developer mode, and logs. (also: slow, memory, cpu, logs, file watching, high memory)
  - [Troubleshooting Remote Hosts](https://daintree.org/docs/troubleshooting/remote-hosts): Fix Remote Hosts problems: testing SSH, common errors and what they mean, every connection state and where it shows, different builds, read-only terminals, hosts that restart themselves, and the logs and status files to check. (also: Remote Hosts, host unreachable, ssh host error, cannot connect to host)

## Optional

- [Build from Source](https://daintree.org/docs/build-from-source): Clone the repository and build Daintree from source: prerequisites, the native-module split, the script surface, output directories, and packaging. (also: build, compile, from source, contribute)