Skip to main content

Coming From Another Tool

A map for switching from another agent workspace such as Orca, Conductor or herdr: where worktree setup and archive scripts, copied local files, dependencies, launch flags, keybindings and remote machines live in Daintree, and where Daintree behaves differently.

Reviewed

Coming from another tool

If you already run agents in parallel in another workspace app, such as Orca, Conductor or herdr, most of what you set up there has a direct equivalent in Daintree: a worktree per task, scripts that prepare and clean up each worktree, ignored files copied into new ones, launch flags, keybindings and remote machines. This page maps each of them to where it lives here, and says plainly where Daintree behaves differently.

Daintree has no importer for other tools' files, on purpose. Their formats move: Conductor, for one, now keeps its settings inside the app and reads its old conductor.json only once, to import it. An importer written against them would already be out of date, and other tools' files move the same way. The map below is the stable part: carry a setup across with it by hand, or with the Daintree Assistant. Nothing on this page reads, moves or changes the other tool's files, or your agent CLIs' own configuration.

What maps to what

What you hadIn Daintree
A workspace or worktree per taskA worktree per task: its own branch and checkout, with the task's agent launched in it.
A setup script (Conductor's setup script, Orca's scripts.setup)setup in .daintree/config.json: commands run in order from the new worktree's root after it is created.
An archive script (Conductor's archive script, Orca's scripts.archive)teardown in the same file. It runs before git worktree remove, the slot an archive script fills.
A .worktreeinclude list of ignored files to copyThe same .worktreeinclude file at the repository root, in .gitignore syntax, so Conductor's patterns carry over as they are. Orca's entries are literal paths from the repository root, and in .gitignore syntax a bare .env also matches in subfolders, so write /.env to keep to the root file. There is no default list: if you relied on Conductor copying .env* without one, write .env* into the file.
A setup script that reinstalls dependencies, or shared directories (Orca's worktree.sharedDirectories)cloneIgnored in .daintree/config.json: ignored directories such as node_modules, cloned copy-on-write from the main checkout into each new worktree. Unlike Orca's symlinked shared directories, each worktree gets its own copy of the files, so a change in one doesn't reach the others. Symlinks inside the tree still point where they did.
A Run button, actions or quick commandsDev Preview for a dev server, QuickRun pinned commands for other one-off tasks, and recipes for a set of panels launched together.
Workspace variables such as CONDUCTOR_ROOT_PATH or ORCA_ROOT_PATHDAINTREE_PROJECT_ROOT, DAINTREE_WORKTREE_PATH, DAINTREE_WORKTREE_NAME, and DAINTREE_BRANCH when the branch is known.
Launch flags, models and environment for an agentAgent presets, which a team can share from .daintree/presets/.
Custom keybindingsSettings > Keyboard, kept as a shortcut profile you can export and import.
Saved remote machines and SSH targetsRemote Hosts, added by SSH target or ~/.ssh/config alias from macOS or Linux.
Plugins or extensionsDaintree plugins. Another tool's plugins don't load here.

Translating a worktree config

Most of the work is the setup and archive scripts. Take an orca.yaml like this one, which installs dependencies, copies the main checkout's .env and stops containers on the way out:

scripts:
  setup: |
    npm install
    cp "$ORCA_ROOT_PATH/.env" .env
  archive: |
    docker compose down

In Daintree it becomes two files at the repository root. .daintree/config.json:

{
  "cloneIgnored": ["node_modules"],
  "setup": ["npm install"],
  "teardown": ["docker compose down"]
}

and .worktreeinclude:

/.env
  • Each command becomes one entry in its list. The entries run in sequence, and the first failure skips the rest. Each entry runs in its own shell, so a cd, export or variable set in one doesn't carry into the next. Commands that share state, and scripts with branches or loops, are easier to keep as a file in the repository, called from setup as one entry.
  • Copying a local file becomes a .worktreeinclude line. A file is copied only when it matches a pattern and Git ignores it in the main checkout, so tracked files never come across, and a file already in the new worktree is never overwritten. Make sure the branches you work on ignore it too, or a copied secret turns up as a new file to commit. Without a .worktreeinclude, nothing is copied: there is no default list, so name .env and its variants explicitly. The files are copied before setup runs, so .env is already in place for the install.
  • Reinstalling becomes a clone. cloneIgnored gives each new worktree a copy-on-write clone of the main checkout's node_modules before setup runs, so the install starts from a populated tree rather than an empty one. Keeping npm install in setup covers the cases where the clone is skipped, and picks up any dependency the new branch changed.
  • Workspace variables change name. $ORCA_ROOT_PATH and $CONDUCTOR_ROOT_PATH become $DAINTREE_PROJECT_ROOT. A command can also use the template form {{project_root}}, which Daintree substitutes and shell-escapes before running it (see Template variables).

Commit .daintree/config.json and .worktreeinclude so everyone on the project gets the same setup. Steps that belong only to your machine go in your own copy of the file under ~/.daintree/projects/ instead (see Script priority order).

Where Daintree differs

  • Repository commands wait for you. A .daintree/config.json in the repository can arrive on any branch, so its commands don't run until you approve them. When a new worktree's setup needs commands you haven't approved, it pauses once the worktree is created, with Review commands on its card, and the dialog lists the commands before any of them runs. Approval covers those exact command lines and asks again when they change. It doesn't cover the scripts they call, so review changes to those yourself. cloneIgnored and .worktreeinclude run no commands from the repository, so they need no approval. See Approving repository commands.
  • Setup has a time budget. All of a worktree's setup commands share 120 seconds. Teardown commands share 120 seconds on a normal delete and 15 on a force delete. A full dependency install on a large project is the usual casualty, which is one more reason to let cloneIgnored carry node_modules. See Timeouts.
  • Scripts don't get your shell. Lifecycle commands run non-interactively under an allowlisted environment: PATH, HOME and a few others, plus your project's variables. Aliases, shell functions and version-manager setup from .zshrc or .bashrc aren't there. See The script environment is an allowlist.
  • One config file wins. Daintree reads your user-level file, then the worktree's, then the repository's, and the first valid one is used whole. Nothing is merged, so a user-level file with only setup in it drops the repository's teardown.
  • Clones are copy-on-write or nothing. cloneIgnored needs the main checkout and the worktree on one volume that supports copy-on-write: APFS on macOS, or a Linux filesystem with reflinks, such as Btrfs or XFS, with a cp that supports --reflink=always. Elsewhere, Windows included, the directory is skipped rather than replaced by a full copy, and setup still runs.
  • No port per worktree. Lifecycle scripts aren't handed a port range. A dev server started from Dev Preview gets a port allocated for each session in PORT, and a plain Vite, SvelteKit, Astro or Nuxt command also gets the port flag added. Drop --port $CONDUCTOR_PORT from a server that reads PORT or is one of those. A compound command, or a package script that ignores PORT, still needs --port $PORT or its equivalent.
  • Teardown never blocks a delete. A failing teardown is logged and the worktree is removed anyway, and a teardown you haven't approved is skipped rather than holding the delete.

Launch flags, keybindings and remote machines

Launch flags. Daintree runs the agent CLIs you already have installed, and they read their own configuration and sign-in as usual, so nothing about the CLI itself needs migrating. The flags, model and environment you passed at launch go into a preset: open Settings > CLI agents, pick the agent, and use Add preset in its Launch preset section. To give a whole team the same presets, commit them as JSON under .daintree/presets/<agentId>/ (see Shared Project Presets). Keep credentials out of a shared preset: its JSON is committed as written, so configure API keys locally instead.

Keybindings. Another tool's keymap file doesn't load here. Rebind the ones you rely on in Settings > Keyboard, then export a shortcut profile to keep them. A profile holds only your changes, so it carries across Daintree releases (see Shortcut profiles).

Remote machines. Remote Hosts runs a project's agents on another Mac or Linux machine from this window, with Daintree running in Host mode on that machine. From macOS or Linux, add each one by SSH target, which can be an alias from your ~/.ssh/config: the alias brings its host name, user, port, key and jump host with it, so a machine you already reach by alias needs no connection details re-entered (see Add a Host).

Let the Assistant translate it

The Daintree Assistant searches these docs by default (the Search documentation setting, see The three MCP servers), so it can do the translation with this page as its reference. Open it in the project and ask, for example:

Read /path/to/shop/orca.yaml, and /path/to/shop/.daintree/config.json and
/path/to/shop/.worktreeinclude if they exist. Using the Daintree docs page
Coming From Another Tool, print merged drafts of both files and list anything
in orca.yaml that has no Daintree equivalent. Don't write anything yet.

Use full paths: the Assistant's session starts in a folder of its own, not in your project, so a relative path would point at the wrong place. Once you have read the drafts, ask it to save them or save them yourself. Claude Code can read files in your project, and its writes there follow your Claude Code permission settings. Codex follows its own sandbox, which may not let it write into the project.

Note

Read the drafts before you commit them. A config the Assistant writes is still a repository file, so its commands wait on Review commands like any other before the first worktree runs them.