@selesai/code 0.13.2 → 0.13.4

package/dist/extensions/pi-intercom/intercom.integration.test.ts

@@ -1672,59 +1672,7 @@ test("intercom tool result hook marks failed details as errors", async () => {
   assert.deepEqual(okResults.filter(Boolean), []);
 });
 
-test("lazy tool visibility reveals intercom on bundled skill use only", { concurrency: false }, async () => {
-  const { default: piIntercomExtension } = await import("./index.ts");
-
-  await withIntercomConfig({ toolVisibility: "after-first-use" }, () => withChildOrchestratorEnv({
-    orchestratorTarget: "orchestrator",
-    runId: "78f659a3",
-    agent: "worker",
-    index: "0",
-  }, async () => {
-    const harness = createExtensionHarness("lazy-skill-worker", { activeTools: ["read", "bash"] });
-    piIntercomExtension(harness.pi as never);
-
-    try {
-      await harness.emitLifecycle("session_start");
-      assert.deepEqual(harness.getActiveTools(), ["read", "bash", "contact_supervisor"]);
-
-      harness.pi.events.emit("subagent:control-intercom", {
-        to: "session-child-test",
-        message: "Local relay traffic should not reveal the generic tool.",
-      });
-      assert.equal(harness.sentMessages.at(-1)?.activeTools.includes("intercom"), false);
-      assert.equal(harness.getActiveTools().includes("intercom"), false);
-
-      await harness.emitLifecycle("tool_result", {
-        toolName: "read",
-        input: { path: path.join(repoDir, "README.md") },
-        isError: false,
-      });
-      await harness.emitLifecycle("tool_result", {
-        toolName: "read",
-        input: { path: path.join(repoDir, "skills", "pi-intercom", "SKILL.md") },
-        isError: true,
-      });
-      assert.equal(harness.getActiveTools().includes("intercom"), false);
-
-      await harness.emitLifecycle("tool_result", {
-        toolName: "read",
-        input: { path: path.join(repoDir, "skills", "pi-intercom", "SKILL.md") },
-        isError: false,
-      });
-      assert.deepEqual(harness.getActiveTools(), ["read", "bash", "contact_supervisor", "intercom"]);
-
-      await harness.emitLifecycle("session_start");
-      assert.equal(harness.getActiveTools().includes("intercom"), false);
-      await harness.emitLifecycle("input", { text: "  /skill: pi-intercom", source: "user" });
-      assert.equal(harness.getActiveTools().includes("intercom"), true);
-    } finally {
-      await harness.emitLifecycle("session_shutdown");
-    }
-  }));
-});
-
-test("lazy tool visibility reveals intercom before broker injection and after an overlay send", { concurrency: false }, async () => {
+test("obsolete toolVisibility config never hides or reveals the intercom tool", { concurrency: false }, async () => {
   const { default: piIntercomExtension } = await import("./index.ts");
 
   await withIntercomConfig({ toolVisibility: "after-first-use" }, async () => {
@@ -1754,14 +1702,14 @@ test("lazy tool visibility reveals intercom before broker injection and after an
       piIntercomExtension(inboundHarness.pi as never);
       await overlayHarness.emitLifecycle("session_start");
       await inboundHarness.emitLifecycle("session_start");
-      assert.equal(overlayHarness.getActiveTools().includes("intercom"), false);
-      assert.equal(inboundHarness.getActiveTools().includes("intercom"), false);
+      assert.equal(overlayHarness.getActiveTools().includes("intercom"), true);
+      assert.equal(inboundHarness.getActiveTools().includes("intercom"), true);
 
       selectedSession = await waitForSessionByName(planner, "planner");
       const inboundSession = await waitForSessionByName(planner, "lazy-inbound-worker");
       const delivered = await planner.send(inboundSession.id, {
-        messageId: "lazy-inbound-message",
-        text: "Reveal intercom before injecting this message.",
+        messageId: "stable-inbound-message",
+        text: "Keep intercom active before injecting this message.",
       });
       assert.equal(delivered.delivered, true);
       const deadline = Date.now() + 1000;
@@ -1770,6 +1718,13 @@ test("lazy tool visibility reveals intercom before broker injection and after an
       }
       assert.equal(inboundHarness.sentMessages[0]?.activeTools.includes("intercom"), true);
 
+      await inboundHarness.emitLifecycle("tool_result", {
+        toolName: "read",
+        input: { path: path.join(repoDir, "skills", "pi-intercom", "SKILL.md") },
+        isError: false,
+      });
+      assert.equal(inboundHarness.getActiveTools().includes("intercom"), true);
+
       await overlayHarness.commands.get("intercom")!("", overlayHarness.ctx);
       assert.equal(overlayStep, 2);
       assert.equal(overlayHarness.getActiveTools().includes("intercom"), true);
@@ -3148,6 +3103,43 @@ test("intercom reply sends attachments", { concurrency: false }, async () => {
   }
 });
 
+test("intercom send refuses a different target during an active inbound ask turn", { concurrency: false }, async () => {
+  const { planner, orchestrator, cleanup } = await setupClients();
+  const { default: piIntercomExtension } = await import("./index.ts");
+  const harness = createExtensionHarness("cwd-reply-worker");
+
+  try {
+    piIntercomExtension(harness.pi as never);
+    await harness.emitLifecycle("session_start");
+    const worker = await waitForSessionByName(planner, "cwd-reply-worker");
+
+    assert.equal((await planner.send(worker.id, {
+      messageId: "cwd-hierarchy-ask",
+      text: "Please answer me, not the repo-root session.",
+      expectsReply: true,
+    })).delivered, true);
+    const deadline = Date.now() + 1000;
+    while (harness.sentMessages.length === 0 && Date.now() < deadline) {
+      await new Promise((resolve) => setTimeout(resolve, 20));
+    }
+    await harness.emitLifecycle("turn_start");
+
+    const intercomTool = harness.tools.find((tool) => tool.name === "intercom")!;
+    const result = await intercomTool.execute("misdirected-send", {
+      action: "send",
+      to: "orchestrator",
+      message: "This was meant as the ask answer.",
+    }, new AbortController().signal, undefined, harness.ctx);
+
+    assert.equal(result.details?.error, true);
+    assert.equal(result.details?.replyTo, "cwd-hierarchy-ask");
+    assert.match(result.content[0]?.text ?? "", /Refusing non-reply send to "orchestrator"/);
+  } finally {
+    await harness.emitLifecycle("session_shutdown");
+    await cleanup();
+  }
+});
+
 test("intercom reply targets one of multiple pending asks by short session ID", { concurrency: false }, async () => {
   const { planner, orchestrator, cleanup } = await setupClients();
   const { default: piIntercomExtension } = await import("./index.ts");

package/dist/extensions/pi-intercom/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-intercom",
-  "version": "0.12.0",
+  "version": "0.12.1",
   "license": "MIT",
   "type": "module",
   "main": "index.ts",

package/dist/extensions/pi-intercom/reply-tracker.test.ts

@@ -93,6 +93,26 @@ test("explicit to overrides the current turn context", () => {
   assert.throws(() => tracker.resolveReplyTarget({ to: "missing" }, 1003), /No pending ask from/);
 });
 
+test("active ask context flags non-reply sends to a different target", () => {
+  const tracker = new ReplyTracker();
+  const current = tracker.recordIncomingMessage(createSession("planner-id", "planner"), createMessage("ask-1", "Need a reply"), 1000);
+  tracker.queueTurnContext(current);
+  tracker.beginTurn(1001);
+
+  assert.equal(tracker.findActiveReplyTargetMismatch("planner-id", 1002), null);
+  assert.equal(tracker.findActiveReplyTargetMismatch("planner", 1002)?.message.id, "ask-1");
+  assert.equal(tracker.findActiveReplyTargetMismatch("repo-root", 1002)?.message.id, "ask-1");
+});
+
+test("active ask context does not trust sender names as destination identity", () => {
+  const tracker = new ReplyTracker();
+  const current = tracker.recordIncomingMessage(createSession("asker-session", "root-session"), createMessage("ask-1", "Need a reply"), 1000);
+  tracker.queueTurnContext(current);
+  tracker.beginTurn(1001);
+
+  assert.equal(tracker.findActiveReplyTargetMismatch("root-session", 1002)?.message.id, "ask-1");
+});
+
 test("replyTo resolves the exact pending ask", () => {
   const tracker = new ReplyTracker();
   tracker.recordIncomingMessage(createSession("planner-id", "planner"), createMessage("ask-1", "First"), 1000);

package/dist/extensions/pi-intercom/reply-tracker.ts

@@ -121,6 +121,14 @@ export class ReplyTracker {
     return candidates.length === 1 ? candidates[0]! : null;
   }
 
+  findActiveReplyTargetMismatch(to: string, now = Date.now()): IntercomContext | null {
+    this.pruneExpired(now);
+    if (!this.currentTurnContext?.message.expectsReply) {
+      return null;
+    }
+    return this.currentTurnContext.from.id === to ? null : this.currentTurnContext;
+  }
+
   markReplied(replyTo: string): void {
     this.dismissPendingAsk(replyTo);
   }

package/dist/extensions/pi-subagents/CHANGELOG.md

@@ -2,6 +2,33 @@
 
 ## [Unreleased]
 
+## [0.60.0] - 2026-08-31
+
+### Highlights
+- Ask for the runtime delegation catalog as clean rows: `subagent({ action: "list", capabilities: true })` returns compact, prompt-free capability rows and machine metadata.
+- Timeout recovery is explainable: async status and `subagent_wait` completions report the missing/written report and changed tracked files for timed-out children with dirty worktrees.
+- Forked children reuse prompt caches: fork-context launches stamp an OpenAI-compatible `prompt_cache_key` on provider requests.
+- `runs.lanes` plans show up as workflow-graph stages in status and TUI views.
+- Watchdog and single-output evidence are cheaper and kinder: home-root/entry-less repos skip untracked scans, and stat errors propagate instead of being swallowed.
+
+### Added
+- Add `capabilities` option to management `list`: returns executable/restricted status, restriction sources, aliases, runner (pi / external-cli / external-job with capabilities), tools (ambient, mcp-direct, mutation), model (value/fallbacks/thinking), execution (defaultAsync, timeoutMs), output, and extensions snapshot per agent, plus total restricted count and capability-ceiling sources, as versioned `details.agentCapabilities` (`details.catalog`).
+- Emit `lanePlan` metadata from `runs.lanes` (stages, phase, label, agent, output name, structured flag) and render workflow-graph stage nodes in async status and TUI views.
+- Stamp `prompt_cache_key` (`pi-fork:<sha256>`) on supported provider requests for fork-context children via `before_provider_request`.
+- Project timeout-recovery evidence (termination, changed files, report status, dirty-worktree reason) into async status steps and `subagent_wait` completion output.
+
+### Changed
+- `runs.host` rejects per-step `cwd` with an actionable hint (use outer request cwd or a trusted `cd` in the command).
+- Watchdog repo-change signatures skip `--untracked-files=all` for home-repo roots and repositories with no tracked entries, keeping status probes cheap and bounded.
+- Single-output snapshots propagate non-ENOENT stat errors instead of treating every failure as "file missing".
+- Background spawns use `windowsHide` consistently and `detached` only on non-Windows.
+- `workflowScript` guidance documents the portability rules (no nested async helpers) and `runs.host` cwd semantics.
+
+### Fixed
+- "Running" spinners in the TUI advance on wall-clock time instead of only on model activity.
+- Noisy repeated single-step status rows are suppressed in workflow status rendering.
+- Timeout recovery summaries no longer claim a written report when the required output is missing.
+
 ## [0.59.0] - 2026-08-28
 
 ### Highlights

package/dist/extensions/pi-subagents/docs/tool-reference.md

@@ -4,7 +4,7 @@ Parameters and actions for the `subagent` tool. These are what the LLM passes wh
 
 ## Execution examples
 
-Chaining is code-driven through `workflowScript`. Use `await runs.run(...)` for sequential steps and `await runs.all([{ key, agent, task }, ...])` for ordinary parallel fanout. `runs.all` resolves to an ordered array, not a key map, so use indexes, destructuring, or `.map(...)`, not `results.<key>`. Do not read `.output` from an unawaited `runs.run` launch. Stored `runs.run` promises are only for the advanced rolling fanout pattern under [Workflow steering](#workflow-steering), where every promise is later observed with direct `await`, `Promise.race`, or `Promise.all`. Legacy top-level `chain`, `tasks`, and `parallel` inputs are not supported. Helper functions must be plain functions or explicit Promise chains. Nested `async function` helpers, async arrows, and async methods are rejected so child-launch tracking stays portable across Node and Bun.
+Chaining is code-driven through `workflowScript`. Use `await runs.run(...)` for sequential steps and `await runs.all([{ key, agent, task }, ...])` for ordinary parallel fanout. `runs.all` resolves to an ordered array, not a key map, so use indexes, destructuring, or `.map(...)`, not `results.<key>`. Do not read `.output` from an unawaited `runs.run` launch. Stored `runs.run` promises are only for the advanced rolling fanout pattern under [Workflow steering](#workflow-steering), where every promise is later observed with direct `await`, `Promise.race`, or `Promise.all`. Legacy top-level `chain`, `tasks`, and `parallel` inputs are not supported. Helper functions must be plain functions or explicit Promise chains. Nested `async function` helpers, async arrows, and async methods are rejected so child-launch tracking stays portable across Node and Bun. Host steps are similarly narrow: use `runs.host(key, { kind: "command", command, timeoutMs, output?, role?, provider? })`; there is no per-step `cwd`, and commands and relative output paths use the workflow `cwd`. Set `cwd` on the outer `subagent({...})` request instead, or put a trusted directory change in the command (for example, `cd /path/to/worktree && npm test`).
 
 Use `{ action: "validate", workflowScript }` to check statically decidable syntax and structure without launching children. It returns `{ ok, errors }` and fails the tool call when `ok` is false. Dynamic keys and values remain valid because runtime-only cases are not guessed.
 
@@ -95,6 +95,7 @@ The complete plain-JSON inventory is validated before the first launch (maximum
 | `view` | `fleet \| transcript` | - | Optional `status` view for the active fleet surface or transcript tail inspection. |
 | `lines` | number | `80` | Maximum transcript lines for `action: "status", view: "transcript"`; capped at 500. |
 | `agentScope` | `user \| project \| both` | `both` | Agent discovery scope. Project wins on collisions. |
+| `capabilities` | boolean | `false` | With `action: "list"`, return compact prompt-free rows and `details.agentCapabilities` machine-readable records for each agent's declared/default routing capabilities. |
 | `async` | boolean | default-on | Background execution. Workflows default to background. `async:false` blocks the parent until completion. |
 | `chatProgress` | `auto \| off \| live-card` | `auto` | WorkflowScript chat projection. `auto` renders a live in-chat card only for watched foreground workflows in the same Git repository, including managed worktrees; it is off otherwise. Explicit `live-card` requires `async:false` and the same Git repository. Async workflows have no inline live card, so omit `chatProgress` or use `auto`/`off`; use `async:false` only when the parent must block. |
 | `isolation` | `none \| worktree` | - | Workflow child isolation. `none` runs in the shared cwd and does not need Git. `worktree` requires a managed Git worktree. Do not combine it with a contradictory `worktree` value. |
@@ -192,6 +193,7 @@ Agent definitions are not loaded into context by default. Management actions let
 ```ts
 { action: "list" }
 { action: "list", agentScope: "project" }
+{ action: "list", capabilities: true }
 { action: "get", agent: "scout" }
 { action: "models" }
 { action: "models", agent: "reviewer" }
@@ -235,6 +237,7 @@ Agent definitions are not loaded into context by default. Management actions let
 
 Rules:
 
+- `capabilities: true` changes `action: "list"` to compact one-line rows and adds `details.agentCapabilities: { agents, restrictedCount, capabilityCeilingSources? }`. Each agent row includes source, aliases, runner type/capabilities, tools, MCP direct tools, mutation tools, model/thinking/fallbacks, default async/timeout, output path/mode, skills/extensions, and whether the current capability ceiling allows execution. It never includes an agent's system prompt. Rows show declared/default capabilities, not task-specific launch resolution; use preflight when exact launch validation is needed.
 - `create` uses `config.scope`, not `agentScope`.
 - `config.name` is the local frontmatter name; optional `config.package` registers the runtime name as `{package}.{name}` and is saved as separate `name` and `package` frontmatter.
 - `config.aliases` accepts a comma-separated string, string array, or `false` to clear aliases. Aliases resolve to the canonical agent name for execution and are shown by `list`/`get`.

package/dist/extensions/pi-subagents/docs/workflows.md

@@ -35,7 +35,7 @@ Add `autofix` to `/parallel-review` or `/parallel-cleanup` to apply only the syn
 
 ## Scripted workflows (workflowScript)
 
-All model-facing subagent execution is expressed through `workflowScript` in the `subagent` tool. Use stable keys and ordinary JavaScript for one child, sequence, and parallelism. For ordinary parallel fanout, use `await runs.all([{ key, agent, task }, ...])`. It resolves to an ordered array, not a key map, so use indexes, destructuring, or `.map(...)`, not `results.<key>`. Do not read `.output` from unawaited `runs.run` launches. Store a `runs.run` promise only when the script later observes it with `await`, `Promise.race`, or `Promise.all`, such as steering a live child before awaiting its result. Scripts are ordinary JavaScript statement bodies. Use an explicit `return` for a useful result:
+Use direct `{ agent, task }` for one bounded child. Use `workflowScript` when the parent needs a stable keyed child, sequence, fanout, steering, retry, or aggregation. For ordinary parallel fanout, use `await runs.all([{ key, agent, task }, ...])`. It resolves to an ordered array, not a key map, so use indexes, destructuring, or `.map(...)`, not `results.<key>`. Do not read `.output` from unawaited `runs.run` launches. Store a `runs.run` promise only when the script later observes it with `await`, `Promise.race`, or `Promise.all`, such as steering a live child before awaiting its result. Scripts are ordinary JavaScript statement bodies. Use an explicit `return` for a useful result:
 
 Child results cross into the script as plain JSON data. Non-JSON host metadata is omitted, so use returned fields such as `runId`, `ok`, `output`, and `structuredOutput` for workflow control.
 
@@ -178,7 +178,7 @@ subagent({ workflowScript: `
 ` });
 ```
 
-The first version supports only `kind: "command"`. `command` and `timeoutMs` are required; `output` must be a relative path without traversal. `role` may be `ci` or `gate`, and `provider` is display metadata only. The command has no stdin, receives the workflow cwd, and must be awaited or returned. Stdout, stderr, and the saved log are bounded. A nonzero exit, timeout, abort, or output-write failure fails the workflow. Async status and terminal receipts store the bounded host-step state; renderers do not run commands or read command output.
+The first version supports only `kind: "command"`. `command` and `timeoutMs` are required; `output` must be a relative path without traversal. `role` may be `ci` or `gate`, and `provider` is display metadata only. **There is no per-step `cwd` field:** the command and relative output path use the workflow cwd. Set `cwd` on the outer `subagent({...})` request when the workflow should run in another directory, or put a trusted directory change in the command (for example, `cd /path/to/worktree && npm test`) when only that step differs. The command has no stdin, receives the workflow cwd, and must be awaited or returned. Stdout, stderr, and the saved log are bounded. A nonzero exit, timeout, abort, or output-write failure fails the workflow. Async status and terminal receipts store the bounded host-step state; renderers do not run commands or read command output.
 
 ### Steering a workflow child
 

package/dist/extensions/pi-subagents/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "pi-subagents",
-  "version": "0.59.0",
+  "version": "0.60.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "pi-subagents",
-      "version": "0.59.0",
+      "version": "0.60.0",
       "license": "MIT",
       "dependencies": {
         "acorn": "8.18.0",

package/dist/extensions/pi-subagents/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-subagents",
-  "version": "0.59.0",
+  "version": "0.60.0",
   "description": "Selesai extension for single-agent delegation and scripted multi-agent workflows",
   "author": "Nico Bailon",
   "license": "MIT",

package/dist/extensions/pi-subagents/skills/council-mode/SKILL.md

@@ -5,250 +5,55 @@ description: Run a bounded supervisor-mediated advisor council. Use when the use
 
 # Council Mode
 
-This skill is for the parent supervisor only. Do not inject it into advisors. The
-parent selects the roster, curates all cross-advisor communication, decides which
-feedback is valid, and writes the decision memo. Advisors do not talk directly or
-see peer transcripts by default. This is not free-form agent chat.
-
-Use council mode for a material decision with real tradeoffs. Do not use it for a
-trivial or settled question, or for implementation work. Read
-`skills/pi-subagents/references/execution-controls.md` before you launch advisors.
-
-## Roster and limits
-
-Use advisor profile names directly. A `council-*` profile defines model, tools,
-context, output defaults, and any persistent stance in the profile body. Its
-profile configuration or explicit invocation owns its context choice.
-
-Package advisors can also join the roster only when their package Pi extension is
-installed and their external-job provider is registered. For Surf, `gpt-pro` is
-available only after the `surf-cli` Pi extension loads Surf's `surf-oracle`
-provider. Treat it as a normal advisor name in `runs.all` after that provider is
-visible. It is background-only, so omit `async` unless you explicitly want
-detached receipt semantics; workflow execution will await the terminal provider
-result. External runners can lack repo tools, structured-output support, or
-resumability. For them, include the needed evidence or file excerpts in the task,
-use the text JSON contract below instead of `outputSchema`, and use the
-fresh-context fallback path for cross-exam when the run is not resumable.
-
-Create model-based profiles in your user or project agent directory. Do not add
-them to this package. This is a valid example:
-
-```markdown
----
-name: council-sol
-description: Read-only fresh-context advisor for bounded council decisions
-tools: read, grep, find, ls
-model: openai-codex/gpt-5.6-sol
-thinking: high
-systemPromptMode: replace
-inheritProjectContext: true
-inheritSkills: false
-defaultContext: fresh
-acceptanceRole: read-only
----
+Council mode is parent-supervised advice for a material decision with real tradeoffs. It is not free-form agent chat, implementation work, a transcript dump, mutation authority, or a council UI.
+
+The parent selects the roster, relays only curated claims, decides validity, and writes the memo. Advisors stay read-only and do not see peer transcripts by default.
+
+Before launch, read:
+
+- `skills/pi-subagents/references/execution-controls.md`
+- `skills/council-mode/references/pass-contracts.md`
+
+## Roster
+
+Run `subagent({ action: "list" })`, then choose 2-3 executable advisor names that start with `council-`. The prefix is convention only. Never use more than four advisors.
+
+If fewer than two council profiles are available, fill with `oracle`, then `reviewer`. Launch fallback `oracle` with `context: "fork"`; let fallback `reviewer` use its normal profile context. Note fallbacks and known context modes in the memo. If fewer than two advisors remain, use the normal one-oracle consultation loop and label it degraded mode.
+
+`council-*` profiles live in user or project agent directories, not this package. A profile defines model, tools, context, output defaults, and persistent stance. Keep advisors read-only, disable inherited skills unless needed, and put stance in the profile body instead of inventing per-run role labels.
 
-Analyze the council question independently. Inspect evidence directly. Do not
-edit, run mutating commands, commit, push, contact peers, or spawn subagents.
-Return concise, cited advice using the report contract in the council task.
-```
-
-After `subagent({ action: "list" })`, prefer 2–3 executable names that start with
-`council-`. The prefix is a naming convention, not runtime selection. If fewer
-than two profiles are available, fill the roster with `oracle`, then `reviewer`,
-until it has two advisors. Launch fallback `oracle` with `context: "fork"` so
-global defaults cannot remove its parent-chat context. Let fallback `reviewer`
-use its normal profile context. Note the fallback and known context modes in the
-memo. Use the normal single-oracle consultation loop only when a requested roster
-or unavailable builtins leaves fewer than two advisors.
-Label that result as degraded mode. Never use more than four advisors.
-
-Pass 1 is independent reports. Pass 2 is one cross-exam. The default pass cap is
-2. Run pass 3 only when `--max-passes 3` was requested and a material dispute can
-be settled by evidence an advisor can produce. Never run an unbounded loop.
+External-job/package advisors may join only when their provider is registered. Treat them as ordinary advisor names in `runs.all`, but honor their runner limits: they may lack repo tools, structured output, or resumability. Include evidence they cannot read, request JSON text instead of `outputSchema`, and use a fresh-context fallback when they cannot resume for cross-exam.
+
+## Passes
+
+Pass 1 is independent reports. Pass 2 is one cross-exam. Run Pass 3 only when `--max-passes 3` was requested and a material dispute can still be settled by evidence. Never run an unbounded loop.
 
 ## Protocol
 
-1. The parent writes a brief with the question, scope, non-goals, evidence targets,
-   roster, known advisor context modes, and pass cap. If the user wants a specific
-   lens, keep it in the question, scope, or profile body instead of inventing a
-   per-advisor label.
-2. Before Pass 1, tell the user the roster, requested or known context modes, and
-   pass cap. Use a stable key, `phase`, and concise `label` for every
-   workflow child. For example, use `advisor-oracle`, `phase: "Council pass 1"`,
-   and `label: "Oracle — intent and consistency"`.
-3. Launch one async `workflowScript` with `runs.all` for independent advisor
-   reports. Set `context` when the selected advisor has a known profile context or
-   a fallback rule requests one, because a global default can otherwise override
-   that profile. Set `context: "fork"` for fallback `oracle`. If no advisor context
-   is known, omit `context` and disclose the unknown runtime default in the memo.
-   Each advisor is read-only and must not spawn children, edit files, run mutating
-   commands, commit, or push. Set `output: false` unless separate advisor artifacts
-   are explicitly requested or useful for the decision. When separate artifacts are
-   useful, give advisors relative output paths so the runtime stores them under its
-   managed artifact directory; do not ask them to write root-level council report
-   files. For installed
-   external-runner advisors such as Surf `gpt-pro` after `surf-oracle` is
-   registered, do not pass `outputSchema`; put the schema request in the task text
-   and accept `result.output` as the report.
-4. Return one aggregate Pass 1 receipt. After it completes, tell the user the
-   completion count, agreement count, dispute count, and whether Pass 2 is needed.
-5. The parent synthesizes a claim matrix in session. It contains agreements,
-   disputed claims, missing proof, owner decisions, and a relay set of at most five
-   high-impact claims per advisor. Do not delegate this synthesis.
-6. Before Pass 2, tell the user how many claims are relayed and why each is
-   material. Launch a second async `workflowScript` with `runs.all` resume calls.
-   Each task is a curated challenge packet, not a peer transcript. A resume requires
-   a retained run id and a non-empty task. It excludes `agent` and rejects `gate`.
-   Record the new run id from every resume. Pass 3 resumes those latest ids. Return
-   one aggregate Pass 2 receipt.
-7. After Pass 2, tell the user whether the council converged or which owner
-   decisions remain. The parent writes the final memo. Do not delegate it.
-
-If an advisor is not resumable, run the same profile in fresh context with its own
-pass-1 report and the challenge packet. Label that response as a fresh-context
-fallback, not a true cross-exam.
-
-Do not set `clarify`, `worktree`, `gate`, tool budgets, or tight usage
-budgets on advisors. Bound work through the roster, pass cap, and report length.
-
-## Advisor contracts and pass receipts
-
-Pass-1 reports are at most about 600 words. Give native Pi advisors the same
-`outputSchema`, so reports are comparable without heading cleanup. For
-external-runner advisors, do not pass `outputSchema`; ask them to return compact
-JSON text with the same fields. The following shape is a contract template. Use
-the runtime schema syntax supported by the workflow for native advisors and keep
-narrative fields as strings:
-
-```js
-const pass1OutputSchema = {
-  type: "object",
-  required: [
-    "recommendation", "evidence", "assumptions", "risks", "confidence",
-    "challengeClaims", "ownerDecisions", "changeMyMind"
-  ],
-  properties: {
-    recommendation: { type: "string" },
-    evidence: {
-      type: "array",
-      items: {
-        type: "object",
-        required: ["claim", "sources"],
-        properties: {
-          claim: { type: "string" },
-          sources: { type: "array", items: { type: "string" } }
-        }
-      }
-    },
-    assumptions: {
-      type: "array",
-      items: {
-        type: "object",
-        required: ["assumption", "status"],
-        properties: {
-          assumption: { type: "string" },
-          status: { enum: ["verified", "unverified"] }
-        }
-      }
-    },
-    risks: { type: "array", items: { type: "string" } },
-    confidence: {
-      type: "object",
-      required: ["level", "reason"],
-      properties: {
-        level: { enum: ["high", "medium", "low"] },
-        reason: { type: "string" }
-      }
-    },
-    challengeClaims: { type: "array", items: { type: "string" }, maxItems: 3 },
-    ownerDecisions: { type: "array", items: { type: "string" } },
-    changeMyMind: { type: "array", items: { type: "string" } }
-  }
-};
-```
-
-Include this contract in each Pass 1 task: inspect supplied evidence directly; do
-not see or ask about other advisors; stay read-only; do not spawn children; return
-only the structured report. For external-runner advisors, say `Return only JSON
-matching this shape. Do not wrap it in Markdown.` and include any evidence they
-cannot read through tools.
-
-After `runs.all`, return one aggregate receipt rather than making the parent find
-separate artifacts. Preserve the result order or map it by stable key so each row
-contains the advisor identity and report:
-
-```js
-return {
-  pass: 1,
-  advisors: results.map((result, index) => ({
-    key: result.key,
-    agent: result.agent,
-    requestedContext: roster[index].context ?? "runtime-default-unknown",
-    runId: result.runId,
-    report: result.structuredOutput ?? result.output
-  }))
-};
-```
-
-Do not replace `runtime-default-unknown` with a guessed context. It records that
-the launch intentionally omitted context.
-
-A challenge packet contains only disputed claims, strong conflicting evidence,
-missing proof, owner decisions, and high-impact risks. Attribute peer content as
-"another advisor". Do not include full peer reports. Use a common Pass 2 contract:
-
-```js
-const pass2OutputSchema = {
-  type: "object",
-  required: ["responses", "recommendationChanged", "outOfScopeFindings"],
-  properties: {
-    responses: {
-      type: "array",
-      items: {
-        type: "object",
-        required: ["claimId", "disposition", "reason", "sources"],
-        properties: {
-          claimId: { type: "string" },
-          disposition: {
-            enum: ["accept", "reject", "refine", "owner-decision"]
-          },
-          reason: { type: "string" },
-          sources: { type: "array", items: { type: "string" } }
-        }
-      }
-    },
-    recommendationChanged: {
-      type: "object",
-      required: ["changed", "reason"],
-      properties: { changed: { type: "boolean" }, reason: { type: "string" } }
-    },
-    outOfScopeFindings: { type: "array", items: { type: "string" } }
-  }
-};
-```
-
-Use stable resume keys such as `cross-oracle`, `phase: "Council pass 2"`, concise
-labels, and `output: false` unless separate artifacts are requested or useful. Keep
-any artifact outputs under the managed run artifact directory. Do not pass
-`outputSchema` to external-runner fallback launches; ask for compact JSON text
-instead. The aggregate Pass 2 receipt uses the same row shape as Pass 1, with the
-new `runId` and `structuredOutput ?? output`.
-
-## Stop and memo
-
-Converged means no disputed claim remains that both materially affects the
-recommendation and can plausibly be settled by evidence. Stop at convergence, the
-pass cap, failed fallback, or user interruption. Put unresolved disputes in owner
-decisions. Never add a round for polish or symmetry.
-
-The parent memo states the question and scope, recommendation, rationale, accepted
-and rejected feedback with reasons, owner decisions, evidence and run ids,
-confidence, what would change the decision, and the roster, passes, fallbacks, and
-known advisor context modes. Identify advisors by profile name or model-based
-profile, not by invented role labels. State that fallback `oracle` is context-aware
-and forked.
-
-Council mode is not agent-to-agent chat, a transcript dump, mutation authority,
-auto-escalation to writer lanes, or a council UI. Escalate to a writer only after
-the parent memo and only when the user explicitly requests it.
+1. Write the council brief: question, scope, non-goals, evidence targets, roster, known advisor context modes, and pass cap.
+2. Tell the user the roster, context modes, and pass cap.
+3. Launch one async `workflowScript` with `runs.all` for Pass 1. Use stable keys, `phase: "Council pass 1"`, concise labels, and `output: false` unless separate artifacts are useful. Set `context` only when the profile context is known or a fallback rule requires it.
+4. Return one aggregate Pass 1 receipt. On completion, tell the user completion count, agreement count, dispute count, and whether Pass 2 is needed.
+5. Synthesize the claim matrix in the parent: agreements, disputed claims, missing proof, owner decisions, and at most five material relay claims per advisor.
+6. For Pass 2, tell the user which claims are relayed and why they matter. Resume each advisor with a curated challenge packet. A resume needs a retained run id and task; it excludes `agent` and rejects `gate`. Record each new run id; Pass 3 resumes those latest ids with new stable keys.
+7. Stop at convergence, pass cap, failed fallback, or user interruption. The parent writes the final memo.
+
+If an advisor is not resumable, run the same profile fresh with its Pass 1 report and challenge packet. Label it a fresh-context fallback, not true cross-exam.
+
+Do not set `clarify`, `worktree`, `gate`, tool budgets, or tight usage budgets on advisors. Bound work through the roster, pass cap, and report length.
+
+## Memo
+
+Converged means no disputed claim remains that both affects the recommendation and can plausibly be settled by advisor evidence. Put unresolved disputes in owner decisions. Do not add a round for polish or symmetry.
+
+The memo states:
+
+- question and scope
+- recommendation and rationale
+- accepted and rejected feedback with reasons
+- owner decisions
+- evidence and run ids
+- confidence and what would change the decision
+- roster, passes, fallbacks, and known advisor context modes
+
+Identify advisors by profile name. State when fallback `oracle` was forked and context-aware. Escalate to a writer only after the memo and only when the user requests it.