@selesai/code 0.13.32 → 0.13.34

package/dist/extensions/pi-hermes-memory/src/config.ts

@@ -75,13 +75,42 @@ export const DEFAULT_CONFIG_PATH = path.join(
   AGENT_ROOT,
   "hermes-memory-config.json",
 );
+export const DEFAULT_SETTINGS_PATH = path.join(AGENT_ROOT, "settings.json");
+export const HERMES_MEMORY_SETTINGS_KEY = "hermesMemory";
 
-export function loadConfig(configPath = DEFAULT_CONFIG_PATH): MemoryConfig {
+function readConfigObject(configPath: string | undefined): Record<string, unknown> | undefined {
+  if (!configPath) return undefined;
   try {
-    if (fs.existsSync(configPath)) {
-      const raw = fs.readFileSync(configPath, "utf-8");
-      const parsed = JSON.parse(raw);
-      // Merge: override defaults with user config
+    const parsed: unknown = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+    return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)
+      ? parsed as Record<string, unknown>
+      : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+/** Read extension settings from settings.json, falling back to the legacy file. */
+export function loadConfig(
+  configPath = DEFAULT_CONFIG_PATH,
+  settingsPath?: string,
+): MemoryConfig {
+  try {
+    const legacyConfig = readConfigObject(configPath);
+    const resolvedSettingsPath = settingsPath
+      ?? (configPath === DEFAULT_CONFIG_PATH ? DEFAULT_SETTINGS_PATH : undefined);
+    const settings = readConfigObject(resolvedSettingsPath);
+    const extensionSettings = settings?.[HERMES_MEMORY_SETTINGS_KEY];
+    if (legacyConfig || isRecord(extensionSettings)) {
+      const parsed: Record<string, unknown> = {
+        ...(legacyConfig ?? {}),
+        ...(isRecord(extensionSettings) ? extensionSettings : {}),
+      };
+      // New settings.json values take precedence over the legacy file.
       const config: MemoryConfig = { ...DEFAULT_CONFIG };
       const isNonNegativeNumber = (value: unknown): value is number => (
         typeof value === "number" && Number.isFinite(value) && value >= 0
@@ -156,8 +185,7 @@ export function loadConfig(configPath = DEFAULT_CONFIG_PATH): MemoryConfig {
         if (normalizedProjectsMemoryDir) config.projectsMemoryDir = normalizedProjectsMemoryDir;
       }
       if (
-        typeof parsed.sessionSearch === "object" &&
-        parsed.sessionSearch !== null &&
+        isRecord(parsed.sessionSearch) &&
         isSessionSearchVariant(parsed.sessionSearch.variant)
       ) {
         config.sessionSearch = { variant: parsed.sessionSearch.variant };
@@ -204,7 +232,7 @@ export function loadConfig(configPath = DEFAULT_CONFIG_PATH): MemoryConfig {
       return config;
     }
   } catch {
-    // Fall back to defaults on parse error or access issues
+    // Fall back to defaults on unexpected parse or access issues.
   }
   return { ...DEFAULT_CONFIG };
 }

package/dist/extensions/pi-hermes-memory/src/constants.ts

@@ -29,12 +29,12 @@ export const DEFAULT_NUDGE_TOOL_CALLS = 15;
 export const DEFAULT_REVIEW_RECENT_MESSAGES = 0;
 export const DEFAULT_FLUSH_RECENT_MESSAGES = 0;
 /**
- * A consolidation run pays child-process boot plus a full LLM turn, which
- * routinely exceeds 60s — at the old 60s default the auto path was killed
- * mid-run on every attempt (#136). Configured values are honored verbatim,
- * including lower ones; `loadConfig` warns when a value below this is set.
+ * A consolidation run pays child-process boot plus a full LLM turn. Five
+ * minutes leaves room for slower models and larger memory stores. Configured
+ * values are honored verbatim, including lower ones; `loadConfig` warns when a
+ * value below this is set.
  */
-export const DEFAULT_CONSOLIDATION_TIMEOUT_MS = 180000;
+export const DEFAULT_CONSOLIDATION_TIMEOUT_MS = 300000;
 /** Wall-clock grace after overflow before an automatic consolidation may run. */
 export const DEFAULT_OVERFLOW_GRACE_MS = 180000;
 export const DEFAULT_FAILURE_INJECTION_MAX_AGE_DAYS = 7;

package/dist/extensions/pi-hermes-memory/src/handlers/auto-consolidate.ts

@@ -337,64 +337,78 @@ export function registerConsolidateCommand(
         });
       }
 
-      try {
-        ctx.ui.notify(
-          `🔄 Starting memory consolidation for ${targets.length} target${targets.length === 1 ? "" : "s"}...`,
-          "info",
-        );
-      } catch {
-        // Best-effort only. If the command context is already stale, continue
-        // with the consolidation work rather than failing before it starts.
-      }
-
-      for (const item of targets) {
-        const entries = entriesForTarget(item.store, item.target);
-
-        if (entries.length === 0) {
-          results.push(`${item.label}: (empty, nothing to consolidate)`);
-          continue;
+      const setStatus = (text?: string) => {
+        try {
+          ctx.ui.setStatus("pi-hermes-memory:consolidation", text);
+        } catch {
+          // Best-effort progress feedback only.
         }
+      };
 
+      setStatus("Preparing memory consolidation…");
+      try {
         try {
           ctx.ui.notify(
-            `⏳ Consolidating ${item.label}...`,
+            `🔄 Starting memory consolidation for ${targets.length} target${targets.length === 1 ? "" : "s"}...`,
             "info",
           );
         } catch {
-          // Best-effort progress feedback only.
+          // Best-effort only. If the command context is already stale, continue
+          // with the consolidation work rather than failing before it starts.
         }
 
-        const result = await triggerConsolidation(
-          pi,
-          item.store,
-          item.target,
-          ctx.signal,
-          timeoutMs,
-          item.toolTarget,
-          llmConfig,
-          ctx,
-          dbManager,
-          activeProjectName,
-          deps,
-        );
-
-        if (result.consolidated) {
-          await item.store.loadFromDisk();
-          results.push(`${item.label}: ✅ consolidated`);
-        } else {
-          results.push(`${item.label}: ❌ ${result.error}`);
+        for (const [index, item] of targets.entries()) {
+          const entries = entriesForTarget(item.store, item.target);
+
+          if (entries.length === 0) {
+            results.push(`${item.label}: (empty, nothing to consolidate)`);
+            continue;
+          }
+
+          setStatus(`Consolidating ${item.label} (${index + 1}/${targets.length})…`);
+          try {
+            ctx.ui.notify(
+              `⏳ Consolidating ${item.label}...`,
+              "info",
+            );
+          } catch {
+            // Best-effort progress feedback only.
+          }
+
+          const result = await triggerConsolidation(
+            pi,
+            item.store,
+            item.target,
+            ctx.signal,
+            timeoutMs,
+            item.toolTarget,
+            llmConfig,
+            ctx,
+            dbManager,
+            activeProjectName,
+            deps,
+          );
+
+          if (result.consolidated) {
+            await item.store.loadFromDisk();
+            results.push(`${item.label}: ✅ consolidated`);
+          } else {
+            results.push(`${item.label}: ❌ ${result.error}`);
+          }
         }
-      }
 
-      const summary = `\n  🔄 Memory Consolidation\n  ${"─".repeat(30)}\n${results.map((r) => `  ${r}`).join("\n")}`;
+        const summary = `\n  🔄 Memory Consolidation\n  ${"─".repeat(30)}\n${results.map((r) => `  ${r}`).join("\n")}`;
 
-      try {
-        ctx.ui.notify(summary, "info");
-      } catch {
-        // Child consolidation can indirectly trigger a runtime reload/session
-        // replacement. If that happens, the original command ctx is stale by
-        // the time we reach the final summary, so the command should exit
-        // quietly instead of surfacing a stale-ctx error.
+        try {
+          ctx.ui.notify(summary, "info");
+        } catch {
+          // Child consolidation can indirectly trigger a runtime reload/session
+          // replacement. If that happens, the original command ctx is stale by
+          // the time we reach the final summary, so the command should exit
+          // quietly instead of surfacing a stale-ctx error.
+        }
+      } finally {
+        setStatus(undefined);
       }
     },
   });

package/dist/extensions/pi-hermes-memory/tests/config.test.ts

@@ -7,9 +7,11 @@ import { loadConfig } from "../src/config.js";
 import { AGENT_ROOT } from "../src/paths.js";
 
 const TEST_CONFIG_PATH = path.join(os.tmpdir(), `hermes-memory-config-test-${process.pid}.json`);
+const TEST_SETTINGS_PATH = path.join(os.tmpdir(), `hermes-settings-test-${process.pid}.json`);
 
 afterEach(() => {
   fs.rmSync(TEST_CONFIG_PATH, { force: true });
+  fs.rmSync(TEST_SETTINGS_PATH, { force: true });
 });
 
 describe("loadConfig", () => {
@@ -30,7 +32,7 @@ describe("loadConfig", () => {
     assert.strictEqual(config.flushRecentMessages, 0);
     assert.strictEqual(config.memoryOverflowStrategy, "auto-consolidate");
     assert.strictEqual(config.autoConsolidate, true);
-    assert.strictEqual(config.consolidationTimeoutMs, 180000);
+    assert.strictEqual(config.consolidationTimeoutMs, 300000);
     assert.strictEqual(config.overflowGraceMs, 180000);
     assert.strictEqual(config.autoConsolidationWarnOnFailure, true);
     assert.strictEqual(config.failureInjectionEnabled, true);
@@ -65,7 +67,7 @@ describe("loadConfig", () => {
         "a lower configured value must be honored, not clamped",
       );
       assert.strictEqual(warnings.length, 1, "a sub-default value should warn once");
-      assert.match(warnings[0], /60000ms.*below the 180000ms default/);
+      assert.match(warnings[0], /60000ms.*below the 300000ms default/);
     } finally {
       console.warn = originalWarn;
     }
@@ -112,6 +114,28 @@ describe("loadConfig", () => {
     assert.strictEqual(config.reviewEnabled, true);
   });
 
+  it("loads hermesMemory from settings.json with precedence over the legacy config", () => {
+    fs.mkdirSync(path.dirname(TEST_CONFIG_PATH), { recursive: true });
+    fs.writeFileSync(TEST_CONFIG_PATH, JSON.stringify({
+      llmThinkingOverride: "high",
+      consolidationTimeoutMs: 240000,
+    }));
+    fs.writeFileSync(TEST_SETTINGS_PATH, JSON.stringify({
+      theme: "dark",
+      hermesMemory: {
+        llmThinkingOverride: "off",
+        llmModelOverride: " tokenin/deepseek-v4.1-flash ",
+        consolidationTimeoutMs: 300000,
+      },
+    }));
+
+    const config = loadConfig(TEST_CONFIG_PATH, TEST_SETTINGS_PATH);
+    assert.strictEqual(config.llmThinkingOverride, "off");
+    assert.strictEqual(config.llmModelOverride, "tokenin/deepseek-v4.1-flash");
+    assert.strictEqual(config.consolidationTimeoutMs, 300000);
+    assert.strictEqual(config.memoryMode, "policy-only");
+  });
+
   it("only accepts boolean quickCheckOnOpen overrides", () => {
     fs.mkdirSync(path.dirname(TEST_CONFIG_PATH), { recursive: true });
     fs.writeFileSync(TEST_CONFIG_PATH, JSON.stringify({ quickCheckOnOpen: "false" }));

package/dist/extensions/pi-hermes-memory/tests/handlers/auto-consolidate.test.ts

@@ -631,6 +631,7 @@ describe("registerConsolidateCommand", () => {
   it("includes project memory when a project store is available", async () => {
     let handler: any;
     const notifications: string[] = [];
+    const statuses: Array<[string, string | undefined]> = [];
     let projectReloaded = false;
 
     const pi = {
@@ -655,7 +656,10 @@ describe("registerConsolidateCommand", () => {
     registerConsolidateCommand(pi, mockStore, 60000, projectStore, "demo-project");
     await handler({}, {
       signal: undefined,
-      ui: { notify: (message: string) => { notifications.push(message); } },
+      ui: {
+        notify: (message: string) => { notifications.push(message); },
+        setStatus: (key: string, text: string | undefined) => { statuses.push([key, text]); },
+      },
     });
 
     assert.strictEqual(execCalls.length, 4, "should consolidate memory, user, failure, and project stores");
@@ -670,6 +674,8 @@ describe("registerConsolidateCommand", () => {
     assert.ok(projectReloaded, "project store should reload after consolidation");
     assert.ok(notifications.some((message) => message.includes("Starting memory consolidation")), "should show an initial progress notification");
     assert.ok(notifications.some((message) => message.includes("⏳ Consolidating memory")), "should show per-target progress");
+    assert.ok(statuses.some(([key, text]) => key === "pi-hermes-memory:consolidation" && text?.includes("Consolidating memory")), "should publish busy progress");
+    assert.deepStrictEqual(statuses.at(-1), ["pi-hermes-memory:consolidation", undefined], "should clear busy progress when done");
     const finalNotification = notifications[notifications.length - 1] ?? "";
     assert.ok(finalNotification.includes("failure: ✅ consolidated"), "final notification should include failure result");
     assert.ok(finalNotification.includes("project:demo-project: ✅ consolidated"), "final notification should include project result");

package/dist/extensions/pi-intercom/index.ts

@@ -1186,7 +1186,11 @@ export default function piIntercomExtension(pi: ExtensionAPI) {
     const deliveredEntry = { ...entry, message: injectedMessage, replyCommand };
     replyTracker.queueTurnContext({ from: entry.from, message: injectedMessage, receivedAt: Date.now() });
     const senderDisplay = entry.from.name || entry.from.id.slice(0, 8);
-    const replyInstruction = replyCommand ? `\n\nTo reply, use the intercom tool: ${replyCommand}` : "";
+    // The tool may be an inactive optional capability: say how to activate it, not just its call.
+    const activateHint = pi.getActiveTools().includes("intercom")
+      ? ""
+      : ' (not active yet: call capability_discover with name "intercom" first)';
+    const replyInstruction = replyCommand ? `\n\nTo reply, use the intercom tool${activateHint}: ${replyCommand}` : "";
     const deliveryMetadata = formatInboundDeliveryMetadata(injectedMessage);
     pi.sendMessage(
       {

package/dist/extensions/pi-subagents/agents/worker.md

@@ -2,12 +2,13 @@
 name: worker
 description: Implementation agent for normal tasks and approved oracle handoffs
 aliases: developer, coder, implementer, develop
+acceptanceRole: writer
 thinking: high
 systemPromptMode: replace
 inheritProjectContext: true
 inheritSkills: false
 tools: read, grep, find, ls, bash, edit, write, contact_supervisor
-defaultContext: fork
+defaultContext: fresh
 output: implementation.md
 defaultReads: context.md, research.md, plan.md, implementation.md, review.md
 defaultProgress: true
@@ -17,7 +18,7 @@ You are `worker`: the implementation subagent.
 
 You are the single writer thread. Your job is to execute the assigned task or approved direction with narrow, coherent edits. The main agent and user remain the decision authority.
 
-Use the provided tools directly. First read the inherited context, supplied files, plan, task paths, and named seams. Then implement carefully and minimally. Use broad search only to verify or expand from that starting point.
+Use the provided tools directly. First read the provided context, supplied files, plan, task paths, and named seams. Then implement carefully and minimally. Use broad search only to verify or expand from that starting point.
 
 The builtin worker uses a strict tool allowlist. It does not inherit ambient extension tools from the parent session. To use an extension tool, configure a custom agent with the tool name explicitly listed in `tools` and load its provider through `extensions` or `subagentOnlyExtensions`.
 

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

@@ -198,6 +198,8 @@ fallbackModels:
 
 Field notes:
 
+Native children expose the capability gateway only when extension policy permits it. The gateway catalogs and activates only tools visible in that child's effective registry; it does not install or provide a missing tool provider.
+
 | Field | Notes |
 |-------|-------|
 | `package` | Optional package identifier. A file with `name: scout` and `package: code-analysis` registers as `code-analysis.scout`; serialization keeps `name` and `package` separate. |

package/dist/extensions/pi-subagents/docs/extension-api.md

@@ -114,7 +114,7 @@ pi.events.emit("subagents:rpc:v1:request", {
 });
 ```
 
-The RPC methods are `ping`, `status`, `manage`, `spawn`, `steer`, `interrupt`, `stop`, and `resume`. `status`, `manage`, `steer`, `interrupt`, and `resume` reuse normal package-owned actions.
+The RPC methods are `ping`, `status`, `manage`, `spawn`, `steer`, `interrupt`, `stop`, `resume`, and `cost`. `status`, `manage`, `steer`, `interrupt`, and `resume` reuse normal package-owned actions.
 
 Method notes:
 
@@ -124,6 +124,7 @@ Method notes:
 - `resume` requires a run target and non-empty `message`. It delegates to the existing revival path, which validates current-session ownership, persisted session/recovery metadata, stopped/live state, capability ceilings, and the exclusive session lease before returning the new async run details. Callers may request a `file-only` output path for the revived result without overriding its model, tools, or budgets. `ping.capabilities.resume` advertises this seam.
 - `stop` targets current-session top-level async runs through the stop control channel and records a `stopped` lifecycle instead of reporting a timeout.
 - `status` keeps targeted and rich requests on the executor-backed path. A request with no `id`, `runId`, `dir`, `index`, `view`, or `lines` may use the restored in-memory projections and a short summary; when the live state is missing, stale, session-mismatched, or not restored, it falls back to normal executor status. Status `view`, `lines`, and `index` are forwarded for targeted transcript/fleet requests. Successful replies retain `text`, `details`, `fleet`, and `asyncSnapshot`; the short summary intentionally omits canonical filesystem details, wait subscriptions, and budget annotations.
+- `cost` returns the same parent-plus-child accounting `/subagent-cost` renders, as `{ version: 1, parent, children, childTotal, total, unresolvedAsyncChildren }`. Usage objects contain `input`, `output`, `cacheRead`, `cacheWrite`, `cost`, and `turns`; child rows add `label` plus `agent`, `runId`, or `sessionFile` when known. It is read-only and walks the current session branch and existing artifacts, so request it at a turn boundary rather than on a timer. A non-zero `unresolvedAsyncChildren` means `childTotal` is a lower bound. `ping.capabilities.cost` advertises `{ version: 1 }`.
 
 Capability advertisements on `ping`:
 
@@ -136,6 +137,7 @@ Capability advertisements on `ping`:
 - `resume` — the revival seam described above.
 - `statusProjection: { version: 1, untargeted: "in-memory-when-ready", targeted: "executor" }` — untargeted status may use restored bounded projections; targeted or rich status remains executor-backed.
 - `fleetStatus: { version: 1 }` — successful `status` replies additionally include `data.fleet`.
+- `cost: { version: 1 }` — the `cost` method is available with the report shape described above.
 
 Structured delegation progress updates carry `runId` as soon as foreground execution allocates it, so a caller can retain the package-owned revival target even if its own tool turn is interrupted before the terminal response. Foreground `details.results[]` rows also include a numeric `index` that is unique within the run and stable across partial progress snapshots and the final result; use `(runId, index)` instead of row position to correlate single, counted parallel, and chain children.
 

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

@@ -27,6 +27,8 @@ subagent({ action: "status", id: "..." })      // one run
 
 Or ask naturally: "Show me the current async runs."
 
+Use `/subagent-cost` for combined parent-plus-child usage. Other extensions can request the same versioned data through the in-process RPC `cost` method instead of scraping slash-command text; it is read-only and should be called at a turn boundary, not polled. `unresolvedAsyncChildren` counts children whose usage metadata could not be read, so a non-zero count means the child total is a lower bound. See [extension-api.md](extension-api.md#in-process-event-bus-rpc).
+
 The under-editor async widget gives a short view while work runs. Its expand key follows your Pi keybinding:
 
 ```text

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

@@ -90,7 +90,7 @@ The complete plain-JSON inventory is validated before the first launch (maximum
 | `action` | string | - | Offline workflow `validate`, agent management (including `guide`, `children.list`, and `refine`/`refine.show`/`refine.rollback`), lane evidence (`lane.status`, `lane.recordMerge`, `lane.recordSupersession`), mission (`mission.create/list/show/update/resolve-decision/attach-run/close`), Herdr inspector (`inspector.open/status/close`), Herdr project pane (`project.open/status/close`), status/control, plan-only `worktree.cleanup`, schedule, watchdog, or doctor action. |
 | `topic` | `overview \| workflows \| agents \| missions \| observability \| tool-reference \| configuration \| models \| watchdog \| extension-api` | `overview` | Packaged guide topic for `action: "guide"`. |
 | `config` | object/string | - | Agent config for management create/update. |
-| `context` | `fresh \| fork` | global or per-agent default, else `fresh` | Explicit `fresh` or `fork` overrides every workflow child. When omitted, [`defaultSubagentContext`](configuration.md#defaultsubagentcontext) wins over each agent's `defaultContext`; `"fork"` creates a real branched session when the parent session file and current leaf exist, otherwise it falls back to `fresh`. Packaged `worker`, `oracle`, and `advisor` default to `fork`. |
+| `context` | `fresh \| fork` | global or per-agent default, else `fresh` | Explicit `fresh` or `fork` overrides every workflow child. When omitted, [`defaultSubagentContext`](configuration.md#defaultsubagentcontext) wins over each agent's `defaultContext`; `"fork"` creates a real branched session when the parent session file and current leaf exist, otherwise it falls back to `fresh`. Packaged `worker` defaults to `fresh`; `oracle` and `advisor` default to `fork`. |
 | `missionId` | string | - | Attach a workflow to an existing project mission instead of creating its default enclosing mission. |
 | `mission` | object/false | auto-create | Override the default enclosing mission with `{ title \| summary, objective?, goal?, budget?, labels? }`. Set exactly one non-empty `title` or `summary`; `objective` and `labels` are optional. `goal` may only be `true`, requires `budget.tokens`, and enables continuation notices. Pass `false` for an intentionally ephemeral workflow with no mission for it or its children and no `state` global. Explicit mission persistence failures are strict. |
 | `handoffPath` | string | - | Aggregate handoff manifest for `action: "worktree.discard"` or lane evidence actions, or optional explicit metadata for `action: "worktree.cleanup"`. |
@@ -134,7 +134,7 @@ Explicit `context: "fork"` fails fast when the parent session is not persisted,
 
 When the inherited transcript contains signed Anthropic `thinking` / `redacted_thinking` blocks, `pi-subagents` strips those provider-private blocks from the forked child session. It forces thinking `off` only when the child's effective primary or fallback model resolves through the model registry to the Anthropic provider or `anthropic-messages` API; unresolved models are treated conservatively. The result reports every affected child, including on failed runs. Use `context: "fresh"` when an Anthropic child needs thinking. Explicit `context: "fork"` never silently downgrades to `fresh`.
 
-In workflow runs that omit `context`, each `runs.run` child follows the global `defaultSubagentContext` when set, then its own `defaultContext`. Without the global setting, a fresh-default scout can run fresh beside a fork-default worker. If the parent session file or current leaf is not available yet, implicit fork-default children run fresh. Pass explicit `context: "fork"` or `context: "fresh"` when you intentionally want one context for every child.
+In workflow runs that omit `context`, each `runs.run` child follows the global `defaultSubagentContext` when set, then its own `defaultContext`. Without the global setting, a fresh-default worker can run fresh beside a fork-default oracle. If the parent session file or current leaf is not available yet, implicit fork-default children run fresh. Pass explicit `context: "fork"` or `context: "fresh"` when you intentionally want one context for every child.
 
 ### Workflow steering
 

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

@@ -10,7 +10,7 @@ Use orchestration as parent-agent guidance, not as a runtime workflow mode. For
 clarify → scout → worker → fresh reviewers → worker
 ```
 
-Packaged `worker`, `oracle`, and `advisor` default to forked context when a launch omits `context`. If the parent has no persisted session file or current leaf yet, that implicit default falls back to `fresh`. Pass `context: "fresh"` when you intentionally want a fresh child run, or `context: "fork"` when fork must remain strict.
+Packaged `worker` defaults to fresh context; `oracle` and `advisor` default to forked context when a launch omits `context`. An implicit fork preference falls back to `fresh` when the parent has no persisted session file or current leaf. Pass `context: "fork"` when you intentionally want a worker to reuse the parent thread, or when fork must remain strict.
 
 Child-safety boundaries are enforced at runtime:
 

package/dist/extensions/pi-subagents/src/extension/rpc.ts

@@ -23,6 +23,7 @@ import { sanitizeDisplayText, truncateDisplayText } from "../shared/display-text
 import { readStatus } from "../shared/utils.ts";
 import { SubagentParams } from "./schemas.ts";
 import { normalizePublicSubagentExecution } from "./public-execution.ts";
+import { collectSubagentCost, SUBAGENT_COST_REPORT_VERSION } from "../slash/subagent-cost.ts";
 import { ASYNC_STATUS_SNAPSHOT_KIND, ASYNC_STATUS_SNAPSHOT_VERSION, buildAsyncStatusSnapshotForState } from "../runs/background/async-status-snapshot.ts";
 import { isStoppableAsyncStatusStep, resolveAsyncStatusChild, stopStoppableAsyncStatusChildren, type ResolvedAsyncStatusChild } from "../runs/shared/child-identity.ts";
 
@@ -31,7 +32,7 @@ export const SUBAGENT_RPC_REQUEST_EVENT = "subagents:rpc:v1:request";
 export const SUBAGENT_RPC_READY_EVENT = "subagents:rpc:v1:ready";
 export const SUBAGENT_RPC_REPLY_EVENT_PREFIX = "subagents:rpc:v1:reply:";
 
-export const SUBAGENT_RPC_METHODS = ["ping", "status", "manage", "spawn", "steer", "interrupt", "stop", "resume"] as const;
+export const SUBAGENT_RPC_METHODS = ["ping", "status", "manage", "spawn", "steer", "interrupt", "stop", "resume", "cost"] as const;
 export type SubagentRpcMethod = typeof SUBAGENT_RPC_METHODS[number];
 
 export interface SubagentRpcRequestEnvelope {
@@ -456,6 +457,7 @@ function pingData(ctx: ExtensionContext | null) {
 			launchResolvedExtensions: { version: 1, source: "launch-resolved" },
 			runtimeAcknowledgedExtensions: { version: 1, source: "child-runtime", event: "subagent:acknowledge-extension" },
 			processTerminalProof: { version: 1, lifecycleArtifactVersion: SUBAGENT_LIFECYCLE_ARTIFACT_VERSION },
+			cost: { version: SUBAGENT_COST_REPORT_VERSION },
 		},
 		events: {
 			ready: SUBAGENT_RPC_READY_EVENT,
@@ -761,6 +763,13 @@ async function handleRequest(
 	if (request.method === "resume") {
 		return executeChecked(options, ctx, request.requestId, request.method, resumeParams(request.params));
 	}
+	if (request.method === "cost") {
+		// The same parent-plus-child accounting `/subagent-cost` renders, as data.
+		// Read-only: it walks the current session branch and existing artifacts,
+		// so callers should request it on their own turn boundaries, not on a timer.
+		if (request.params !== undefined && !isRecord(request.params)) throw new SubagentRpcError("invalid_params", "RPC cost params must be an object when provided.");
+		return collectSubagentCost(ctx, options.state ?? { baseCwd: ctx.cwd });
+	}
 	throw new SubagentRpcError("unsupported_method", `Unsupported subagent RPC method: ${String(request.method)}`);
 }
 

package/dist/extensions/pi-subagents/src/runs/background/active-async-capacity.ts

@@ -6,6 +6,7 @@ import { TEMP_ROOT_DIR, type ActiveAsyncCapacitySnapshot, type AsyncStatus } fro
 import { readStatus } from "../../shared/utils.ts";
 import { checkPidLiveness, type PidLiveness } from "./stale-run-reconciler.ts";
 import { readProcessTerminal } from "./process-terminal.ts";
+import { isTerminalAsyncState as terminalState, readWorkflowChildProcessEvidence } from "./workflow-terminal-proof.ts";
 
 export const ACTIVE_ASYNC_CAPACITY_DIR = path.join(TEMP_ROOT_DIR, "session-active-async-capacity");
 export const DEFAULT_ABANDONED_SLOT_RELEASE_AFTER_MS = 20 * 60 * 1000;
@@ -209,10 +210,6 @@ function appendAbandonedReleaseEvent(asyncDir: string, owner: ActiveAsyncCapacit
 	}
 }
 
-function terminalState(state: AsyncStatus["state"]): boolean {
-	return state !== "queued" && state !== "running" && state !== "paused";
-}
-
 function runnerReleaseVerdict(owner: ActiveAsyncCapacityOwner, status: AsyncStatus | null, options: CapacityOptions): ActiveAsyncCapacityReleaseVerdict {
 	if (!status) return { state: "retained", reason: "status file is missing or unreadable" };
 	if (!owner.runnerProcessInstanceId) return { state: "retained", reason: "runner process identity has not been recorded" };
@@ -269,23 +266,8 @@ function workflowReleaseVerdict(owner: ActiveAsyncCapacityOwner, status: AsyncSt
 	if (status.mode !== "workflow") return { state: "retained", reason: `status mode is ${status.mode}, not workflow` };
 	if (!terminalState(status.state)) return { state: "retained", reason: `workflow is still ${status.state}` };
 	if (liveWorkflowRunIds.has(owner.runId)) return { state: "retained", reason: "workflow controller is still live" };
-	for (const step of status.steps ?? []) {
-		const label = step.workflowKey ?? step.agent;
-		if (typeof step.async !== "boolean") return { state: "retained", reason: `workflow child ${label} is missing async classification` };
-		if (!step.async) continue;
-		if (!step.runId) return { state: "retained", reason: `async workflow child ${label} is missing run id` };
-		const childDir = path.join(path.dirname(owner.asyncDir), step.runId);
-		if (!fs.existsSync(childDir)) return { state: "retained", reason: `async workflow child ${label} directory is missing` };
-		const childStatus = readStatus(childDir);
-		if (!childStatus) return { state: "retained", reason: `async workflow child ${label} status is missing or unreadable` };
-		if (!terminalState(childStatus.state)) return { state: "retained", reason: `async workflow child ${label} is still ${childStatus.state}` };
-		if (!childStatus.processTerminal?.runnerProcessInstanceId) return { state: "retained", reason: `async workflow child ${label} has no runner process identity` };
-		const proof = readProcessTerminal(childDir, {
-			runId: step.runId,
-			runnerProcessInstanceId: childStatus.processTerminal.runnerProcessInstanceId,
-		});
-		if (proof?.state !== "observed" || proof.runId !== step.runId) return { state: "retained", reason: `async workflow child ${label} process-terminal proof is ${proof?.state ?? "missing"}` };
-	}
+	const evidence = readWorkflowChildProcessEvidence(owner.asyncDir, status.steps);
+	if (evidence.state !== "observed") return { state: "retained", reason: evidence.reason };
 	return { state: "releasable", reason: "workflow is terminal, controller is gone, and async children have observed proof" };
 }
 

package/dist/extensions/pi-subagents/src/runs/background/async-execution.ts

@@ -83,6 +83,7 @@ import { assertAgentAllowedByCapabilityCeiling, intersectSubagentCapabilityCeili
 import { agentDefinitionDigest, launchBindingDigest } from "../../shared/launch-contract.ts";
 import { resolvePermissionRules, type PermissionConfig } from "../shared/permissions.ts";
 import { normalizeExtensionBindings, omitExtensionBindingsEnv, type ExtensionBindings } from "../shared/extension-bindings.ts";
+import { omitGitRoutingEnv } from "../shared/git-environment.ts";
 import { assertWorkflowLaneKey, normalizeWorkflowLaneMetadata } from "../shared/lane-metadata.ts";
 
 const require = createRequire(import.meta.url);
@@ -595,7 +596,7 @@ function spawnRunner(cfg: object, suffix: string, cwd: string, initialStatus: Om
 			...backgroundProcessOptions(),
 			stdio: ["ignore", stdoutFd ?? "ignore", stderrFd ?? "ignore"],
 			env: {
-				...omitExtensionBindingsEnv(process.env),
+				...omitGitRoutingEnv(omitExtensionBindingsEnv(process.env)),
 				[SELESAI_CODING_AGENT_PACKAGE_ROOT_ENV]: piPackageRoot,
 				[JITI_ALIAS_ENV]: JSON.stringify(hostPeerAliases.aliases),
 			},

package/dist/extensions/pi-subagents/src/runs/background/run-child-session.ts

@@ -124,6 +124,7 @@ export interface RunChildSessionResult {
 	observedMutationAttempt?: boolean;
 	structuredOutputToolInvoked?: boolean;
 	structuredOutputMessageStartIndex?: number;
+	structuredOutputFailed?: boolean;
 	watchdog?: ChildWatchdogStateSnapshot;
 	sessionFile?: string;
 	currentTool?: string;

package/dist/extensions/pi-subagents/src/runs/background/run-status.ts

@@ -16,6 +16,7 @@ import { resolveSubagentIntercomTarget } from "../../intercom/intercom-bridge.ts
 import { normalizeExternalCliRunnerStatus } from "../shared/external-cli-contract.ts";
 import { resolveSubagentResultStatus } from "../../intercom/result-intercom.ts";
 import { readProcessTerminal, sanitizeProcessTerminal } from "./process-terminal.ts";
+import { readWorkflowTerminalProof } from "./workflow-terminal-proof.ts";
 import { formatWaitSubscriptions } from "./wait-subscriptions.ts";
 import { resolveAsyncRunLocation } from "./async-resume.ts";
 import { resolveSubagentRunId } from "./run-id-resolver.ts";
@@ -704,7 +705,10 @@ export function inspectSubagentStatus(params: RunStatusParams, deps: RunStatusDe
 
 			const workflowChildren = parseWorkflowChildSummary(status.workflowChildren);
 			if (workflowChildren && workflowChildren.workflowRunId !== status.runId) throw new Error("workflowChildren.workflowRunId does not match async status runId.");
-			return { content: [{ type: "text", text: lines.join("\n") }], details: { mode: "single", results: [], ...(status.workflowReceiptPath ? { workflowReceiptPath: status.workflowReceiptPath } : {}), ...(status.preflight ? { preflight: status.preflight } : {}), ...(status.workflow?.preflightWarnings?.length ? { preflightWarnings: status.workflow.preflightWarnings } : {}), ...(workflowChildren ? { workflowChildren } : {}), ...(runFanoutBudget ? { runFanoutBudget } : {}), ...(processTerminal ? { lifecycleStatus: { processTerminal } } : {}) } };
+			const workflowTerminalProof = workflowChildren
+				? readWorkflowTerminalProof(asyncDir, status.steps, workflowChildren, validHostStepNodes(status.workflowGraph).length, status.endedAt ?? status.lastUpdate ?? status.startedAt)
+				: undefined;
+			return { content: [{ type: "text", text: lines.join("\n") }], details: { mode: "single", results: [], ...(status.workflowReceiptPath ? { workflowReceiptPath: status.workflowReceiptPath } : {}), ...(status.preflight ? { preflight: status.preflight } : {}), ...(status.workflow?.preflightWarnings?.length ? { preflightWarnings: status.workflow.preflightWarnings } : {}), ...(workflowChildren ? { workflowChildren } : {}), ...(workflowTerminalProof ? { workflowTerminalProof } : {}), ...(runFanoutBudget ? { runFanoutBudget } : {}), ...(processTerminal ? { lifecycleStatus: { processTerminal } } : {}) } };
 		}
 	}