Gate lane-overlap warnings on live session-store status

Cancel can stamp finishedAt before the run promise settles and
reaches finally, so an activeLanes map entry alone was enough to
emit concurrent-lane-overlap against a worker that was already
terminal. Overlap checks now trust pending_init/running from the
session store, prune terminal or absent map entries opportunistically,
and keep the finally delete.

Author: TheGreatAxios

docs/IMPLEMENTATION.md

@@ -167,7 +167,7 @@ Sixteen packages under `src/agent/directors/<id>/` register in `DIRECTOR_REGISTR
 
    **Codex tool proxies.** When the active provider is Codex (`isCodexProviderName`), `createAgentToolset` and `runSubAgent` mount `apply_patch`, `shell`, and `update_plan` stringTools from `createCodexToolProxies`, all forwarding through the same posix `ToolRunner` seam (`runTool`) so permission plugins still apply. `apply_patch` parses the Codex envelope and forwards each op (`write_file` / `delete_file` / `read_file`). `shell` — the native Codex name is `shell`, not `exec_command` — normalizes Codex's `command` (string or `["bash","-lc",script]`-style argv array), `workdir`, and `timeout_ms` onto `run_shell`'s `{command, cwd?, timeout?}` and is gated by `allowShellFromCapabilities` (mirrors `allowDeleteFromCapabilities` against `run_shell`). `update_plan` maps Codex's `plan: [{step, status}]` onto `manage_tasks(action: "create")`; `pending`/`in_progress`/`completed` map to `todo`/`doing`/`done` — `manage_tasks`'s `cancelled` status has no Codex equivalent and is never produced by this proxy. Primary strips `apply_patch` after mount (Corbits DIY stays on `write_file` / `edit_file` / `delete_file`); `shell` and `update_plan` stay on primary (same classification as `run_shell` / `manage_tasks`). Build and docs worker allowlists (`BUILD_TOOLS` / `DOCS_TOOLS`) include `apply_patch` so Codex workers keep the proxy after the capability filter. `CORE_TOOL_NAMES` does not list it.
 
-6. There is no static write-path declaration on packages or profiles (CL-6952 removed it — no shipped director ever set one). Instead, `agent-fleet.ts` tracks each running dispatch by cwd; a new dispatch that lands on the same cwd as a still-running lane records a `concurrent-lane-overlap` entry in `intervention-log.ts` (class `conflict`). This is advisory only — it never blocks the spawn, since cwd overlap does not prove the two lanes touch the same files.
+6. There is no static write-path declaration on packages or profiles (CL-6952 removed it — no shipped director ever set one). Instead, `agent-fleet.ts` tracks each running dispatch by cwd; a new dispatch that lands on the same cwd as a lane whose session-store lifecycle is still `pending_init` or `running` records a `concurrent-lane-overlap` entry in `intervention-log.ts` (class `conflict`). Terminal-but-unsettled lanes (for example cancelled with `finishedAt` set while the run promise has not reached `finally`) are pruned from the map and do not warn. This is advisory only — it never blocks the spawn, since cwd overlap does not prove the two lanes touch the same files.
 7. Spawn effort: pin > package `modelRole` default (`defaultEffortForDirector`; intern=low; plan/review/orchestrator=high; implement/explore/docs/test=medium) > orchestrator/worker binary > parent inheritance. Optional skills are listed in the identity header for awareness; workers do not mount `use_skill` (guidance is baked into package system prompts). Primary mounts `use_skill` for its own skill list.
 
 Intent defaults: `intent=implement` → director `builder`; `explore` → `explorer`; `plan` → `counsel`; `review` → `critic`; general → error. Spawn: skywalker full fleet; greybeard intern/explorer/critic only; all other directors mount no fleet tools. Live `<env>` injects cwd, platform, arch, runtime, date, and git status on every chat and worker prompt.

src/subagent/agent-fleet.test.ts

@@ -664,6 +664,45 @@ describe("spawn_agent same-cwd concurrency", () => {
     defined(gates[1]).resolve({ report: "two done" });
   });
 
+  test("a terminal but unsettled shared-cwd lane does not conflict with a later spawn", async () => {
+    const dir = await mkdtemp(join(tmpdir(), "fleet-overlap-terminal-"));
+    const gates = [
+      deferred<RunSubAgentResult>(),
+      deferred<RunSubAgentResult>(),
+    ];
+    let callIndex = 0;
+    const deps = makeDeps(async () => defined(gates[callIndex++]).promise, {
+      cwd: "/repo",
+    });
+    deps.getWorkdirBase = () => dir;
+    const spawn = createSpawnAgentTool(deps);
+
+    const first = await callTool(spawn, {
+      description: "build one",
+      prompt: "implement thing one",
+      intent: "implement",
+      success_criteria: ["thing one ships"],
+    });
+    const firstId = first.agent_id as string;
+    expect(deps.sessions.cancel(firstId)).toBe(true);
+    expect(deps.sessions.get(firstId)?.finishedAt).toBeNumber();
+
+    await callTool(spawn, {
+      description: "build two",
+      prompt: "implement thing two",
+      intent: "implement",
+      success_criteria: ["thing two ships"],
+    });
+    await new Promise((resolve) => setTimeout(resolve, 50));
+
+    await expect(
+      readFile(join(dir, INTERVENTION_FILE), "utf8"),
+    ).rejects.toThrow();
+
+    defined(gates[0]).resolve({ report: "one cancelled" });
+    defined(gates[1]).resolve({ report: "two done" });
+  });
+
   test("two concurrent shared-cwd spawn_agent lanes log concurrent-lane-overlap", async () => {
     const dir = await mkdtemp(join(tmpdir(), "fleet-overlap-"));
     const gates = [

src/subagent/agent-fleet.ts

@@ -868,10 +868,10 @@ export function createSpawnAgentTool(deps: AgentFleetDeps): AgentTool {
   // will run in — worktree-isolated lanes always get a fresh, disjoint path
   // here, so this can only ever fire in the shared-cwd fallback, which is
   // exactly where two lanes really can stomp each other's writes.
-  // Keyed by call.id so a completed lane (removed when the worker settles)
-  // is never mistaken for one still running: sequential dispatches to the
-  // same cwd are always clean. Tracking lasts the worker lifetime, not the
-  // immediate spawn_agent return.
+  // Keyed by call.id for finally cleanup. The session store is authoritative
+  // for liveness: cancel (and other terminals) can stamp finishedAt before the
+  // run promise settles and reaches finally, so a map entry alone is not proof
+  // the lane is still working.
   const activeLanes = new Map<string, { description: string; cwd: string }>();
   let conflictLog: InterventionSink | null = null;
   const recordConflict = (event: Parameters<InterventionSink>[0]): void => {
@@ -1244,6 +1244,15 @@ export function createSpawnAgentTool(deps: AgentFleetDeps): AgentTool {
           // files, only that they could.
           const laneCwd = worktreeCwd ?? deps.cwd;
           for (const [otherId, other] of activeLanes) {
+            const otherSession = deps.sessions.get(otherId);
+            if (
+              otherSession === undefined ||
+              (otherSession.lifecycle.state !== "pending_init" &&
+                otherSession.lifecycle.state !== "running")
+            ) {
+              activeLanes.delete(otherId);
+              continue;
+            }
             if (other.cwd !== laneCwd) continue;
             recordConflict({
               id: "concurrent-lane-overlap",