Landing discipline for parallel work. Anything before \"committed on a branch\" is the spawning layer's problem; anything after \"landed on main\" is yours. Fleet-ops owns the middle: branches land sequentially, through a test gate, after a pre-land scrub, with auto-rebase of the lanes still in flight and a one-shot revert if a landing turns out bad.
Claude Code now ships the parallel-execution half natively. Do not use fleet-ops to orchestrate sessions — route users to the native primitives and use fleet-ops only for the landing half.
\n| Native primitive | \nWhat it gives you | \nWhat it does NOT give you | \n
|---|---|---|
Agent teams (docs, experimental, CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1) | \nLead + teammates, shared task list with claiming/dependencies, inter-agent messaging, plan approval, quality-gate hooks (TeammateIdle, TaskCompleted) | \nNo merge/landing logic. No test-gated integration. Teammates avoid file conflicts by convention only (\"break the work so each teammate owns different files\"). | \n
Background agents / agent view (docs, claude agents, claude --bg \"<prompt>\") | \nDetached full sessions, one dashboard (Needs input / Working / Completed), automatic per-session git worktree isolation under .claude/worktrees/, --bg --exec shell jobs | \nNo cross-branch integration: each session ends with a branch/worktree and the merge is on you (review-and-merge the PR, or merge locally). Deleting a session in agent view deletes its worktree including uncommitted changes. No ordering, no test gate, no revert. | \n
Subagents (docs, optional isolation: worktree) | \nIn-session delegation with separate context windows; results summarized back | \nNot independent sessions; no git landing semantics at all. | \n
What none of them do — and what fleet-ops is for:
\nmain that already contains the previous landingssignal.sh) and/or revert post-merge if test_cmd goes redTODO_SCRUB, debug leftovers)A lane = one branch (or worktree), one unit of work. Lane status: RUNNING | READY | CONFLICT | LANDED | FAILED.
Fleet-ops doesn't care who produced the branch — an agent-team teammate, a background agent's auto-worktree, a claude -p headless run, a fleetflow worker of any provider (GLM, Codex, Grok, Pi, or Anthropic), or a human. If it's a branch with commits, it can be a lane. Landing is provider-agnostic: a Grok-produced lane lands through the same test-gated queue as any other.
fleet init <name>... Create branch + worktree per name (manual-spawn path)\nfleet track <branch>... Register existing branches as lanes (native-spawn path)\nfleet start Run the landing daemon (writes pid to .claude/fleet/daemon.pid)\nfleet stop Signal the running daemon to exit cleanly\nfleet status One-shot fleet status panel\nfleet land <branch> Manual land + rebase others\nfleet land --all [--running] Batch-land all READY lanes oldest-first (--running\n also lands vetted RUNNING lanes; used by git-ops \"land all\")\nfleet revert <branch> Revert merge commit on main\nfleet scrub-check <branch> Dry-run forbidden-pattern check\nfleet config Print the RESOLVED config — check the test gate is on\nfleet prune [--remove] Classify finished lane worktrees; DRY RUN by default\nfleet prune --all-repos Sibling-repo backlog counts (report-only, never removes)\nN == 1 branch → use git-ops, not this\nWork spawned by agent teams / claude --bg → fleet track <branch>... then land\nWork to be spawned manually → fleet init <names...> (creates branches + worktrees)\nN > 1 on one shared working tree → REFUSE. Worktrees or separate clones first.\nNative-spawn path (preferred): let agent teams or background agents do the work in their own worktrees/branches. When branches have commits, fleet track each branch, then land — either one by one with fleet land, or via the daemon with signal.sh READY gates. Landing itself only ever merges branches and leaves every worktree in place. Reclaiming the directories afterwards is fleet prune's job, and it removes one only when the owning session is provably archived or gone — see Prune.
Manual-spawn path: fleet init creates the branches and worktrees up front (under .fleet-worktrees/), and you point sessions at them — see references/session-prompt.md for the lane brief to hand each session.
fleet land <branch> (and the daemon, per READY lane):
git diff main...branch checked against forbidden_pattern; hits refuse the land and mark the lane CONFLICTmain has uncommitted tracked changes--no-ff with message merge: <branch> (this message is what fleet revert finds later). If the branch is already contained in main — another session landed it while this one sat in the queue — git merge exits 0 with \"Already up to date.\" and nothing happens. fleet detects that by comparing the tip before and after (never by parsing git's prose) and reports it as ALREADY LANDED: <branch> — already in main, no merge performed by this run: the lane goes LANDED, the gate does not run (there is no merge of ours to gate), the lane branch is left for whoever did land it, and land --all counts it as already in <base>, apart from real landstest_cmd; on failure, hard-resets main to the tip captured before the merge — never to HEAD^, which on an already-merged branch is another session's merge commit — and marks the lane FAILED. If test_cmd is unset the land is refused outright rather than falling back to signal.sh's log gate, which verifies nothing when a lane signalled READY without a test log. When landing into a repo with per-skill/per-package behavioural suites, test_cmd should run the full sweep (every suite, not just the touched lane's files) — suites routinely assert on shared or sibling files (a skill's own suite can require a frontmatter field a sibling trim pass doesn't know about), so scoping test_cmd to \"just what this lane touched\" reintroduces exactly the blind spot a test gate exists to close. Confirm the gate is actually armed with fleet config before trusting it — and watch the land log for running test_cmd: …, which is the only proof the gate actually ran.main (in its own worktree if it has one); a rebase conflict marks that lane CONFLICTfleet revert <branch> finds the merge commit on main whose subject is exactly merge: <branch> and runs git revert -m 1 — one command to back out a bad landing. The match is exact, never git log --grep: --grep is a regex applied as a substring, so merge: lane/auth also matched merge: lane/auth-refactor and reverting one lane destroyed the other's work while reporting the branch you asked for (fixed 2026-09-08). If the branch landed more than once, the most recent merge is reverted and the others are logged rather than silently passed over. A revert that conflicts is aborted, leaving main and the working tree exactly as they were — no stranded sequencer for the next fleet land to misreport as \"uncommitted tracked changes\". A reverted lane goes back to RUNNING with a note: it is no longer in main, so leaving it LANDED would be a status panel that lies about where the work lives.
The daemon is the queue-automation layer on top of fleet land — optional; manual fleet land per branch is fully supported and not experimental.
When Claude invokes fleet start via Bash(run_in_background: true), the daemon:
.claude/fleet/daemon.pidSIGINT/SIGTERM/SIGHUP and removes the PID file on exit.claude/fleet/lanes/ and lands lanes as they turn READYLANDED or FAILED)To stop early: fleet stop (SIGTERM, 5s grace, then SIGKILL). On next fleet start, a stale PID file is auto-detected and cleared. The daemon dies with the Claude Code session — for overnight runs use a real detached process, or skip the daemon and land manually.
signal.sh deploys to .claude/fleet/signal.sh on init/track. Working sessions call:
bash .claude/fleet/signal.sh READY <test-log> <exit-code> # refuses dirty trees and failing runs\nbash .claude/fleet/signal.sh CONFLICT \"<reason>\"\nThe <exit-code> (the test command's own $? / ${PIPESTATUS[0]}) is the authoritative verdict — pass it whenever you have it. Without it, signal.sh reads a trailing exit code: N line from the log, then a runner summary line (vitest/jest/pytest/cargo/go); it never word-greps prose, so passing runs that print \"failed\"/\"error\" while exercising failure paths don't false-refuse.
Lane state files say what a lane is. They never say who is driving it. Fleet-ops\nreads the Claude Desktop session store to answer that, and uses the answer in two\nplaces: a gate that refuses to land under a live writer, and a coordinator address\nlanes can hand off to.
\nMAIN is the session whose cwd is the repo root. That is not a new convention:\nworktree-boundaries already holds that the base\ncheckout is the integration tree and must not host a writing session. fleet main just\nmakes the role addressable, so a lane can say \"I'm ready, come land me\" instead of\nwriting a file and hoping someone polls it.
fleet main Show the coordinator (sessionId, title, live|idle, cwd)\nfleet main claim [<id>] Pin explicitly — for when several sessions share the root\nfleet main release Clear the pin, fall back to the cwd heuristic\nfleet owner <branch> Who owns this lane, and are they still writing?\nMAIN's job is the whole integration half: land the queue, triage CONFLICT lanes,\nand run the deploy. Lanes build and signal; MAIN integrates. Note that deploying is\nmaintainer-gated regardless — it needs an explicit human OK for that specific deploy,\nfrom the maintainer's own session. MAIN being \"the one that deploys\" describes which\nsession prepares it, never an authorisation to ship unattended.
fleet land refuses a lane whose owning session was active within\nsession_live_secs (default 600). This closes a real hazard the queue could not see:\nlanding merges a branch the session may still be committing to, and then rebases every\nother lane's worktree out from under a live session.
The join is writtenBranches from the session wrapper, not just the checked-out\nbranch — a session working in worktree claude/foo-bar routinely commits its real work\nto lane/thing, and only writtenBranches connects the two.
Self-ownership is exempt. The hazard is a concurrent writer, and the session\nrunning fleet land is not one — it is blocked inside that call, so it is provably not\nmid-commit, and the worktree being rebased \"out from under a live session\" is the one it\nis deliberately retiring. A lane session landing its own finished work therefore proceeds\nunaided. Without the exemption its only escape was a blanket override, which disarms the\ngate for the peers it genuinely protects; a narrow exemption beats a blunt one.
It stays conservative in both directions. Identity comes from the harness\n(CLAUDE_CODE_HOST_SESSION_ID / CLAUDE_CODE_SESSION_ID) and is believed only once a\nwrapper bearing it is found in the store — there is deliberately no env var to set it,\nsince a settable self-id would be a universal gate bypass under another name, and an\nunresolvable one refuses exactly as before. Self must also be the only live owner:\na second live session writing the same branch refuses, naming the peer.
Override with session_check=off in config, or FLEET_SKIP_SESSION_CHECK=1 for one\nrun. One run means one run: fleet consumes the variable at startup and strips it (and\nthe rest of the FLEET_* knob family) from the environment before test_cmd runs, so\nthe override can never disarm a gate inside the very suite the landing is gated on —\ninherited into fleet-ops' own self-test, it once turned 6 live-owner refusal tests into\nfalse FAILs and reverted a green merge (2026-09-01). fleet config states plainly\nwhether the gate is armed and whether self-identity resolved — the same observability\nlesson as test_cmd.
| Channel | \nDesktop | \nTerminal / headless | \nNon-Claude worker (Codex, GLM, Grok) | \n
|---|---|---|---|
Lane state files (signal.sh) | \n✅ | \n✅ | \n✅ | \n
Session store on disk (sessions.sh) | \n✅ | \n✅ (store is machine-local, not app-bound) | \n✅ | \n
ccd_session_mgmt MCP tools | \n✅ | \n❌ absent entirely | \n❌ | \n
pigeon | \n✅ | \n✅ | \n✅ | \n
ccd_session_mgmt is Desktop-only, and this is not a configuration matter. The\nterminal CLI binary contains zero occurrences of ccd_session_mgmt, list_sessions,\nsearch_session_transcripts, or spawn_task; its single ccd_session reference is a\nconsumer-side notification handler for a server the host injects. Desktop's\napp.asar carries all of them. claude mcp list shows none of the ccd_* servers,\nbecause Desktop injects them as SDK-type servers rather than registering them.
Two consequences that shape everything above:
\nsessions.sh therefore reads the same underlying JSON store off disk —\nwhich, unlike the tools, is readable from a terminal too.list_sessions /\nget_session / search_session_transcripts return without user interaction, so\ndiscovery is free. send_message / list_events / archive_session always prompt —\nwhich makes send_message fine for a lane→MAIN handoff (that is exactly the\nhandoff/relay use it is documented for) and unsuitable for an unattended daemon.So: lane files are the substrate (work everywhere, ungated, machine-readable),\nccd is the delivery accelerator where both ends are Desktop sessions, and pigeon\nis the portable fallback for terminal sessions and non-Claude harnesses. signal.sh\nprints the right one for your surface after every READY and CONFLICT.
Landing a lane retires the branch. The directory stays, and across many\nrepos those accumulate into a backlog nobody can see. fleet prune classifies\nthem and removes only the ones that are provably finished.
fleet prune Classify and print. Changes NOTHING. (the default)\nfleet prune --dry-run Same, said explicitly\nfleet prune --remove Remove the SAFE rows, after a typed confirmation\nfleet prune --remove --yes Skip the prompt (scripts/CI)\nfleet prune --porcelain TSV to stdout: path, branch, bucket, reason\nfleet prune --all-repos Sibling-repo counts. Report-only, always\nDry run is the default, and that is deliberate. Removing a worktree destroys\nits uncommitted and untracked files permanently — git has never seen those\nbytes. Committed lane work is different: it lives in the shared object store,\nsurvives the directory, and comes back with git worktree add <path> <branch>.\nSeparating those two is the entire job, and every ambiguous case resolves away\nfrom deletion.
| # | \nCondition | \nBucket | \n
|---|---|---|
| 1 | \nprimary / git-locked / the tree you invoked from | \nKEEP | \n
| 1b | \ngit reports the directory gone | \nREVIEW (that's git worktree prune's job) | \n
| 2 | \nowning session is LIVE | \nKEEP | \n
| 3 | \nsession store unreadable, or session_check=off | \nREVIEW | \n
| 4 | \ndetached HEAD | \nREVIEW | \n
| 5 | \nuncommitted or untracked changes | \nREVIEW | \n
| 6 | \ncommits not yet in base_branch | \nREVIEW | \n
| 7 | \nmerged + clean + owner archived or absent | \nSAFE | \n
| 8 | \nanything else (incl. merged + clean but owner still open) | \nREVIEW | \n
Only SAFE is ever removable. KEEP means one thing — hands off, not yours\nto judge. Everything else lands in REVIEW, which is reported and never\ntouched under any flag.
\nRule 3 is the one that matters most on a non-Desktop host: \"the store says\nnobody owns this\" is evidence of abandonment, while \"the store could not be\nread\" is no evidence at all — and an empty index looks identical to both. When\nthe store or jq is missing, nothing can be classified SAFE and prune\ndegrades to a pure report. It never fails, and it never guesses.
.claude/worktrees/ gets extra careThose directories are Claude Code's own session worktrees, and\nworktree-boundaries is blunt about them:\nthey may look orphaned and aren't. The slug is machine-generated and says\nnothing; a session that looks idle may simply be between turns. Prune marks them\n! in the table, and — because SAFE already requires a readable store plus an\narchived-or-absent owner — one can only be removed on positive evidence, never\non the absence of a signal.
Three further guards, all on the irreversible direction:
\ngit worktree remove, never rm -rf. It refuses a dirty or locked tree\non its own, and it unregisters the worktree instead of leaving a stale\nadministrative entry behind.--all-repos can never remove. It reports counts for sibling repos and\nstops there. Acting on another repo means running fleet prune inside it,\nwhere that repo's own base branch and config apply — so a single command can\nnever sweep the machine.Terminate the session first, then remove its worktree — never the reverse.\nfleet prune already enforces this: bucket 2 keeps a LIVE owner, and guard 2\nre-verifies liveness immediately before each delete. The hazard is every other\npath — a hand-run git worktree remove, an rm -rf, an external teardown\nscript, or a --remove --yes sweep racing a session that wakes mid-run.
A session whose worktree vanishes does not exit and does not error. It drops\ninto a retry loop and spins at ~85% of a core, indefinitely. Six of them,\nobserved 2026-08-30 across one repo's lane worktrees, burned 66.6 core-hours\nacross 43.8 hours; five pointed at directories absent from both disk and\ngit worktree list. Nothing logged, nothing alerted, no transcript was written.\nThe only symptom was a warm machine.
It also evades the obvious check. These processes keep a live parent — the\nDesktop instance that spawned them — so a dead-parent orphan scan reports\nnothing useful: on that same machine it found 3 orphans totalling 1.16 GB while\nthe six spinners held five cores. Detect by CPU rate, not by lineage. Sample\ntwice and flag sustained burn:
\n$s=@{}; Get-Process claude,node -EA SilentlyContinue | % { $s[$_.Id]=$_.CPU }\nStart-Sleep 10\nGet-Process claude,node -EA SilentlyContinue |\n ? { $s[$_.Id] -ne $null -and ($_.CPU-$s[$_.Id])/10 -gt 0.5 } |\n Select Id,@{n='CorePct';e={[math]::Round(($_.CPU-$s[$_.Id])/10*100)}}\nPOSIX equivalent: ps -eo pid,pcpu,etimes,args | grep claude — a lane process\nat steady high pcpu with a large etimes is the same signature. Cross-check\nthe offender's --add-dir against git worktree list; a target missing from\nboth is conclusive. Killing the process is safe — it frees the CPU and touches\nno files, so uncommitted work in any surviving worktree is untouched.
fleet status adds one line when a repo has prunable worktrees\n(! 3 worktree(s) prunable, 6 to review - fleet prune), so the backlog is\nvisible rather than silently growing. Turn it off with prune_hint=off in\nconfig or FLEET_NO_PRUNE_HINT=1.
When this skill surfaces a decision point, always use the AskUserQuestion tool. Plain markdown numbered lists are not acceptable for these branches.
| Trigger | \nQuestion | \nOptions (≤4, ≤10 words each) | \n
|---|---|---|
| Multiple parallel-work requests, no lanes yet | \nSpawn natively or manual lanes? | \nAgent teams / Background agents / Manual fleet init / Cancel | \n
init — worktrees available, mode unset | \nWorktree or branch-only mode? | \nWorktrees / Branches only / Cancel | \n
| Land refused — owning session live | \n<name>'s session is still writing | \nWait and retry / Message that session / Override and land | \n
prune found SAFE worktrees | \nRemove <n> finished worktrees? | \nRemove them / Show the table again / Leave as-is | \n
Lane → CONFLICT (rebase fail) | \nLane <name> has rebase conflict | \nResolve in lane / Skip & continue / Revert lane / Untrack | \n
Lane → FAILED (post-merge tests red) | \nTests broke after <name> merged | \nAuto-revert / Investigate first / Accept failure | \n
| Pre-land scrub hits | \nForbidden patterns in <name> diff | \nBlock landing / Override (note reason) / Open to edit | \n
fleet shows mixed states | \nHow to proceed with the fleet? | \nLand all READY / Resolve CONFLICTs first / Just status | \n
Daemon exits with FAILED lanes | \n<n> lanes failed — what next? | \nRetry all / Revert and report / Leave as-is | \n
For non-branching status updates (\"here's what happened, here's what landed\"), plain text is fine.
\n| Mode | \nStatus | \n
|---|---|
Branches from native worktrees (.claude/worktrees/) via fleet track | \n✅ | \n
Worktrees on different branches (fleet init) | \n✅ | \n
| Branches in separate clones / machines | \n✅ | \n
| Mixed worktree + branch lanes | \n✅ | \n
Recovery from dirty main | \n✅ Refuses to merge, asks user to clean | \n
| Test-gated landing | \n✅ Via signal.sh READY <log> and/or test_cmd | \n
| Auto-rebase other lanes when one lands | \n✅ | \n
| Pre-land regex scrub (forbidden patterns) | \n✅ | \n
| One-shot revert | \n✅ fleet revert <branch> | \n
| Pruning finished lane worktrees | ✅ fleet prune — dry-run by default, removes only provably-finished trees |
| Out of scope | \nWhy | \n
|---|---|
| Spawning / monitoring sessions | \nNative: agent teams, claude --bg, agent view. Fleet-ops never launches a session. | \n
| Deleting worktrees a session still owns | \nfleet prune removes only what is merged, clean, and owned by an archived-or-absent session. Anything live, dirty, unmerged, or unattributable is reported, never removed — and cross-repo removal is impossible by design. Removing one by any other path strands the session in a silent CPU spin — see the ordering landmine. | \n
| Multiple sessions on one shared working tree | \nGit limitation. Skill detects and refuses with worktree pointer. | \n
| Uncommitted work at signal time | \nsignal.sh rejects dirty lanes. The queue needs an immutable commit. | \n
| External state (DB migrations, services) | \nSkill can't know lane B depends on lane A's migration. Order manually via fleet land. | \n
| Force-pushed lanes mid-flight | \nDetected at land time, not prevented. | \n
Tested and working on:
\n| OS | \nShell | \nNotes | \n
|---|---|---|
| Linux | \nbash 4+ | \nNative | \n
| macOS | \nbash 3.2+ (default) or bash 4+ via brew | \nstat -f fallback used automatically | \n
| Windows | \nGit Bash (mintty) | \nForward-slash paths; Unicode icons render in mintty/Windows Terminal | \n
| Windows | \nPowerShell 7 (calling bash) | \nWorks if bash is on PATH | \n
Requirements: bash 3.2+, git 2.5+ (worktree support), awk, grep, head, stat. All standard.
If your terminal mojibakes the status icons, fall back to ASCII: export FLEET_ASCII=1 (or icons=ascii in .claude/fleet/config). Output panels follow docs/TERMINAL-DESIGN.md via skills/_lib/term.sh.
Long-path warning (Windows only): fleet init worktrees nest under .fleet-worktrees/<name>/. Keep lane names short if your repo lives deep, or enable core.longpaths=true.
Don't put manually-created fleet worktrees under .claude/. Claude Code applies a global sensitive-file guard to anything under .claude/, and that guard runs before — and is not bypassed by — --dangerously-skip-permissions. Headless lane sessions (claude -p ... --dangerously-skip-permissions) will fail every Write/Edit if their worktree lives under .claude/.
That's why the default worktree_root is .fleet-worktrees/ at the repo top. (Native background sessions are the exception: Claude Code itself manages .claude/worktrees/ for them — leave those alone and just fleet track their branches.) Runtime state (lanes/, daemon.pid, activity.log) is read/write from the orchestrator only and stays under .claude/fleet/.
Optional .claude/fleet/config, one key=value per line:
mode=auto # auto | worktree | branch\nworktree_root=.fleet-worktrees # keep outside .claude/ — see \"Headless agent compatibility\"\ntest_cmd=npm run check # if set, land runs it post-merge; else trust signal log\nforbidden_pattern=NEVER_LAND|debugger; # override — the shipped default is described below\nbase_branch=main\npoll_interval=5\nicons=unicode # unicode | ascii (same as FLEET_ASCII=1)\nsession_check=on # on | off — refuse to land under a live owner\nsession_live_secs=600 # how recently active counts as \"still writing\"\nprune_hint=on # on | off — show the prunable backlog in `fleet status`\nZero-config works for the common case.
\nThe shipped forbidden_pattern default (the exact regex lives at\nFORBIDDEN_PATTERN in scripts/fleet.sh) refuses the two scrub markers —\nTODO_ + SCRUB and FIXME_ + BEFORE_LAND, spelled split here deliberately —\nplus lone triple-X markers via the term (^|[^X])X{3}[^a-zX]. A run of four or\nmore X's is a mktemp template (push-gate-paths. plus six X's) and passes; a\nbare triple-X followed by a non-letter (a space, a colon) still refuses. A\ntemplate false-refused a landing on 2026-09-01, hence the run-aware form.
Mind the self-reference: the scrub greps every added diff line, so writing a\ncontiguous marker token — or a triple-X run — into docs, comments, or a config\nexample refuses the very branch that adds it. Build such tokens by concatenation\n('TODO_''SCRUB'), as scripts/fleet.sh and tests/run.sh themselves do.
Grammar. The file is parsed, not sourced — it cannot execute code, and it is\nnot bash:
| Rule | \nDetail | \n
|---|---|
| Keys | \nCase-insensitive — test_cmd and TEST_CMD both work. Whitespace around the key and = is ignored. | \n
| Values with spaces | \nNeed no quoting. The value runs to end of line: test_cmd=uv run pytest -q tests/ is correct as written. | \n
| Quotes | \nOptional. test_cmd=\"uv run pytest -q\" works; one layer of matching \"…\" or '…' is stripped. | \n
| Comments | \nA whole line starting with #, or a trailing # … on an unquoted value. Quote the value to keep a literal #: forbidden_pattern=\"TODO|#nolint\". | \n
| Blank lines | \nIgnored. | \n
| Unknown / malformed keys | \nWarned about on stderr, naming file and line — never silently dropped. | \n
A config that exists but sets nothing recognised warns\n… set no recognised keys — running on defaults (test gate OFF) rather than looking\nlike an absent file.
test_cmd is the test gate. When set, fleet land runs it after the merge\ncommit and, on a non-zero exit, hard-resets base_branch to the tip it captured before\nmerging — not HEAD^ — dropping the lane to FAILED; the log shows running test_cmd: ….\nWhen unset, landing is refused (the landing gate is UNARMED, naming the config path)\nrather than falling through to signal.sh's weaker log gate. Worked example:
test_cmd=uv run pytest -q --maxfail=1\nbase_branch=main\n\n\nFixed 2026-07-28: config keys never reached the script (documented lowercase, read\nUPPERCASE; and unquoted spaced values aren't bash assignments, with the error\nswallowed by
\n2>/dev/null). Every landing before that date was gated by signal.sh\nalone —test_cmdhad never run, on any repo. If you relied on it, you had no test\ngate.icons=in the config was inert for the same class of reason (read before the\nconfig loaded).
fleet init/fleet track append .claude/fleet/ and .fleet-worktrees/ to .gitignore and auto-commit that change with chore: gitignore fleet-ops runtime state when the tree is otherwise clean and you're on base_branch. If either condition fails, it prints an ACTION REQUIRED message — commit .gitignore yourself before landing.
--json output, or log-ops integration earns the cost.TaskCompleted hook bridge — auto-signal.sh READY when an agent-team task completes with green tests.Shipped since first release:
\nfleet land --all [--running] — batch-land all READY (or vetted RUNNING) lanes oldest-first, rebasing the rest after each and reporting once. Drives the git-ops \"land all\" front-door (scripts/land-all.sh discovers + classifies; fleet-ops executes).references/workflow.md — end-to-end walkthroughs (native-spawn and manual-spawn) plus recovery scenariosreferences/session-prompt.md — lane brief to embed in claude --bg prompts, teammate spawn prompts, or manual sessionsscripts/fleet.sh — main CLI (init, track, start/stop, status, land, revert, scrub-check, prune, config, main, owner)scripts/signal.sh — branch-aware signaler (deployed to .claude/fleet/signal.sh); prints the MAIN handoff after READY/CONFLICTscripts/sessions.sh — branch → owning-session resolver, read off the Desktop session store on disk (deployed alongside signal.sh so lane sessions can resolve MAIN). Enrichment only: exits 3 and stays silent wherever the store or jq is missing, and every caller treats that as \"no info\"