Keep wait_agents live and strip leftover fleet ads

The fused task wrapper is gone, so wait_agents is a long-lived parent
tool and spawn_agent progress lasts the worker lifetime. Exec overlay
tests now pin that mountFleet:false drops fleet verbs, not merely the
old task name.

Author: TheGreatAxios

evals/capability/README.md

@@ -183,21 +183,21 @@ change that justifies it.
 
 Flags:
 
-| Flag                                 | Meaning                                                                                                                                                                                                                                                      |
-| ------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| `--case <id\|all>`                   | Case id or `all` (default)                                                                                                                                                                                                                                   |
-| `--provider <name>` / `--model <id>` | Required unless `--matrix`. Single-variant via `loadConfig`. Not inferred from local settings                                                                                                                                                                |
-| `--matrix <cells>`                   | Alternative to `--provider`/`--model`. Multi-variant: `p:m,p2:m2` or `label=p:m` (comma-separated). Every cell must include both sides                                                                                                                       |
-| `--config <path>`                    | Settings file override (CI injection)                                                                                                                                                                                                                        |
-| `--out <path>`                       | Write machine-readable results JSON                                                                                                                                                                                                                          |
-| `--baseline <path>`                  | Compare this run to a prior results file (improve/regress + metric deltas)                                                                                                                                                                                   |
-| `--ask-permissions`                  | Do **not** pass `--dangerously-skip-permissions`                                                                                                                                                                                                             |
-| `--agent-timeout-ms <n>`             | Wall-clock limit for `runExec` (default `1200000`, env `CORBITS_EVAL_AGENT_TIMEOUT_MS`)                                                                                                                                                                      |
-| `--verify-timeout-ms <n>`            | Wall-clock limit for `verify.sh` (default `120000`, env `CORBITS_EVAL_VERIFY_TIMEOUT_MS`)                                                                                                                                                                    |
-| `--repeats <n>`                      | Runs per case×variant cell (default `1`; gate runs use `5`, baseline freezes `3`). Results record every repeat plus per-cell aggregates                                                                                                                      |
-| `--concurrency <n>`                  | Independent case×variant×repeat cells in parallel (default `1`, env `CORBITS_EVAL_CONCURRENCY`). Each cell still uses its own temp workdir. Use `--concurrency 4` (or similar) to run a live matrix faster                                                   |
-| `--dry-run`                          | Load cases × variants and print plan; no inference. Still requires `--provider`/`--model` or `--matrix`                                                                                                                                                      |
-| `--director <id>`                    | Exec overlay: run the product `corbits exec` path with this director's system prompt and initially-advertised tool set (default: skywalker). Eval/CI override, not single-agent mode. Directors that cannot spawn (for example `build`) do not mount `task`. |
+| Flag                                 | Meaning                                                                                                                                                                                                                                                                             |
+| ------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `--case <id\|all>`                   | Case id or `all` (default)                                                                                                                                                                                                                                                          |
+| `--provider <name>` / `--model <id>` | Required unless `--matrix`. Single-variant via `loadConfig`. Not inferred from local settings                                                                                                                                                                                       |
+| `--matrix <cells>`                   | Alternative to `--provider`/`--model`. Multi-variant: `p:m,p2:m2` or `label=p:m` (comma-separated). Every cell must include both sides                                                                                                                                              |
+| `--config <path>`                    | Settings file override (CI injection)                                                                                                                                                                                                                                               |
+| `--out <path>`                       | Write machine-readable results JSON                                                                                                                                                                                                                                                 |
+| `--baseline <path>`                  | Compare this run to a prior results file (improve/regress + metric deltas)                                                                                                                                                                                                          |
+| `--ask-permissions`                  | Do **not** pass `--dangerously-skip-permissions`                                                                                                                                                                                                                                    |
+| `--agent-timeout-ms <n>`             | Wall-clock limit for `runExec` (default `1200000`, env `CORBITS_EVAL_AGENT_TIMEOUT_MS`)                                                                                                                                                                                             |
+| `--verify-timeout-ms <n>`            | Wall-clock limit for `verify.sh` (default `120000`, env `CORBITS_EVAL_VERIFY_TIMEOUT_MS`)                                                                                                                                                                                           |
+| `--repeats <n>`                      | Runs per case×variant cell (default `1`; gate runs use `5`, baseline freezes `3`). Results record every repeat plus per-cell aggregates                                                                                                                                             |
+| `--concurrency <n>`                  | Independent case×variant×repeat cells in parallel (default `1`, env `CORBITS_EVAL_CONCURRENCY`). Each cell still uses its own temp workdir. Use `--concurrency 4` (or similar) to run a live matrix faster                                                                          |
+| `--dry-run`                          | Load cases × variants and print plan; no inference. Still requires `--provider`/`--model` or `--matrix`                                                                                                                                                                             |
+| `--director <id>`                    | Exec overlay: run the product `corbits exec` path with this director's system prompt and initially-advertised tool set (default: skywalker). Eval/CI override, not single-agent mode. Directors that cannot spawn (for example `build`) do not mount `spawn_agent` / `wait_agents`. |
 
 ## Case format
 

plugins/corbits-skills/skills/opsh/SKILL.md

@@ -6,7 +6,7 @@ description: Write scripts using opsh and its built-in libraries. Tiny scripts:
 
 # opsh Scripting
 
-How to write scripts with opsh and its libraries. Tiny / single-file scripts: DIY with write_file/edit_file using these rules. Substantial script work: spawn `spawn_agent(agent="builder")` with these rules copied into the brief (workers do not mount `use_skill`). For a review, spawn `spawn_agent(agent="critic")` (or `spawn_agent(agent="neckbeard")` for hygiene-only) with the same rules copied in.
+How to write scripts with opsh and its libraries. Tiny / single-file scripts: DIY with write_file/edit_file using these rules. Substantial script work: spawn `spawn_agent(agent="builder")` with these rules copied into the brief, then collect with `wait_agents` (workers do not mount `use_skill`). For a review, spawn `spawn_agent(agent="critic")` (or `spawn_agent(agent="neckbeard")` for hygiene-only) with the same rules copied in, then `wait_agents`.
 
 Shell for agent commands is `run_shell`. Bash-the-language in the examples below stays — opsh scripts are bash.
 

src/agent/codex-tool-proxies.ts

@@ -438,7 +438,7 @@ function createUpdatePlanProxy(runManageTasks: CodexRunManageTasks): AgentTool {
       // (pending/in_progress/completed) — this proxy never produces it, so a
       // Codex model cannot cancel a step through update_plan. That is a
       // lossy-but-safe narrowing (dropped, not misrepresented), not a bug fix
-      // for the underlying task tool, which stays out of scope here.
+      // for the underlying manage_tasks tool, which stays out of scope here.
       const tasks = parsed.plan.map((item, i) => ({
         id: `p${i + 1}`,
         title: item.step,

src/agent/profile-types.ts

@@ -62,11 +62,9 @@ export interface AgentProfile {
   // plugin-contributed profiles, or .agents/agents/ for local profiles. When both
   // systemPromptRole and systemPromptPath are set, systemPromptRole wins.
   systemPromptPath?: string;
-  // Orchestrator agents are an explicit exception to the "sub-agents do not
-  // recurse" rule. When true, the dispatch-time appendix grants this profile
-  // permission to call `task` to spawn other agents. Reserved for top-level
-  // coordinators (e.g. a planning agent that fans work out to specialists);
-  // leaf-task agents should leave this unset.
+  // Reserved for future profile-sourced orchestrator support. Today spawn_agent
+  // rejects profile orchestrators because only built-in director packages carry
+  // trusted fleet semantics. Leaf workers should leave this unset.
   orchestrator?: boolean;
   // Where the profile came from, for search_agents labeling (e.g. "claude",
   // "plugin:<id>", "local"). Omitted for built-in defaults.

src/provider/reasoning-effort.ts

@@ -240,7 +240,7 @@ export interface ResolveEffortForRoleOpts {
  *
  * Pins are still highest precedence, but an unsupported pin is clamped so the
  * pure API owns the "never emit an unsupported effort" invariant (callers that
- * want hard-fail on bad pins should validateEffort first, as task-tool does).
+ * want hard-fail on bad pins should validateEffort first, as spawn_agent does).
  */
 export function pickEffortFromCascade(opts: {
   pin?: ReasoningEffort;

src/subagent/agent-fleet.test.ts

@@ -1,4 +1,7 @@
 import { describe, expect, test } from "bun:test";
+import { mkdtemp, readFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 
 import {
   createFleetRecords,
@@ -19,6 +22,7 @@ import { agentLaneIsLive, fleetProgress } from "../tui/agent-progress.js";
 import { AGENTS_PANEL_LINGER_MS, formatAgentsPanel } from "../tui/chrome-state.js";
 import { forcedStopReport } from "./stop-policy.js";
 import type { RunSubAgentParams, RunSubAgentResult } from "./types.js";
+import { INTERVENTION_FILE } from "./intervention-log.js";
 
 const testPermissionGate = createPermissionGate({
   approvals: [],
@@ -384,6 +388,46 @@ describe("spawn_agent same-cwd concurrency", () => {
     gates[0]!.resolve({ report: "one done" });
     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 = [deferred<RunSubAgentResult>(), deferred<RunSubAgentResult>()];
+    let callIndex = 0;
+    const deps = makeDeps(async () => gates[callIndex++]!.promise, { cwd: "/repo" });
+    deps.getWorkdirBase = () => dir;
+    const spawn = createSpawnAgentTool(deps);
+
+    await callTool(spawn, {
+      description: "build one",
+      prompt: "implement thing one",
+      intent: "implement",
+    });
+    await callTool(spawn, {
+      description: "build two",
+      prompt: "implement thing two",
+      intent: "implement",
+    });
+
+    const path = join(dir, INTERVENTION_FILE);
+    let log = "";
+    for (let i = 0; i < 50; i++) {
+      try {
+        log = await readFile(path, "utf8");
+        if (log.includes("concurrent-lane-overlap")) break;
+      } catch {
+        // append is fire-and-forget
+      }
+      await new Promise((resolve) => setTimeout(resolve, 20));
+    }
+    expect(log).toContain("concurrent-lane-overlap");
+    expect(log).toContain("conflict");
+    expect(log).toContain("/repo");
+    expect(log).toContain("build one");
+    expect(log).toContain("build two");
+
+    gates[0]!.resolve({ report: "one done" });
+    gates[1]!.resolve({ report: "two done" });
+  });
 });
 
 describe("fleetRecords retention cap", () => {

src/subagent/agent-fleet.ts

@@ -87,6 +87,7 @@ import {
 
 import { formatSubAgentSpawnAuthFailureMessage } from "./inference-auth-failure.js";
 import { isSubAgentCancelError } from "./dispose.js";
+import { createInterventionLog, type InterventionSink } from "./intervention-log.js";
 
 const log = getLogger([LOG_NAMESPACE_ROOT, "subagent", "agent-fleet"]);
 
@@ -592,6 +593,23 @@ function resolveAgentDispatch(input: {
 
 export function createSpawnAgentTool(deps: AgentFleetDeps): AgentTool {
   const telemetry = deps.telemetry ?? NOOP_TELEMETRY;
+  // Concurrent-lane overlap detection, replacing the static per-package
+  // writePaths lock. There is no field in the spawn_agent contract a caller
+  // uses to declare which files a dispatch will touch, so the only honestly
+  // knowable "intended scope" at spawn is the working directory the dispatch
+  // 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.
+  const activeLanes = new Map<string, { description: string; cwd: string }>();
+  let conflictLog: InterventionSink | null = null;
+  const recordConflict = (event: Parameters<InterventionSink>[0]): void => {
+    conflictLog ??= createInterventionLog(deps.getWorkdirBase(), { role: "parent" });
+    conflictLog(event);
+  };
   return tool({
     definition: spawnAgentToolDefinition,
     handler: async (call, _signal): Promise<ToolResult> => {
@@ -845,6 +863,27 @@ export function createSpawnAgentTool(deps: AgentFleetDeps): AgentTool {
         }
       };
 
+      // Detect, don't lock: warn when another lane still running right now
+      // is already working in this same cwd. Worktree-isolated lanes never
+      // collide here (each gets its own directory); this only fires in the
+      // shared-cwd fallback, where two lanes genuinely can overwrite each
+      // other's writes. Never blocks the spawn — the least destructive
+      // response that still tells the operator something true, since a
+      // shared cwd does not by itself prove the two lanes touch the same
+      // files, only that they could.
+      const laneCwd = worktreeCwd ?? deps.cwd;
+      for (const [otherId, other] of activeLanes) {
+        if (other.cwd !== laneCwd) continue;
+        recordConflict({
+          id: "concurrent-lane-overlap",
+          class: "conflict",
+          detail:
+            `"${description}" (${call.id}) and "${other.description}" (${otherId}) ` +
+            `are both running against ${laneCwd} at once`,
+        });
+      }
+      activeLanes.set(call.id, { description, cwd: laneCwd });
+
       const params: RunSubAgentParams = {
         // Name the trace directory after the session-store id so the
         // descendant-scoping check behind read_agent_trace can resolve this
@@ -978,6 +1017,7 @@ export function createSpawnAgentTool(deps: AgentFleetDeps): AgentTool {
           deps.sessions.fail(session.id, failReason);
         })
         .finally(() => {
+          activeLanes.delete(call.id);
           finalizeEnd();
           if (!keepWorktreeAlive) void reclaimWorktree();
         });

src/telemetry/feedback.ts

@@ -173,7 +173,7 @@ export function getLastTurnTraceId(): string | undefined {
 
 /**
  * Remember the in-flight turn's `$ai_trace_id` so `subagent_end` can link to the
- * turn that is still running when `task` / `spawn_agent` dispatch (not the
+ * turn that is still running when `spawn_agent` dispatch (not the
  * previous completed turn).
  */
 export function noteCurrentTurnTraceId(traceId: string): void {

src/tui/agent-progress.test.ts

@@ -153,7 +153,7 @@ describe("agentProgress", () => {
 
   test("default stall window tolerates a multi-minute Grok think gap", () => {
     // DEFAULT_STALL_MS is 300s — 180s of quiet with no tool outstanding must
-    // still read working, or Task rows false-stall on healthy Responses thinks.
+    // still read working, or worker/spawn_agent rows false-stall on healthy Responses thinks.
     const progress = agentProgress({ ...base, currentToolName: null, lastActivityAt: 0 }, 180_000);
     expect(progress?.state).toBe("working");
     expect(progress?.stalled).toBe(false);