@bingjiang0611/rotom 0.1.24 → 0.1.26

package/extensions/third-party/node_modules/pi-subagents/skills/pi-subagents/references/execution-controls.md

@@ -48,7 +48,7 @@ subagent({
 
 ```typescript
 subagent({
-  workflowScript: `return runs.run("oracle-check", { agent: "oracle", task: "Review my current direction and challenge assumptions.", context: "fork" })`
+  workflowScript: `return runs.run("continue-thread", { agent: "delegate", task: "Continue the investigation from the current conversation state.", context: "fork" })`
 })
 ```
 
@@ -86,7 +86,7 @@ Completed workflow children from this parent session stay addressable as retaine
 
 ### Async/background
 
-Prefer async mode for every subagent launch. Set `async: true` no matter the task unless the parent must block until completion. This applies to scouts, researchers, workers, reviewers, validators, oracle checks, one-off delegates, final review gates, backlog gates, and scripted workflows. Keep the write path single-threaded even when the run is async.
+Prefer async mode for every subagent launch. Set `async: true` no matter the task unless the parent must block until completion. This applies to scouts, workers, reviewers, validators, oracle checks, one-off delegates, final review gates, backlog gates, and scripted workflows. Keep the write path single-threaded even when the run is async.
 
 Use `async:false` only when the parent must block until completion. Async mode still shows progress. Do not use `async:false` because a task is short, because it is the last gate, because no other work is ready, because the user asked to finish the overall job, or because blocking is convenient.
 
@@ -358,7 +358,7 @@ worktree, first confirm dependencies were linked, installed, or provisioned by
 
 ### Oracle consultation loop
 
-For plan, design, or architecture advice that asks to ask, consult, discuss with, or come to agreement with `oracle`, start with one forked oracle run. Read its result. If it challenges the direction or leaves a material tradeoff, resume that same completed child once with a focused follow-up, then synthesize the parent decision. `resume` returns a new run id, but continues the same oracle session and inherited context. Do not force a second round for an explicit one-shot request, a trivial question, or a fully settled first answer.
+For plan, design, or architecture advice that asks to ask, consult, discuss with, or come to agreement with `oracle`, start with one fresh oracle run whose task is a decision brief: goal and acceptance criteria, decisions already made and why, hard constraints, the proposed move, the files that matter, and the specific question. Read its result. If it challenges the direction or leaves a material tradeoff, resume that same completed child once with a focused follow-up, then synthesize the parent decision. `resume` returns a new run id, but continues the same oracle session. Do not force a second round for an explicit one-shot request, a trivial question, or a fully settled first answer.
 
 ```typescript
 const first = await runs.run("oracle-consult", { agent: "oracle", task: "Review this plan and identify the strongest unresolved tradeoff." });
@@ -368,14 +368,14 @@ const final = await runs.run("oracle-consult-follow-up", { resume: first.runId,
 The parent remains the final decision-maker. Oracle advice does not approve a direction or start implementation.
 
 The intended oracle loop is:
-1. the main agent forks to `oracle`
+1. the main agent writes a decision brief and launches `oracle` with fresh context
 2. `oracle` reviews direction, drift, assumptions, and risks
 3. `oracle` can coordinate back through `contact_supervisor` when the bridge injects it
 4. the main agent decides what direction to approve
 5. only then should `worker` implement
 
 ```typescript
-// Advisory review in a branched thread. Oracle defaults to forked context.
+// Advisory review from a parent-written decision brief. Oracle defaults to fresh context.
 subagent({
   workflowScript: `return runs.run("oracle-check", { agent: "oracle", task: "Review my current direction, challenge assumptions, and propose the best next move." })`
 })

package/extensions/third-party/node_modules/pi-subagents/skills/pi-subagents/references/prompting-and-roles.md

@@ -9,7 +9,7 @@ Parent extensions may register a session-scoped, out-of-band ceiling through `pi
 ## When to Use
 
 - **Complex work orchestration**: use Fable mode as the default parent-agent loop for complex work. Complex means the task has multiple moving parts, unclear acceptance, cross-cutting code, meaningful user-visible impact, expensive or irreversible validation, broad review surface, or the user asks for orchestration. Lightweight one-off delegation can stay lightweight.
-- **Advisory review**: use fresh-context `reviewer` agents for adversarial code review, or fork to `oracle` when inherited decisions and drift matter
+- **Advisory review**: use fresh-context `reviewer` agents for adversarial code review, or give `oracle` a written decision brief when prior decisions and drift matter
 - **Implementation handoff**: have `oracle` advise, then `worker` implement only after an approved direction
 - **Recon and planning**: use `scout`, then write a plan when needed
 - **Parallel exploration**: run multiple non-conflicting tasks concurrently
@@ -41,7 +41,7 @@ you are guiding a human through an interactive flow.
 Packaged prompt shortcuts are also available for repeatable workflows. Treat them as reusable orchestration recipes, not just human slash commands. When the user asks for one of these shapes, or when the workflow clearly fits, apply the same pattern directly with `subagent(...)` and other tools:
 - `/parallel-review` — fresh-context reviewers with distinct review angles, then synthesis
 - `/review-loop` — parent-orchestrated worker, fresh-reviewer, and fix-worker cycles until clean or capped
-- `/parallel-research` — combine `researcher` and `scout` for external evidence plus local code context
+- `/parallel-research` — combine parallel `scout` lanes for local code context with external evidence the parent gathers
 - `/gather-context-and-clarify` — scout/research first, then ask the user clarifying questions with `interview`
 - `/parallel-cleanup` — two fresh-context reviewers (deslop + verbosity passes) for an adversarial cleanup review of the current diff
 
@@ -87,13 +87,13 @@ As a conservative orchestration policy, do not pass `turnBudget` or a hard `tool
 
 ### Parallel research technique
 
-Use this when the question needs both external evidence and local implications. Combine `researcher` for official docs, specs, ecosystem behavior, recent changes, benchmarks, and primary sources with `scout` for repository files, patterns, constraints, tests, and likely integration points. Give each child a distinct angle: external evidence, local code context, and practical tradeoffs. Ask for source links or file ranges, confidence level, gaps, and decision implications. Do not ask these children to edit unless implementation was explicitly requested.
+Use this when the question needs both external evidence and local implications. The parent gathers official docs, specs, ecosystem behavior, recent changes, benchmarks, and primary sources itself (there is no builtin web-research agent) and uses `scout` for repository files, patterns, constraints, tests, and likely integration points. Give each child a distinct angle: external evidence, local code context, and practical tradeoffs. Ask for source links or file ranges, confidence level, gaps, and decision implications. Do not ask these children to edit unless implementation was explicitly requested.
 
 
 
 ### Gather-context-and-clarify technique
 
-Use this at the start of non-trivial work. Launch `scout` for local context and `researcher` only when external docs, recent sources, ecosystem context, or primary evidence would materially improve understanding. Ask children for concise findings plus remaining clarification questions. Then synthesize what is known and use `interview` to ask the unresolved questions needed for shared understanding before planning or implementing.
+Use this at the start of non-trivial work. Launch `scout` for local context, and gather external docs, recent sources, ecosystem context, or primary evidence in the parent only when they would materially improve understanding. Ask children for concise findings plus remaining clarification questions. Then synthesize what is known and use `interview` to ask the unresolved questions needed for shared understanding before planning or implementing.
 
 ### Parallel cleanup technique
 
@@ -157,10 +157,9 @@ and user/project agents override builtins with the same name.
 |-------|---------|-------|------------------------|
 | `scout` | Fast codebase recon | inherits default | Writes `context.md` handoff material |
 | `worker` | Implementation and approved oracle handoffs | inherits default | Single-writer implementation with decision escalation |
-| `reviewer` | Review specialist | inherits default | Default recipes are review-only; tools include edit/write when a fix pass is explicit |
-| `researcher` | Web research brief generator | inherits default | Writes `research.md` |
+| `reviewer` | Review specialist | inherits default | Review-only; `bash` limited by prompt to read-only inspection and existing checks |
 | `delegate` | Lightweight generic delegate | inherits default | No fixed output; generic delegated work |
-| `oracle` | Decision-consistency advisory review | inherits default | Advisory review, intercom coordination |
+| `oracle` | Decision-consistency advisory review | inherits default | Read-only; fresh context from a parent-written decision brief |
 | `advisor` | Claude Code-compatible alias for `oracle` | inherits default | Same advisory role as `oracle` |
 
 Builtin `worker` and `delegate` use strict tool allowlists and do not inherit ambient parent extension tools. To give a child an extension tool, name it in `tools` and load its provider via `extensions`, a path-like `tools` entry, or `subagentOnlyExtensions`. Custom agents without an `extensions` field follow `subagents.defaultExtensions` when set.
@@ -206,7 +205,7 @@ A strong subagent prompt usually includes:
 
 Give each role useful discovery anchors. Name source roots, filenames, symbols, types, methods, and paths for scouts. Give workers context files, plans, task paths, and named source seams before asking them to search. Give reviewers changed files, contracts, and any exhaustive-verification target. Tell oracle whether current source behavior, product/policy documents, plans, or inherited decisions are the evidence that matters.
 
-Avoid carrying over old prompt habits that over-specify every step. Use `must`, `always`, and `never` for real invariants; for judgment calls, give decision rules. For example, tell a reviewer to inspect the staged diff directly and report only evidence-backed findings, rather than prescribing every file or command. Tell a researcher the retrieval budget: start with broad targeted searches, fetch only the strongest sources, search again only when a required fact is missing, then stop.
+Avoid carrying over old prompt habits that over-specify every step. Use `must`, `always`, and `never` for real invariants; for judgment calls, give decision rules. For example, tell a reviewer to inspect the staged diff directly and report only evidence-backed findings, rather than prescribing every file or command.
 
 For implementation handoffs, name the approved scope and success criteria more clearly than the process. Good prompts say what to change, what not to change, where the evidence lives, how to validate, and when to escalate. They should not ask the child to create another subagent plan or continue the parent conversation.
 

package/extensions/third-party/node_modules/pi-subagents/src/agents/agents.ts

@@ -39,7 +39,6 @@ export const BUILTIN_AGENT_NAMES = [
 	"advisor",
 	"delegate",
 	"oracle",
-	"researcher",
 	"reviewer",
 	"scout",
 	"worker",

package/extensions/third-party/node_modules/pi-subagents/src/extension/index.ts

@@ -47,6 +47,7 @@ import { resolveWaitToolConfig } from "../runs/background/subagent-wait.ts";
 import { registerWaitTool } from "../runs/background/wait-tool.ts";
 import { createWaitSubscriptionManager } from "../runs/background/wait-subscriptions.ts";
 import { drainOutstandingWork } from "../runs/background/auto-drain.ts";
+import { asyncRunnerDrain } from "../runs/background/async-execution.ts";
 import registerSubagentNotify, { parseSubagentNotifyContent, type SubagentNotifyDetails } from "../runs/background/notify.ts";
 import { formatSteeringNotice, handleSubagentSteeringNotice, SUBAGENT_STEERING_MESSAGE_TYPE, type SubagentSteeringMessageDetails } from "./steering-notices.ts";
 import { SUBAGENT_CHILD_ENV, SUBAGENT_PARENT_SESSION_ENV } from "../runs/shared/pi-args.ts";
@@ -950,7 +951,13 @@ export default function registerSubagentExtension(pi: ExtensionAPI): void {
 	});
 
 	pi.on("session_shutdown", async () => {
-		runtimeEntry.cleanup();
-		await herdrStatusBridge.flush();
+		try {
+			// Quit, reload and replacement retire this runtime's authority. Persist
+			// child close evidence before disposing the original observers.
+			await asyncRunnerDrain(pi).drain();
+		} finally {
+			runtimeEntry.cleanup();
+			await herdrStatusBridge.flush();
+		}
 	});
 }

package/extensions/third-party/node_modules/pi-subagents/src/profiles/profiles.ts

@@ -261,7 +261,7 @@ function qualityTierToRoleTier(quality: QualityTier, cost: CostTier): Recommende
 
 function agentsForRoleTier(roleTier: RecommendedRoleTier): BuiltinAgentName[] {
 	if (roleTier === "cheap") return ["scout", "delegate"];
-	if (roleTier === "medium") return ["researcher", "reviewer"];
+	if (roleTier === "medium") return ["reviewer"];
 	return ["worker", "reviewer", "oracle"];
 }
 
@@ -407,7 +407,6 @@ function buildProfileFile(kind: ProfileKind, models: { cheap: string; medium: st
 			agentOverrides: {
 				scout: { model: models.cheap },
 				delegate: { model: models.cheap },
-				researcher: { model: models.medium },
 				worker: { model: models.strong },
 				reviewer: { model: models.strong },
 				oracle: { model: models.strong },

package/extensions/third-party/node_modules/pi-subagents/src/runs/background/async-execution.ts

@@ -67,7 +67,9 @@ import { validateToolBudgetConfig } from "../shared/tool-budget.ts";
 import { usageBudgetState } from "../shared/usage-budget.ts";
 import type { ImportedAsyncRoot } from "./chain-root-attachment.ts";
 import type { SessionLeaseRequest } from "../shared/session-lease.ts";
-import { finalizeProcessTerminal, readProcessTerminal } from "./process-terminal.ts";
+import { finalizeProcessTerminal, readProcessTerminal, registerRunnerCloseObserver } from "./process-terminal.ts";
+import { createRunnerDrain } from "./runner-drain.ts";
+
 import type { ActiveAsyncCapacityHandle } from "./active-async-capacity.ts";
 import { assertExecutionStoreScope, scopedSessionRoot, assertScopedSessionPath } from "../../shared/execution-store.ts";
 import { OWNED_EXECUTION_SCOPE, type OwnedExecutionRequest, type OwnedWorkflowParent } from "./owned-execution.ts";
@@ -76,6 +78,17 @@ import { assertAgentAllowedByCapabilityCeiling, decodeSubagentCapabilityCeiling,
 import { agentDefinitionDigest, launchBindingDigest } from "../../shared/launch-contract.ts";
 import { resolvePermissionRules, type PermissionConfig } from "../shared/permissions.ts";
 
+// Each runtime owns live ChildProcess handles, never historical PIDs.
+const runtimeRunnerDrains = new WeakMap<object, ReturnType<typeof createRunnerDrain>>();
+export function asyncRunnerDrain(owner: object): ReturnType<typeof createRunnerDrain> {
+	let drain = runtimeRunnerDrains.get(owner);
+	if (!drain) {
+		drain = createRunnerDrain();
+		runtimeRunnerDrains.set(owner, drain);
+	}
+	return drain;
+}
+
 const require = createRequire(import.meta.url);
 const piPackageRoot = resolvePiPackageRoot();
 
@@ -487,7 +500,8 @@ interface SpawnRunnerResult {
 	startupDidNotProceed?: boolean;
 }
 
-function spawnRunner(cfg: object, suffix: string, cwd: string, onProcessTerminal?: (proof: unknown) => void): SpawnRunnerResult {
+function spawnRunner(cfg: object, suffix: string, cwd: string, drain: ReturnType<typeof createRunnerDrain>, onProcessTerminal?: (proof: unknown) => void): SpawnRunnerResult {
+	drain.assertOpen();
 	if (!jitiCliPath) {
 		return { error: "upstream jiti for TypeScript execution could not be found; ensure package dependencies are installed" };
 	}
@@ -546,62 +560,75 @@ function spawnRunner(cfg: object, suffix: string, cwd: string, onProcessTerminal
 		proc.on("error", (error) => {
 			console.error(`[pi-subagents] async spawn failed: ${error.message}`);
 		});
+		const releaseCloseObserver = typeof launchAsyncDir === "string" && typeof launchRunId === "string"
+			? registerRunnerCloseObserver(launchAsyncDir, launchRunId, runnerProcessInstanceId) : undefined;
+		const observedClose = drain.track(() => {
+			// Awaiting a Promise alone cannot keep Node alive after RPC stdin closes.
+			proc.ref();
+			if (proc.exitCode === null && proc.signalCode === null) proc.kill("SIGTERM");
+		});
 		proc.once("close", (exitCode, signal) => {
-			const launch = launchConfig as { asyncDir?: unknown; id?: unknown; nestedRoute?: NestedRouteInfo; nestedSelf?: { parentRunId: string; parentStepIndex?: number; depth: number; path?: Array<{ runId: string; stepIndex?: number; agent?: string }> } };
-			const asyncDir = launch.asyncDir;
-			const runId = launch.id;
-			if (typeof asyncDir !== "string" || typeof runId !== "string") return;
-			finalizeProcessTerminal(asyncDir, runId, {
-				processInstanceId: runnerProcessInstanceId,
-				closeObservedAt: Date.now(),
-				exitCode,
-				signal,
-			});
-			const persisted = readProcessTerminal(asyncDir, { runId, runnerProcessInstanceId });
-			if (!persisted) return;
-			if (launch.nestedRoute && launch.nestedSelf) {
-				try {
-					let status: import("../../shared/types.ts").AsyncStatus;
+			try {
+				const launch = launchConfig as { asyncDir?: unknown; id?: unknown; nestedRoute?: NestedRouteInfo; nestedSelf?: { parentRunId: string; parentStepIndex?: number; depth: number; path?: Array<{ runId: string; stepIndex?: number; agent?: string }> } };
+				const asyncDir = launch.asyncDir;
+				const runId = launch.id;
+				if (typeof asyncDir !== "string" || typeof runId !== "string") return;
+				finalizeProcessTerminal(asyncDir, runId, {
+					processInstanceId: runnerProcessInstanceId,
+					closeObservedAt: Date.now(),
+					exitCode,
+					signal,
+				});
+				const persisted = readProcessTerminal(asyncDir, { runId, runnerProcessInstanceId });
+				if (!persisted) return;
+				if (launch.nestedRoute && launch.nestedSelf) {
 					try {
-						status = JSON.parse(fs.readFileSync(path.join(asyncDir, "status.json"), "utf-8")) as import("../../shared/types.ts").AsyncStatus;
-						status.processTerminal = persisted;
-					} catch {
-						status = {
-							runId,
-							mode: "single",
-							state: persisted.state === "observed" ? "complete" : "failed",
-							startedAt: persisted.observedAt ?? Date.now(),
-							lastUpdate: Date.now(),
-							processTerminal: persisted,
-						};
-					}
-					writeNestedEvent(launch.nestedRoute, {
-						type: "subagent.nested.completed",
-						ts: Date.now(),
-						parentRunId: launch.nestedSelf.parentRunId,
-						parentStepIndex: launch.nestedSelf.parentStepIndex,
-						child: nestedSummaryFromAsyncStatus(status, asyncDir, {
-							id: runId,
+						let status: import("../../shared/types.ts").AsyncStatus;
+						try {
+							status = JSON.parse(fs.readFileSync(path.join(asyncDir, "status.json"), "utf-8")) as import("../../shared/types.ts").AsyncStatus;
+							status.processTerminal = persisted;
+						} catch {
+							status = {
+								runId,
+								mode: "single",
+								state: persisted.state === "observed" ? "complete" : "failed",
+								startedAt: persisted.observedAt ?? Date.now(),
+								lastUpdate: Date.now(),
+								processTerminal: persisted,
+							};
+						}
+						writeNestedEvent(launch.nestedRoute, {
+							type: "subagent.nested.completed",
+							ts: Date.now(),
 							parentRunId: launch.nestedSelf.parentRunId,
 							parentStepIndex: launch.nestedSelf.parentStepIndex,
-							depth: launch.nestedSelf.depth,
-							path: launch.nestedSelf.path,
-							mode: status.mode,
-							ts: Date.now(),
-						}),
-					});
+							child: nestedSummaryFromAsyncStatus(status, asyncDir, {
+								id: runId,
+								parentRunId: launch.nestedSelf.parentRunId,
+								parentStepIndex: launch.nestedSelf.parentStepIndex,
+								depth: launch.nestedSelf.depth,
+								path: launch.nestedSelf.path,
+								mode: status.mode,
+								ts: Date.now(),
+							}),
+						});
+					} catch (error) {
+						console.error("Failed to emit final nested process-terminal status:", error);
+					}
+				}
+				try {
+					onProcessTerminal?.(persisted);
 				} catch (error) {
-					console.error("Failed to emit final nested process-terminal status:", error);
+					// The close proof is already durable. Reload/disposal can retire the
+					// originating Pi API before this late advisory wake; never redirect it
+					// to a new session or claim a receipt. Recovery must read the record.
+					if (!(error instanceof Error)
+						|| !/extension ctx is stale|stale after session replacement or reload/i.test(error.message)) throw error;
 				}
-			}
-			try {
-				onProcessTerminal?.(persisted);
-			} catch (error) {
-				// The close proof is already durable. Reload/disposal can retire the
-				// originating Pi API before this late advisory wake; never redirect it
-				// to a new session or claim a receipt. Recovery must read the record.
-				if (!(error instanceof Error)
-					|| !/extension ctx is stale|stale after session replacement or reload/i.test(error.message)) throw error;
+			} finally {
+				// Finalization (including honest unknown) precedes runtime teardown.
+				releaseCloseObserver?.();
+				observedClose();
 			}
 		});
 		if (typeof proc.pid !== "number") {
@@ -1202,6 +1229,7 @@ export function executeAsyncChain(
 			},
 			id,
 			runnerCwd,
+			asyncRunnerDrain(ctx.pi),
 			(proof) => ctx.pi.events.emit(SUBAGENT_PROCESS_TERMINAL_EVENT, proof),
 		);
 	} catch (error) {
@@ -1684,6 +1712,7 @@ export function executeAsyncSingle(
 			},
 			id,
 			runnerCwd,
+			asyncRunnerDrain(ctx.pi),
 			(proof) => ctx.pi.events.emit(SUBAGENT_PROCESS_TERMINAL_EVENT, proof),
 		);
 	} catch (error) {

package/extensions/third-party/node_modules/pi-subagents/src/runs/background/process-terminal.ts

@@ -13,6 +13,19 @@ import { canonicalSessionId, inspectSessionLease } from "../shared/session-lease
 import { releaseActiveRunIndex } from "./active-run-index.ts";
 import { validOwnedExecution, projectOwnedClosure, type OwnedExecutionV2 } from "./owned-execution.ts";
 
+// Process-local liveness of the original observer, not evidence of exit. A new
+// parent cannot reconstruct this registration from disk or a numeric PID.
+const runnerCloseObservers = new Set<string>();
+const observerKey = (asyncDir: string, runId: string, instanceId: string) => JSON.stringify([path.resolve(asyncDir), runId, instanceId]);
+export function registerRunnerCloseObserver(asyncDir: string, runId: string, instanceId: string): () => void {
+	const key = observerKey(asyncDir, runId, instanceId);
+	runnerCloseObservers.add(key);
+	return () => { runnerCloseObservers.delete(key); };
+}
+export function hasRunnerCloseObserver(asyncDir: string, runId: string, instanceId: string): boolean {
+	return runnerCloseObservers.has(observerKey(asyncDir, runId, instanceId));
+}
+
 export interface ProcessTerminalCandidate {
 	version: 1;
 	runId: string;

package/extensions/third-party/node_modules/pi-subagents/src/runs/background/stale-run-reconciler.ts

@@ -7,6 +7,7 @@ import { readStatus } from "../../shared/utils.ts";
 import { DIRS, type AsyncParallelGroupStatus, type AsyncStatus, type NestedRunSummary, type SubagentRunMode } from "../../shared/types.ts";
 import { resolveEffectiveThinking } from "../../shared/model-info.ts";
 import { normalizeParallelGroups } from "./parallel-groups.ts";
+import { hasRunnerCloseObserver } from "./process-terminal.ts";
 import { nestedSummaryFromAsyncStatus, projectNestedEvents, resolveNestedAsyncDir, writeNestedEvent, type NestedRoute } from "../shared/nested-events.ts";
 
 export type PidLiveness = "alive" | "dead" | "unknown";
@@ -141,7 +142,7 @@ function childState(overallState: ResultRepairData["state"], child: ResultChildO
 	return overallState;
 }
 
-function terminalStatusFromResult(status: AsyncStatus, resultPath: string, now: number): AsyncStatus | undefined {
+function terminalStatusFromResult(status: AsyncStatus, resultPath: string, now: number, asyncDir: string): AsyncStatus | undefined {
 	const repair = readResultRepairData(resultPath);
 	if (!repair) return undefined;
 	const steps = (status.steps ?? []).map((step, index) => {
@@ -168,7 +169,10 @@ function terminalStatusFromResult(status: AsyncStatus, resultPath: string, now:
 	const terminalStatus: AsyncStatus = {
 		...status,
 		state: repair.state,
-		...(status.lifecycleArtifactVersion === 3 && (!status.processTerminal || status.processTerminal.state === "pending") ? {
+		...(status.lifecycleArtifactVersion === 3 && (!status.processTerminal || status.processTerminal.state === "pending")
+			// A result can precede the launching parent's native close callback.
+			// Retain pending for that actual observer; this never proves exit.
+			&& !(status.processTerminal?.state === "pending" && hasRunnerCloseObserver(asyncDir, status.runId, status.processTerminal.runnerProcessInstanceId)) ? {
 			processTerminal: { version: 1 as const, state: "unknown" as const, runId: status.runId, runnerProcessInstanceId: "observer-unavailable", reason: "observer-unavailable" as const },
 		} : {}),
 		...(repair.state === "stopped" ? { stopped: true } : {}),
@@ -379,7 +383,7 @@ export function reconcileAsyncRun(asyncDir: string, options: ReconcileAsyncRunOp
 		: regularFileExists(resultPath) ? resultPath : undefined;
 	if (existingResultPath) {
 		const terminalStatus = effectiveStatus.state === "running" || effectiveStatus.state === "queued"
-			? terminalStatusFromResult(effectiveStatus, existingResultPath, now)
+			? terminalStatusFromResult(effectiveStatus, existingResultPath, now, asyncDir)
 			: undefined;
 		if (terminalStatus) {
 			writeAtomicJson(path.join(asyncDir, "status.json"), terminalStatus);

package/extensions/third-party/node_modules/sol-pi/UPSTREAM.md

@@ -3,13 +3,18 @@
 - Upstream: SoL-Pi, <https://github.com/NVlabs/SoL-Pi>. License: MIT, Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES; the original notice stays in `LICENSE`.
 - Upstream base: `2b791687` ("Update Pi to 0.85.1 and verify 0.84.2 compatibility (#63)").
 - Source: the maintainer's SoL-Pi branch at `b463fad0ffab6e42488f5c80687adab67174a0ee`, imported from its tracked files. On top of the upstream base it carries five commits: recalled pages keep source references (`81b80b0`), the Pi 0.85 compaction-reason test (`83c5426`), the 0.85.1 baseline merge (`807ad60`), selected upstream reliability backports (`32840b2`), and Pi error-result handling plus runtime compatibility repairs (`b463fad`).
-- Maintained version: `0.1.0-rotom.0`, a private component of [rotom](https://github.com/bingjiang0611/rotom). It is not an upstream or npm release.
+- Maintained version: `0.1.0-rotom.1`, a private component of [rotom](https://github.com/bingjiang0611/rotom). It is not an upstream or npm release.
 
 ## Changes in this import
 
-- `package.json` / `package-lock.json`: version `0.1.0-rotom.0`, rotom description, `UPSTREAM.md` added to and the hero image removed from the packed files.
+- `package.json` / `package-lock.json`: version `0.1.0-rotom.1`, rotom description, `UPSTREAM.md` added to and the hero image removed from the packed files.
 - Not imported: `.github/`, `AGENTS.md`, `CLAUDE.md`, `.gitattributes` and `assets/` (the README hero image link is therefore broken in this copy).
-- `src/` and `tests/` are byte-identical to the source commit.
+- `src/` and `tests/` were byte-identical to the source commit in `0.1.0-rotom.0`.
+
+## rotom changes
+
+- `0.1.0-rotom.1`: the Evidence-Preserving Reducer records each returned reducer response (applied or rejected) as a Pi `usage` entry of kind `sol_pi_reducer`, attributed to the reducer provider/model with the provider-reported usage unchanged. Pi's footer, session stats, usage breakdown and Goal budgets then include the reducer spend. It uses `pi.appendUsage`, which the rotom Pi fork exposes from `1.3.0-rotom.2`; on Pi releases without it (upstream Pi) only the SoL-Pi journal entry is written, as before. Calls that throw before a response (timeout, unavailable model, missing auth) record no usage. Files: `evidence-preserving-reducer/{provider,journal,index}.ts`, `tests/helpers.ts`, `tests/evidence-preserving-reducer.test.ts`.
+- `0.1.0-rotom.2`: an `unverifiable-quote` fallback journal entry now carries a `quoteDiagnostic` for the first rejected evidence item: `cause` (`invalid-kind`, `not-a-string`, `empty`, `too-long` or `not-in-source`), its index and the evidence count, the quote length and SHA-256, and for `not-in-source` the longest leading part found in the log with its line, plus whether the quote would match after removing ANSI escapes or collapsing whitespace. It never stores quote or log text. Acceptance is unchanged: a receipt is still rejected unless every quote appears byte for byte. Files: `evidence-preserving-reducer/{receipt,index}.ts`, `tests/evidence-preserving-reducer.test.ts`.
 
 ## How rotom uses it
 

package/extensions/third-party/node_modules/sol-pi/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "sol-pi",
-	"version": "0.1.0-rotom.0",
+	"version": "0.1.0-rotom.2",
 	"description": "rotom-maintained build of SoL-Pi: context and tool-efficiency extensions for Pi",
 	"type": "module",
 	"private": true,

package/extensions/third-party/node_modules/sol-pi/src/sol-pi/extensions/evidence-preserving-reducer/index.ts

@@ -39,7 +39,7 @@ import {
 	type ReducerConfigOptions,
 	sha256,
 } from "./config.ts";
-import { createJournal, type Journal } from "./journal.ts";
+import { createJournal, createUsageRecorder, type Journal, type UsageRecorder } from "./journal.ts";
 import { callReducer, type ProviderResult } from "./provider.ts";
 import { receiptText, validateReceipt } from "./receipt.ts";
 
@@ -57,6 +57,7 @@ function errorName(error: unknown): string | undefined {
 
 export async function reduceToolResult(
 	journal: Journal,
+	recordUsage: UsageRecorder,
 	config: ReducerConfig,
 	event: ToolResultEvent,
 	context: ExtensionContext,
@@ -103,6 +104,7 @@ export async function reduceToolResult(
 		return undefined;
 	}
 
+	recordUsage(provider);
 	journal("provider_response", {
 		toolCallId: event.toolCallId,
 		sourceSha256: archive.hash,
@@ -129,6 +131,7 @@ export async function reduceToolResult(
 			toolCallId: event.toolCallId,
 			sourceSha256: archive.hash,
 			reason: checked.reason,
+			quoteDiagnostic: checked.quoteDiagnostic,
 			usage: provider.usage,
 		});
 		return undefined;
@@ -179,6 +182,7 @@ export async function reduceToolResult(
 export function createEvidencePreservingReducerExtension(options: EvidencePreservingReducerOptions = {}): ExtensionFactory {
 	return (pi: ExtensionAPI) => {
 		const states = new Map<string, { config: ReducerConfig; journal: Journal }>();
+		const recordUsage = createUsageRecorder(pi);
 		pi.on("tool_result", (event, context) => {
 			let root: string;
 			try {
@@ -192,7 +196,7 @@ export function createEvidencePreservingReducerExtension(options: EvidencePreser
 				state = { config, journal: createJournal(pi, config) };
 				states.set(root, state);
 			}
-			return reduceToolResult(state.journal, state.config, event, context);
+			return reduceToolResult(state.journal, recordUsage, state.config, event, context);
 		});
 	};
 }

package/extensions/third-party/node_modules/sol-pi/src/sol-pi/extensions/evidence-preserving-reducer/journal.ts

@@ -2,8 +2,13 @@
  * SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
  * SPDX-License-Identifier: MIT
  */
+import type { Usage } from "@earendil-works/pi-ai";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { REDUCER_EVENT_SCHEMA, REDUCER_EVENT_TYPE, type ReducerConfig } from "./config.ts";
+import type { ProviderResult } from "./provider.ts";
+
+/** Pi usage-entry kind for reducer model calls. */
+export const REDUCER_USAGE_KIND = "sol_pi_reducer";
 
 /**
  * Append one non-context session entry per decision the reducer made.
@@ -23,3 +28,19 @@ export function createJournal(pi: ExtensionAPI, config: ReducerConfig): Journal
 		});
 	};
 }
+
+type AppendUsage = (kind: string, provider: string, model: string, usage: Usage, note?: string) => void;
+export type UsageRecorder = (provider: ProviderResult) => void;
+
+/**
+ * Record each reducer response in Pi's usage entries so footer, session stats
+ * and budgets include the reducer spend. Pi releases without
+ * `pi.appendUsage` (upstream Pi) keep only the journal record.
+ */
+export function createUsageRecorder(pi: ExtensionAPI): UsageRecorder {
+	const appendUsage = (pi as ExtensionAPI & { appendUsage?: AppendUsage }).appendUsage;
+	if (typeof appendUsage !== "function") return () => {};
+	return (provider) => {
+		appendUsage.call(pi, REDUCER_USAGE_KIND, provider.provider, provider.responseModel, provider.responseUsage);
+	};
+}

package/extensions/third-party/node_modules/sol-pi/src/sol-pi/extensions/evidence-preserving-reducer/provider.ts

@@ -3,7 +3,7 @@
  * SPDX-License-Identifier: MIT
  */
 
-import type { Api, AssistantMessage, Context, Model, ProviderStreamOptions } from "@earendil-works/pi-ai";
+import type { Api, AssistantMessage, Context, Model, ProviderStreamOptions, Usage } from "@earendil-works/pi-ai";
 import { complete as completeCompat } from "@earendil-works/pi-ai/compat";
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import type { ArchiveObject } from "./archive.ts";
@@ -44,6 +44,10 @@ export interface ProviderResult {
 	readonly ok: boolean;
 	readonly outputText: string;
 	readonly provider: string;
+	/** Concrete model that served the request, for usage attribution. */
+	readonly responseModel: string;
+	/** Provider-reported usage including cost, recorded unchanged in Pi's usage entries. */
+	readonly responseUsage: Usage;
 	readonly stopReason: AssistantMessage["stopReason"];
 	readonly usage: NormalizedUsage;
 }
@@ -154,6 +158,8 @@ export async function callReducer(
 			ok: response.stopReason === "stop" || response.stopReason === "length",
 			outputText: responseOutputText(response),
 			provider: response.provider,
+			responseModel: response.responseModel ?? response.model,
+			responseUsage: response.usage,
 			stopReason: response.stopReason,
 			usage: normalizedUsage(response),
 		};