@ferris1225/pi-subagents 1.0.0 → 2.0.0

package/src/monitor.ts

@@ -11,8 +11,7 @@
 import { stripVTControlCharacters } from "node:util";
 import type { Theme } from "@earendil-works/pi-coding-agent";
 import { visibleWidth } from "@earendil-works/pi-tui";
-import type { UsageStats } from "./spawn.ts";
-import { redactSensitiveText } from "./trajectory.ts";
+import { emptyUsage, type UsageStats } from "./rpc-run.ts";
 import type { IsolationMode, WorktreeFinalizationStatus } from "./worktree.ts";
 
 // ---------------------------------------------------------------------------
@@ -34,7 +33,7 @@ export interface RunView {
 	 * are doing, not just their run id. */
 	label?: string;
 	model?: string;
-	/** Primary model ref when the run advanced to another candidate in its pool. */
+	/** Selected model ref when the run handed off to current main. */
 	modelFallbackFrom?: string;
 	/** Effective thinking strength this run was launched with (frontmatter/config/global). */
 	thinking?: string;
@@ -46,14 +45,6 @@ export interface RunView {
 	usage: UsageStats;
 	/** Concise current activity ("thinking", "read src/index.ts"); last writer wins. */
 	activity?: string;
-	/** Total tool calls started by the run so far (a progress signal). */
-	toolCount?: number;
-	/** Tool currently executing (set on tool_start, cleared on tool_end). When set,
-	 * the run is NOT idle for needs-attention purposes. */
-	currentTool?: string;
-	/** Epoch ms of the last live activity (tool, usage, status). Used to derive
-	 * the needs-attention state: no tool running AND now - lastActivityAt > threshold. */
-	lastActivityAt?: number;
 	/** Epoch ms when the run started executing (set on first "running" status). */
 	startedAt?: number;
 	/** Epoch ms when the run finished (set on "done"/"failed"). */
@@ -62,16 +53,6 @@ export interface RunView {
 	groupId?: string;
 	/** Human-readable role within a chain, e.g. "fix round 1" or "re-review round 1". */
 	relationLabel?: string;
-	/** Free-form orchestration note (e.g. "auto-fix chain running"). */
-	annotation?: string;
-	/** One-line outcome summary of a finished chain run: a reviewer reports its verdict
-	 * plus key fragments of what it found ("fail · src/index.ts · render()"), a
-	 * worker the fragments of what it changed. Unset for non-chain runs. */
-	summary?: string;
-	/** True when a finished run remains in monitor state (e.g. an auto-fix
-	 * parent whose chain is still running). beginTurn preserves
-	 * retained runs so they are not swept between turns. */
-	retained?: boolean;
 }
 
 /** Optional chain metadata for runs spawned by an auto-fix loop. */
@@ -280,18 +261,40 @@ export function formatDuration(ms: number): string {
 /** Elapsed wall time of a run: live while running, final once finished. */
 export function formatElapsed(run: RunView, now: number = Date.now()): string {
 	if (run.startedAt === undefined) return "";
-	// A retained row (e.g. an auto-fix chain parent whose chain is still running)
-	// must keep ticking: its `endedAt` was stamped when the review itself
-	// finished, but the work is ongoing, so show live elapsed until the chain
-	// resolves and the row is removed. Without this, subagent_status would show a
-	// frozen elapsed for a run the UI otherwise presents as still active.
-	const end = run.retained ? now : (run.endedAt ?? now);
-	return formatDuration(end - run.startedAt);
+	return formatDuration((run.endedAt ?? now) - run.startedAt);
 }
 
 /** Max length of the argument target inside a formatted activity line. */
 export const ACTIVITY_TARGET_MAX = 60;
 
+const REDACTED = "<redacted>";
+
+/** Remove credentials embedded in otherwise ordinary activity strings such as
+ * shell commands and HTTP headers. */
+function redactSensitiveText(value: string): string {
+	let text = stripVTControlCharacters(value);
+	text = text.replace(
+		/(\bauthorization\s*:\s*(?:bearer|basic)\s+)([^\s'"`;,]+)/giu,
+		`$1${REDACTED}`,
+	);
+	text = text.replace(
+		/(\bbearer\s+)([A-Za-z0-9._~+/=-]{6,})/giu,
+		`$1${REDACTED}`,
+	);
+	text = text.replace(
+		/(\b(?:api[-_]?key|apikey|access[-_]?token|refresh[-_]?token|token|password|passwd|secret|credential|cookie)\b\s*(?:=|:)\s*)(?:"[^"]*"|'[^']*'|[^\s;&,]+)/giu,
+		`$1${REDACTED}`,
+	);
+	text = text.replace(
+		/((?:--?(?:api[-_]?key|access[-_]?token|token|password|secret|credential))\s+)(?:"[^"]*"|'[^']*'|\S+)/giu,
+		`$1${REDACTED}`,
+	);
+	return text.replace(
+		/\b(?:sk-[A-Za-z0-9_-]{8,}|gh[pousr]_[A-Za-z0-9]{8,}|AKIA[A-Z0-9]{16})\b/gu,
+		REDACTED,
+	);
+}
+
 /** Monitor activity is returned to the parent model and rendered in the terminal,
  * so treat every live string as untrusted before it reaches store state. */
 function sanitizeActivityText(value: string): string {
@@ -363,19 +366,22 @@ export class MonitorStore {
 	private subscribers = new Set<() => void>();
 
 	beginTurn(): void {
-		// Clear finished runs from a previous turn, but keep any still-active
-		// (queued/running) ones so a concurrent sub-agent call is not wiped.
-		// Retained runs (e.g. an auto-fix chain parent whose chain is still
-		// running) are also preserved — their status is "done" but they must
-		// stay visible until the chain resolves.
+		// Clear finished runs from a previous turn, but keep active and parked
+		// threads so concurrent work is not wiped between parent turns.
 		this.runs = this.runs.filter(
-			(r) => isRunActiveStatus(r.status) || r.status === "parked" || r.retained,
+			(r) => isRunActiveStatus(r.status) || r.status === "parked",
 		);
 		this.notify();
 	}
 
+	/** Reserve a stable id for a durable result that must remain independently
+	 * addressable without appearing as a live monitor row. */
+	reserveRunId(): number {
+		return this.nextId++;
+	}
+
 	addRun(agent: string, task: string, model?: string, thinking?: string, meta?: RunChainMeta): number {
-		const id = this.nextId++;
+		const id = this.reserveRunId();
 		this.runs.push({
 			id,
 			agent,
@@ -384,7 +390,7 @@ export class MonitorStore {
 			model,
 			thinking,
 			status: "queued",
-			usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, contextTokens: 0, turns: 0 },
+			usage: emptyUsage(),
 			...(meta?.groupId ? { groupId: meta.groupId } : {}),
 			...(meta?.relationLabel ? { relationLabel: meta.relationLabel } : {}),
 			...(meta?.isolation ? { isolation: meta.isolation, integrationStatus: meta.isolation === "worktree" ? "pending" : undefined } : {}),
@@ -400,10 +406,9 @@ export class MonitorStore {
 		run.status = status;
 		if (status === "running" || status === "steering" || status === "interrupting") {
 			if (run.startedAt === undefined) run.startedAt = Date.now();
-			// A model-fallback retry or resumed generation restarts the clock; a
+			// A selected-to-main handoff or resumed generation restarts the clock; a
 			// stale endedAt would freeze the elapsed display at the first attempt.
 			if (run.endedAt !== undefined) run.endedAt = undefined;
-			run.lastActivityAt = Date.now();
 		} else if ((status === "parked" || status === "done" || status === "failed") && run.endedAt === undefined) {
 			run.endedAt = Date.now();
 		}
@@ -414,11 +419,10 @@ export class MonitorStore {
 		if (!run) return;
 		run.usage = { ...usage };
 		if (model) run.model = model;
-		run.lastActivityAt = Date.now();
 		this.notify();
 	}
 
-	/** Record the final actual model and primary-to-backup transition. */
+	/** Record the final actual model and selected-to-main transition. */
 	setModel(id: number, model?: string, fallbackFrom?: string): void {
 		const run = this.find(id);
 		if (!run) return;
@@ -427,64 +431,40 @@ export class MonitorStore {
 		this.notify();
 	}
 
+	/** Record the capability-clamped thinking level for the active model. */
+	setThinking(id: number, thinking?: string): void {
+		const run = this.find(id);
+		if (!run || !thinking) return;
+		run.thinking = thinking;
+		this.notify();
+	}
+
 	/** Update the run's current one-line activity (what it is doing now). */
 	setActivity(id: number, text: string): void {
 		const run = this.find(id);
 		if (!run) return;
 		run.activity = sanitizeActivityText(text) || undefined;
-		run.lastActivityAt = Date.now();
 		this.notify();
 	}
 
-	/** Record a tool starting: counts it, marks it current, and updates activity.
-	 * A running tool means the run is NOT idle, so needs-attention is suppressed
-	 * while it stays current. */
+	/** Record a tool starting and update the run's visible activity. */
 	recordToolStart(id: number, toolName: string, activity: string): void {
 		const run = this.find(id);
 		if (!run) return;
 		const safeToolName = sanitizeActivityText(toolName) || "tool";
-		run.toolCount = (run.toolCount ?? 0) + 1;
-		run.currentTool = safeToolName;
 		run.activity = sanitizeActivityText(activity) || safeToolName;
-		run.lastActivityAt = Date.now();
 		this.notify();
 	}
 
-	/** Record a tool ending: clears the current-tool marker (so the run becomes
-	 * eligible for needs-attention again) and notes the failure in activity. */
+	/** Record a failed tool; successful completions keep their last activity
+	 * until the next model event supplies a more useful description. */
 	recordToolEnd(id: number, toolName: string, isError: boolean): void {
 		const run = this.find(id);
 		if (!run) return;
-		run.currentTool = undefined;
-		run.lastActivityAt = Date.now();
 		if (isError) run.activity = `✗ ${sanitizeActivityText(toolName) || "tool"} failed`;
 		this.notify();
 	}
 
-	/** Set an orchestration note on the run (e.g. auto-fix chain running). */
-	setAnnotation(id: number, text: string): void {
-		const run = this.find(id);
-		if (!run) return;
-		run.annotation = text;
-		this.notify();
-	}
-
-	/** Set the run's one-line outcome summary (what a finished chain round did). */
-	setSummary(id: number, text: string | undefined): void {
-		const run = this.find(id);
-		if (!run) return;
-		run.summary = text;
-		this.notify();
-	}
-
-	/** Keep a finished chain step in status state until its group settles. */
-	setRetained(id: number, retained: boolean): void {
-		const run = this.find(id);
-		if (!run) return;
-		run.retained = retained;
-		this.notify();
-	}
-
 	setIsolation(id: number, isolation: IsolationMode, integrationStatus?: "pending" | WorktreeFinalizationStatus): void {
 		const run = this.find(id);
 		if (!run) return;
@@ -526,7 +506,7 @@ export class MonitorStore {
 				thinking,
 				...(isolation ? { isolation, integrationStatus: isolation === "worktree" ? "pending" as const : undefined } : {}),
 				status: "queued",
-				usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, contextTokens: 0, turns: 0 },
+				usage: emptyUsage(),
 			});
 			this.notify();
 			return;
@@ -539,16 +519,10 @@ export class MonitorStore {
 		if (isolation) run.isolation = isolation;
 		run.integrationStatus = isolation === "worktree" ? "pending" : undefined;
 		run.status = "queued";
-		run.usage = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, contextTokens: 0, turns: 0 };
+		run.usage = emptyUsage();
 		run.activity = undefined;
-		run.toolCount = undefined;
-		run.currentTool = undefined;
-		run.lastActivityAt = undefined;
 		run.startedAt = undefined;
 		run.endedAt = undefined;
-		run.annotation = undefined;
-		run.summary = undefined;
-		run.retained = undefined;
 		this.notify();
 	}
 
@@ -589,7 +563,6 @@ export class MonitorStore {
 		const usage = formatUsageCompact(run.usage);
 		const parts = [run.agent];
 		if (run.relationLabel) parts.push(run.relationLabel);
-		if (run.summary) parts.push(run.summary);
 		if (run.model) parts.push(run.model);
 		if (run.thinking) parts.push(`thinking ${run.thinking}`);
 		if (run.isolation === "worktree") parts.push(`worktree ${run.integrationStatus ?? "active"}`);
@@ -658,20 +631,3 @@ export function statusLabel(status: RunStatus): string {
 			return "stopped";
 	}
 }
-
-/** Theme color matching the status label. */
-export function statusColor(status: RunStatus): "accent" | "success" | "error" | "warning" | "dim" {
-	switch (status) {
-		case "running":
-		case "steering":
-			return "accent";
-		case "interrupting":
-			return "warning";
-		case "done":
-			return "success";
-		case "failed":
-			return "error";
-		default:
-			return "dim";
-	}
-}

package/src/prompt.ts

@@ -16,8 +16,9 @@ import { formatCatalogEntry } from "./agents.ts";
 
 /** Compact role routing hints, emitted only for roles that are enabled. */
 const ROLE_ROUTING: Record<string, string> = {
-	explore: "explore — codebase reconnaissance: broad/open-ended search, multi-file lookups, mapping unfamiliar code, tracing symbols/dependencies (read-only, cheap fast model); NOT for one-line lookups.",
+	explore: "explore — codebase reconnaissance: broad/open-ended search, multi-file lookups, mapping unfamiliar code, tracing symbols/dependencies (read-only, competent fast model); NOT for one-line lookups.",
 	worker: "worker — implement/fix/refactor/test a self-contained task worth a separate context (full tools; plans internally).",
+	cleaner: "cleaner — evidence-first cleanup for explicit cleanup intent in any language (for example dead code, redundancy, simplification, or over-engineering) or a requested periodic cleanup pass; audit/find/inspect/report is read-only, while explicit remove/clean/simplify/refactor wording permits verified edits; never PR-count or pre-commit driven (reviewer remains the gate).",
 	reviewer: "reviewer — adversarial pre-commit review of a diff (read-only; independent context).",
 };
 
@@ -30,6 +31,8 @@ export function buildDelegationDirective(agents: AgentConfig[]): string {
 		.filter((line): line is string => Boolean(line))
 		.map((line) => `- ${line}`)
 		.join("\n");
+	const hasExplore = agents.some((a) => a.name === "explore");
+	const hasCleaner = agents.some((a) => a.name === "cleaner");
 	const hasReviewer = agents.some((a) => a.name === "reviewer");
 	const hasMultiple = agents.length > 1;
 
@@ -54,18 +57,18 @@ ${catalog}
 
 ${routing ? `Routing:\n${routing}\n` : ""}Dispatch discipline:
 - Handle SIMPLE work INLINE with direct tools: a one-line lookup, single edit, or quick question is a grep/read/edit in the main context — never a sub-agent. Sub-agents cost startup time, tokens, and a context switch.
-- Use \`explore\` PROACTIVELY for codebase reconnaissance: mapping an unfamiliar area, multi-file lookups, tracing symbols across modules, or any "where is X / which files reference Y" question that would take several greps or reading multiple files. It runs on a fast cheap model and returns compressed findings, so delegating recon costs little.
-- Delegate only when isolation genuinely pays: a self-contained implementation/fix with its own validation (worker), or a fresh-context review gate (reviewer).
-- When in doubt, start with a direct tool call in the main context; escalate to \`explore\` as soon as the search turns broad or crosses multiple files.
+- Use \`explore\` PROACTIVELY for codebase reconnaissance: mapping an unfamiliar area, multi-file lookups, tracing symbols across modules, or any "where is X / which files reference Y" question that would take several greps or reading multiple files. It should run on a competent fast code model and returns compressed findings, saving main-context space.
+- Delegate only when isolation genuinely pays: a self-contained implementation/fix with its own validation (worker)${hasCleaner ? ", explicit evidence-first cleanup (cleaner)" : ""}, or a fresh-context review gate (reviewer).
+${hasCleaner ? "- Route explicit cleanup intent in any language to `cleaner` (for example dead code, redundancy, simplification, or over-engineering), including a requested periodic maintenance pass. Audit/find/inspect/report wording means read-only evidence; apply only for explicit remove/clean/simplify/refactor wording. Generic code review without cleanup intent goes to `reviewer`. Never dispatch cleaner by PR count or automatically as the pre-commit gate; `reviewer` separately reviews cleaner edits.\n" : ""}- When in doubt, start with a direct tool call in the main context; escalate to \`explore\` as soon as the search turns broad or crosses multiple files.
 - For an already-known or trivial target, use a direct search/read tool (e.g. grep/find/read) — do not over-delegate a one-line lookup.
-${hasMultiple ? "- Run INDEPENDENT tasks in parallel: one subagent call with a `tasks` array, and track them with your todo list. Parallel worker items default to detached Git worktree isolation; pass `isolation: \"shared\"` only when a worker intentionally needs the caller's live uncommitted tree. Let the automatically resumed main agent launch dependent work only after its prerequisite result arrives (e.g. explore, then worker, then reviewer).\n" : ""}- Single dispatch stays in the shared working tree by default. Use \`isolation: "worktree"\` only for worker/write-capable agents in a Git repository; never request it for explore/reviewer, and never silently retry shared after setup fails.
+${hasMultiple ? `- Run INDEPENDENT tasks in parallel: one subagent call with a \`tasks\` array, and track them with your todo list. Parallel worker items default to detached Git worktree isolation; pass \`isolation: "shared"\` only when a worker intentionally needs the caller's live uncommitted tree.${hasCleaner ? " Cleaner is also write-capable and may use explicit worktree isolation." : ""} Let the automatically resumed main agent launch dependent work only after its prerequisite result arrives (e.g. explore, then ${hasCleaner ? "worker/cleaner" : "worker"}, then reviewer).\n` : ""}- Single dispatch stays in the shared working tree by default. Use \`isolation: "worktree"\` only for ${hasCleaner ? "worker, cleaner, or another" : "worker or another"} write-capable agent in a Git repository; never request it for explore/reviewer, and never silently retry shared after setup fails.
 - Brief each sub-agent as self-contained: goal, exact paths, constraints, expected output. It has NO memory of this conversation.
 - Treat delegated agents as leaf workers: do not ask a sub-agent to dispatch another sub-agent; child processes do not have this tool. Use \`subagent_control fork\` on a parked/settled retained thread when you need an independent continuation with preserved context and a new run id.
 - Trust but verify: a sub-agent's summary describes intent, not outcome. Check the actual changes/results before reporting work done.
-
+${hasExplore ? "- Treat `explore` findings as a retrieval index, never as sole proof for edits, deletion, security, compatibility, persistence, or dynamic reachability. Re-read load-bearing files before acting. An underpowered model can be false economy on complex dynamic, concurrent, migration, or security-sensitive code; use a stronger model or specialist there.\n" : ""}
 Vision tasks:
 - Judge whether a delegated task may require viewing images (frontend screenshots, mockups, design files, visual regression comparisons). If it might, pass \`vision: true\` in the subagent call and give the sub-agent the exact image paths — it reads them with its read tool.
-- \`vision: true\` runs the sub-agent on the vision-capable model configured in /subagents-setup; when none is configured it falls back to the main session's current model. Do not skip the flag because the agent's default model looks fast/cheap — a non-vision model cannot see the images.
+- \`vision: true\` runs the sub-agent on the vision-capable model configured in /subagents-setup; when none is configured it falls back to the main session's current model. Do not skip the flag because the agent's default model looks fast — a non-vision model cannot see the images.
 
 Result handoff (do not re-state):
 - A sub-agent's result arrives as a message that is already shown to the user. Do NOT restate, paraphrase, or re-summarize its findings in your reply — that just burns tokens duplicating what is already visible. The user can read the result above.
@@ -75,5 +78,7 @@ Result handoff (do not re-state):
 
 Review & verification:
 - Never report an unrun check as passed; report it as unavailable or as a pre-existing failure.
-${hasReviewer ? "- For non-trivial diffs, run one fresh read-only `reviewer` sub-agent before reporting done. Fix only concrete blockers and re-review at most once.\n- Use multi-model cross-review only when explicitly requested or for genuinely high-risk changes (security, unsafe/FFI, persistence-migration, concurrency). Reviewers are read-only; only the main agent edits.\n" : ""}- Commit or push only when explicitly requested, applicable checks pass, and no accepted blockers remain.`;
+${hasReviewer ? `- For non-trivial diffs${hasCleaner ? " (including cleaner edits)" : ""}, run one fresh read-only \`reviewer\` sub-agent before reporting done. Fix only concrete blockers and re-review at most once.
+- Use multi-model cross-review only when explicitly requested or for genuinely high-risk changes (security, unsafe/FFI, persistence-migration, concurrency). Reviewers are read-only; only the main agent edits.
+` : ""}- Commit or push only when explicitly requested, applicable checks pass, and no accepted blockers remain.`;
 }

package/src/rpc-run.ts

@@ -14,7 +14,7 @@ import { tmpdir } from "node:os";
 import { basename, join } from "node:path";
 import { StringDecoder } from "node:string_decoder";
 import type { Message } from "@earendil-works/pi-ai";
-import type { AgentConfig, AgentSource } from "./agents.ts";
+import type { AgentConfig } from "./agents.ts";
 import type { ThinkingLevel } from "./config.ts";
 import type { IsolationMode, WorktreeFinalizationStatus } from "./worktree.ts";
 
@@ -43,7 +43,6 @@ export interface UsageStats {
 
 export interface RpcSingleResult {
 	agent: string;
-	agentSource: AgentSource | "unknown";
 	task: string;
 	exitCode: number;
 	messages: Message[];
@@ -53,28 +52,29 @@ export interface RpcSingleResult {
 	thinking?: string;
 	stopReason?: string;
 	errorMessage?: string;
-	/** Primary model when this result came from a later candidate in its configured pool. */
+	/** Selected model when this result handed off to the current main model. */
 	modelFallbackFrom?: string;
 	dispatchFailed?: boolean;
 	/** An accepted generation failed because an RPC prompt was rejected before
-	 * model execution. This remains model-candidate retry/fallback eligible even
-	 * when an earlier, aborted objective left assistant text in the session. */
+	 * model execution. This remains main-model handoff eligible even when an
+	 * earlier, aborted objective left assistant text in the session. */
 	rpcPromptRejected?: boolean;
+	/** The child accepted a prompt; startup retries must never duplicate it. */
+	rpcPromptAccepted?: boolean;
+	/** Pi emitted agent/turn/model/tool activity for this attempt. */
+	rpcActivity?: boolean;
 	startupRetries?: number;
-	modelRetries?: number;
 	failedTools?: Array<{ toolName: string; error: string }>;
 	sessionId?: string;
 	sessionDir?: string;
-	resumed?: boolean;
+	/** Original task/project cwd used for result-artifact retention buckets. */
+	projectCwd?: string;
 	/** Internal disposition: dispatch suppresses completion delivery for parks. */
 	parked?: boolean;
 	/** Stable logical run id assigned by dispatch (also present on queued results). */
 	runId?: number;
 	/** Filesystem isolation selected for this logical thread. */
 	isolation?: IsolationMode;
-	/** Original parent cwd; isolated children execute at isolationCwd instead. */
-	originalCwd?: string;
-	isolationCwd?: string;
 	/** Final integration state for a worktree-isolated settlement. */
 	integrationStatus?: "pending" | WorktreeFinalizationStatus;
 	integrationApplied?: boolean;
@@ -89,7 +89,7 @@ export interface RpcSingleResult {
 
 export type SubagentLiveEvent =
 	| { kind: "status"; status: "queued" | "running" | "steering" | "interrupting" | "parked" | "done" | "failed" }
-	| { kind: "model"; model?: string; fallbackFrom?: string }
+	| { kind: "model"; model?: string; thinking?: ThinkingLevel; fallbackFrom?: string }
 	| { kind: "usage"; usage: UsageStats; model?: string }
 	| { kind: "tool_start"; toolCallId?: string; toolName: string; args: unknown }
 	| { kind: "tool_end"; toolCallId?: string; toolName: string; isError: boolean }
@@ -115,7 +115,7 @@ interface AttemptControl {
 }
 
 /**
- * Stable control surface for a logical run generation. Retry/fallback attempts
+ * Stable control surface for a logical run generation. Startup/main-handoff attempts
  * attach and detach beneath it, so callers never retain a stale child handle.
  * Control calls are serialized to prevent overlapping abort/settle/prompt flows.
  */
@@ -168,10 +168,6 @@ export class RpcRunControl {
 		this.setPhase("parked");
 	}
 
-	markQueued(): void {
-		this.setPhase("queued");
-	}
-
 	markStarting(): void {
 		this.setPhase("starting");
 	}
@@ -347,6 +343,46 @@ export function extractToolErrorText(content: unknown): string {
 		.join("\n");
 }
 
+interface ChildRetryPolicyExtension {
+	dir: string;
+	filePath: string;
+}
+
+/** Build a child-only Pi extension that replaces the selected provider's
+ * stream adapter with its registered API implementation while forcing
+ * maxRetries=0. It uses Pi's public extension and pi-ai compatibility APIs, so
+ * it works in Node and standalone/Bun builds without touching user settings. */
+export async function writeChildRetryPolicyExtension(
+	modelRef?: string,
+): Promise<ChildRetryPolicyExtension> {
+	const dir = await mkdtemp(join(tmpdir(), "pi-subagents-policy-"));
+	const filePath = join(dir, "no-provider-retries.mjs");
+	const slash = modelRef?.indexOf("/") ?? -1;
+	const selectedProvider = slash > 0 ? modelRef!.slice(0, slash) : undefined;
+	const source = `import { getApiProvider } from "@earendil-works/pi-ai/compat";\n`
+		+ `const selectedProvider = ${JSON.stringify(selectedProvider)};\n`
+		+ `export default function noProviderRetries(pi) {\n`
+		+ `  pi.on("before_provider_request", (_event, ctx) => {\n`
+		+ `    const providerId = ctx.model?.provider ?? selectedProvider;\n`
+		+ `    if (!providerId) return;\n`
+		+ `    pi.registerProvider(providerId, {\n`
+		+ `      streamSimple(model, context, options) {\n`
+		+ `        const api = getApiProvider(model.api);\n`
+		+ `        if (!api) throw new Error(\`No API stream implementation is registered for \${model.api}.\`);\n`
+		+ `        return api.streamSimple(model, context, { ...options, maxRetries: 0 });\n`
+		+ `      },\n`
+		+ `    });\n`
+		+ `  });\n`
+		+ `}\n`;
+	try {
+		await writeFile(filePath, source, "utf8");
+		return { dir, filePath };
+	} catch (error) {
+		await rm(dir, { recursive: true, force: true }).catch(() => undefined);
+		throw error;
+	}
+}
+
 async function writePromptToTempFile(agentName: string, prompt: string): Promise<{ dir: string; filePath: string }> {
 	const dir = await mkdtemp(join(tmpdir(), "pi-subagents-"));
 	const safeName = agentName.replace(/[^\w.-]+/g, "_");
@@ -431,12 +467,17 @@ export async function runRpcAgentAttempt(options: RunRpcAttemptOptions): Promise
 		args.push("--append-system-prompt", tmpPromptPath);
 	}
 
-	const resumed = Boolean(
-		options.sessionDir && options.sessionId && sessionExists(options.sessionDir, options.sessionId),
-	);
+	let retryPolicy: ChildRetryPolicyExtension;
+	try {
+		retryPolicy = await writeChildRetryPolicyExtension(agent.model);
+		args.push("--extension", retryPolicy.filePath);
+	} catch (error) {
+		if (tmpPromptDir) await rm(tmpPromptDir, { recursive: true, force: true }).catch(() => undefined);
+		throw error;
+	}
+
 	const result: RpcSingleResult = {
 		agent: agentName,
-		agentSource: agent.source,
 		task,
 		exitCode: 0,
 		messages: [],
@@ -446,7 +487,6 @@ export async function runRpcAgentAttempt(options: RunRpcAttemptOptions): Promise
 		thinking: thinkingLevel,
 		sessionId: options.sessionId,
 		sessionDir: options.sessionDir,
-		resumed,
 	};
 
 	const childDepth = currentSubagentDepth(options.env) + 1;
@@ -526,6 +566,7 @@ export async function runRpcAgentAttempt(options: RunRpcAttemptOptions): Promise
 	const resolveInitialPrompt = (accepted: boolean, error?: Error): void => {
 		if (initialPromptResolved) return;
 		initialPromptResolved = true;
+		if (accepted) result.rpcPromptAccepted = true;
 		initialPrompt.resolve({ accepted, error });
 	};
 
@@ -752,6 +793,33 @@ export async function runRpcAgentAttempt(options: RunRpcAttemptOptions): Promise
 		}
 		if (finished) return;
 
+		if (
+			[
+				"agent_start",
+				"agent_end",
+				"turn_start",
+				"turn_end",
+				"message_start",
+				"message_update",
+				"message_end",
+				"tool_execution_start",
+				"tool_execution_update",
+				"tool_execution_end",
+				"auto_retry_start",
+				"auto_retry_end",
+				"agent_settled",
+			].includes(event.type)
+		) {
+			result.rpcActivity = true;
+		}
+
+		// The child provider adapter disables request-level retries. Cancel Pi's
+		// separate outer turn retry the instant it is scheduled, before another
+		// same-model provider call can begin.
+		if (event.type === "auto_retry_start") {
+			void send({ type: "abort_retry" }).catch(() => undefined);
+		}
+
 		// Child RPC mode exposes extension dialogs. Sub-agents are non-interactive:
 		// cancel blocking dialogs so an unrelated child extension cannot deadlock.
 		if (
@@ -987,5 +1055,6 @@ export async function runRpcAgentAttempt(options: RunRpcAttemptOptions): Promise
 				/* ignore */
 			}
 		}
+		await rm(retryPolicy.dir, { recursive: true, force: true }).catch(() => undefined);
 	}
 }

package/src/runtime.ts

@@ -27,7 +27,6 @@ import {
 	type RecoveryRecord,
 } from "./recovery.ts";
 import type { RpcRunControl } from "./rpc-run.ts";
-import { trajectoryStore } from "./trajectory.ts";
 import type { SingleResult } from "./spawn.ts";
 import type { IsolationMode, WorktreeFinalization, WorktreeIsolation } from "./worktree.ts";
 
@@ -54,8 +53,6 @@ export interface SubagentThread {
 	/** Actual child cwd (the equivalent path inside an isolated worktree). */
 	executionCwd: string;
 	vision: boolean;
-	/** Exact primary→fallback refs inherited by a session fork. */
-	modelPool: string[];
 	thinkingLevel?: ThinkingLevel;
 	isolation: IsolationMode;
 	worktree?: WorktreeIsolation;
@@ -118,9 +115,6 @@ export interface SubagentRuntime {
 	sessionDirs: Set<string>;
 	retainSession: (result: Pick<SingleResult, "sessionDir">) => void;
 	retireThreadSession: (thread: SubagentThread) => void;
-	/** Worktree/patch paths intentionally retained after a failed integration. */
-	retainedArtifactPaths: Set<string>;
-	retainWorktreeArtifacts: (finalization: WorktreeFinalization) => void;
 	/** Flip sessionActive off and release all session-scoped resources. */
 	shutdown: () => Promise<void>;
 }
@@ -141,9 +135,11 @@ export function createRuntime(pi: ExtensionAPI, configPath: string): SubagentRun
 			// Computing this at delivery (emit) time — not when the item was
 			// pushed — reflects the current monitor state, since finishing runs
 			// are removed from the monitor before their completion is pushed.
+			// Auto-fix parents are flipped back to "running" while their chain
+			// owns the logical run, so they are included without a special case.
 			const active = monitor
 				.getRuns()
-				.filter((run) => isRunActiveStatus(run.status) || run.retained)
+				.filter((run) => isRunActiveStatus(run.status))
 				.map((run) => ({ id: run.id, agent: run.agent, label: run.label }));
 			const message = {
 				customType: "subagent-result",
@@ -171,11 +167,6 @@ export function createRuntime(pi: ExtensionAPI, configPath: string): SubagentRun
 		threads: new Map<number, SubagentThread>(),
 		preflightOperations: new Set<Promise<void>>(),
 		sessionDirs: new Set<string>(),
-		retainedArtifactPaths: new Set<string>(),
-		retainWorktreeArtifacts: (finalization) => {
-			if (finalization.worktreePath) runtime.retainedArtifactPaths.add(finalization.worktreePath);
-			if (finalization.patchPath) runtime.retainedArtifactPaths.add(finalization.patchPath);
-		},
 		retainSession: (result) => {
 			if (result.sessionDir) runtime.sessionDirs.add(result.sessionDir);
 		},
@@ -241,7 +232,6 @@ export function createRuntime(pi: ExtensionAPI, configPath: string): SubagentRun
 			for (const thread of runtime.threads.values()) {
 				const finalization = await thread.finalizeIsolation(thread.generation).catch(() => undefined);
 				if (finalization?.status === "retained") {
-					runtime.retainWorktreeArtifacts(finalization);
 					recoveryRecords.push(recoveryRecordFromFinalization(thread.id, finalization));
 					if (!thread.isolationFailureNotified) {
 						thread.isolationFailureNotified = true;
@@ -268,12 +258,8 @@ export function createRuntime(pi: ExtensionAPI, configPath: string): SubagentRun
 			}
 			runtime.sessionDirs.clear();
 			runtime.preflightOperations.clear();
-			// Deliberately do not remove retainedArtifactPaths: they are the recovery
-			// path after a failed patch apply/cleanup.
 			runtime.threads.clear();
 			monitor.clear();
-			// Lifecycle trajectories are parent-session scoped.
-			trajectoryStore.clearAll();
 		},
 	};
 

package/src/session-fork.ts

@@ -7,7 +7,6 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 
 export interface ForkedSession {
-	sourceSessionFile: string;
 	sessionDir: string;
 	sessionId: string;
 	sessionFile: string;
@@ -15,7 +14,6 @@ export interface ForkedSession {
 
 /** Locate one retained session by its authoritative header id. */
 export async function findRetainedSessionFile(
-	cwd: string,
 	sessionDir: string,
 	sessionId: string,
 ): Promise<string> {
@@ -47,7 +45,6 @@ export async function forkRetainedSession(options: {
 	sessionId: string;
 }): Promise<ForkedSession> {
 	const sourceSessionFile = await findRetainedSessionFile(
-		options.cwd,
 		options.sessionDir,
 		options.sessionId,
 	);
@@ -72,7 +69,6 @@ export async function forkRetainedSession(options: {
 			throw new Error(`Forked session branch has no persisted assistant checkpoint at ${sessionFile}.`);
 		}
 		return {
-			sourceSessionFile,
 			sessionDir,
 			sessionId: manager.getSessionId(),
 			sessionFile,