@ferris1225/pi-subagents 4.1.7 → 4.1.9

package/src/durable.ts

@@ -0,0 +1,336 @@
+/**
+ * Durable thread state: a manifest next to the config that lets parked and
+ * settled sub-agent threads survive pi reloads and restarts, plus the durable
+ * state root that keeps their retained sessions and isolated worktrees out of
+ * the OS temp directory.
+ *
+ * Records are small path/state snapshots, never full transcripts; the retained
+ * Pi session files and worktrees they point at remain the actual context.
+ * Writes are atomic (tmp+rename) and serialized through the same
+ * withFileMutationQueue as the recovery manifest.
+ */
+
+import { withFileMutationQueue } from "@earendil-works/pi-coding-agent";
+import { existsSync } from "node:fs";
+import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import type { UsageStats } from "./rpc-run.ts";
+import type { SubagentThread } from "./runtime.ts";
+import { getResultOutput, isFailedResult, type SingleResult } from "./spawn.ts";
+import {
+	restoreWorktreeIsolation,
+	type IsolationMode,
+	normalizeWorktreeSnapshot,
+	worktreeSnapshot,
+	type WorktreeSnapshot,
+} from "./worktree.ts";
+
+export const THREADS_MANIFEST_FILE_NAME = "pi-subagents-threads.json";
+const THREADS_MANIFEST_VERSION = 1;
+export const STATE_DIR_NAME = "pi-subagents-state";
+
+/** Fixed retention: settled results stop being resumable after a week,
+ * parked work (which may hold unintegrated changes) after a month. */
+export const SETTLED_RECORD_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1_000;
+export const PARKED_RECORD_MAX_AGE_MS = 30 * 24 * 60 * 60 * 1_000;
+
+/** Result excerpts are for status display after restore, not full transcripts. */
+const RESULT_SUMMARY_MAX_CHARS = 4_000;
+
+export interface ThreadResultSummary {
+	agent: string;
+	task: string;
+	exitCode: number;
+	failed: boolean;
+	stopReason?: string;
+	usage: UsageStats;
+	model?: string;
+	thinking?: string;
+	output: string;
+}
+
+export interface ThreadRecord {
+	runId: number;
+	createdAt: number;
+	updatedAt: number;
+	generation: number;
+	agentName: string;
+	task: string;
+	cwd: string;
+	executionCwd: string;
+	thinkingLevel?: string;
+	isolation: IsolationMode;
+	state: "parked" | "completed" | "failed";
+	elapsedMs: number;
+	sessionId?: string;
+	sessionDir?: string;
+	worktree?: WorktreeSnapshot;
+	childPids: number[];
+	resultSummary?: ThreadResultSummary;
+}
+
+interface ThreadsManifest {
+	version: number;
+	records: ThreadRecord[];
+}
+
+export function getStateRoot(configPath: string): string {
+	return join(dirname(configPath), STATE_DIR_NAME);
+}
+
+export function getThreadsManifestPath(configPath: string): string {
+	return join(dirname(configPath), THREADS_MANIFEST_FILE_NAME);
+}
+
+function normalizeUsage(value: unknown): UsageStats {
+	const raw = (value && typeof value === "object" ? value : {}) as Record<string, unknown>;
+	const num = (key: string): number => (typeof raw[key] === "number" && Number.isFinite(raw[key]) ? raw[key] : 0);
+	return {
+		input: num("input"),
+		output: num("output"),
+		cacheRead: num("cacheRead"),
+		cacheWrite: num("cacheWrite"),
+		cost: num("cost"),
+		contextTokens: num("contextTokens"),
+		turns: num("turns"),
+	};
+}
+
+function normalizeResultSummary(value: unknown): ThreadResultSummary | undefined {
+	if (!value || typeof value !== "object") return undefined;
+	const raw = value as Record<string, unknown>;
+	if (typeof raw.agent !== "string" || !raw.agent) return undefined;
+	if (typeof raw.output !== "string") return undefined;
+	return {
+		agent: raw.agent,
+		task: typeof raw.task === "string" ? raw.task : raw.agent,
+		exitCode: typeof raw.exitCode === "number" ? raw.exitCode : 0,
+		failed: raw.failed === true,
+		...(typeof raw.stopReason === "string" && raw.stopReason ? { stopReason: raw.stopReason } : {}),
+		usage: normalizeUsage(raw.usage),
+		...(typeof raw.model === "string" && raw.model ? { model: raw.model } : {}),
+		...(typeof raw.thinking === "string" && raw.thinking ? { thinking: raw.thinking } : {}),
+		output: raw.output,
+	};
+}
+
+function normalizeRecord(value: unknown): ThreadRecord | undefined {
+	if (!value || typeof value !== "object") return undefined;
+	const raw = value as Record<string, unknown>;
+	if (typeof raw.runId !== "number" || !Number.isInteger(raw.runId) || raw.runId < 1) return undefined;
+	if (typeof raw.createdAt !== "number" || !Number.isFinite(raw.createdAt)) return undefined;
+	if (typeof raw.updatedAt !== "number" || !Number.isFinite(raw.updatedAt)) return undefined;
+	if (typeof raw.agentName !== "string" || !raw.agentName) return undefined;
+	if (typeof raw.task !== "string" || !raw.task) return undefined;
+	if (typeof raw.cwd !== "string" || !raw.cwd) return undefined;
+	if (raw.isolation !== "shared" && raw.isolation !== "worktree") return undefined;
+	if (raw.state !== "parked" && raw.state !== "completed" && raw.state !== "failed") return undefined;
+	const worktree = raw.worktree === undefined ? undefined : normalizeWorktreeSnapshot(raw.worktree);
+	if (worktree === null) return undefined;
+	return {
+		runId: raw.runId,
+		createdAt: raw.createdAt,
+		updatedAt: raw.updatedAt,
+		generation: typeof raw.generation === "number" && Number.isInteger(raw.generation) && raw.generation >= 0 ? raw.generation : 0,
+		agentName: raw.agentName,
+		task: raw.task,
+		cwd: raw.cwd,
+		executionCwd: typeof raw.executionCwd === "string" && raw.executionCwd ? raw.executionCwd : raw.cwd,
+		...(typeof raw.thinkingLevel === "string" && raw.thinkingLevel ? { thinkingLevel: raw.thinkingLevel } : {}),
+		isolation: raw.isolation,
+		state: raw.state,
+		elapsedMs: typeof raw.elapsedMs === "number" && Number.isFinite(raw.elapsedMs) ? Math.max(0, raw.elapsedMs) : 0,
+		...(typeof raw.sessionId === "string" && raw.sessionId ? { sessionId: raw.sessionId } : {}),
+		...(typeof raw.sessionDir === "string" && raw.sessionDir ? { sessionDir: raw.sessionDir } : {}),
+		...(worktree ? { worktree } : {}),
+		childPids: Array.isArray(raw.childPids)
+			? raw.childPids.filter((pid): pid is number => typeof pid === "number" && Number.isInteger(pid) && pid > 0)
+			: [],
+		...(raw.resultSummary === undefined ? {} : { resultSummary: normalizeResultSummary(raw.resultSummary) }),
+	};
+}
+
+export async function readThreadRecords(configPath: string): Promise<ThreadRecord[]> {
+	try {
+		const parsed = JSON.parse(await readFile(getThreadsManifestPath(configPath), "utf8")) as {
+			records?: unknown;
+		};
+		if (!Array.isArray(parsed.records)) return [];
+		return parsed.records.flatMap((record) => {
+			const normalized = normalizeRecord(record);
+			return normalized ? [normalized] : [];
+		});
+	} catch {
+		return [];
+	}
+}
+
+async function writeManifest(configPath: string, records: readonly ThreadRecord[]): Promise<void> {
+	const path = getThreadsManifestPath(configPath);
+	if (records.length === 0) {
+		await rm(path, { force: true });
+		return;
+	}
+	await mkdir(dirname(path), { recursive: true });
+	const temporaryPath = `${path}.${process.pid}.${Date.now()}.tmp`;
+	try {
+		const manifest: ThreadsManifest = {
+			version: THREADS_MANIFEST_VERSION,
+			records: [...records],
+		};
+		await writeFile(temporaryPath, `${JSON.stringify(manifest, null, 2)}\n`, "utf8");
+		await rename(temporaryPath, path);
+	} finally {
+		await rm(temporaryPath, { force: true }).catch(() => undefined);
+	}
+}
+
+export async function upsertThreadRecord(configPath: string, record: ThreadRecord): Promise<void> {
+	const path = getThreadsManifestPath(configPath);
+	await withFileMutationQueue(path, async () => {
+		const records = await readThreadRecords(configPath);
+		const index = records.findIndex((candidate) => candidate.runId === record.runId);
+		const merged: ThreadRecord = index === -1
+			? record
+			: { ...record, createdAt: records[index]!.createdAt };
+		if (index === -1) records.push(merged);
+		else records[index] = merged;
+		await writeManifest(configPath, records);
+	});
+}
+
+export async function removeThreadRecord(configPath: string, runId: number): Promise<void> {
+	const path = getThreadsManifestPath(configPath);
+	await withFileMutationQueue(path, async () => {
+		const records = await readThreadRecords(configPath);
+		const next = records.filter((record) => record.runId !== runId);
+		if (next.length === records.length) return;
+		await writeManifest(configPath, next);
+	});
+}
+
+function truncateSummary(text: string): string {
+	if (text.length <= RESULT_SUMMARY_MAX_CHARS) return text;
+	return `${text.slice(0, RESULT_SUMMARY_MAX_CHARS - 1)}…`;
+}
+
+function summarizeResult(result: SingleResult): ThreadResultSummary | undefined {
+	if (!result) return undefined;
+	return {
+		agent: result.agent,
+		task: result.task,
+		exitCode: result.exitCode,
+		failed: isFailedResult(result),
+		...(result.stopReason ? { stopReason: result.stopReason } : {}),
+		usage: result.usage,
+		...(result.model ? { model: result.model } : {}),
+		...(result.thinking ? { thinking: result.thinking } : {}),
+		output: truncateSummary(getResultOutput(result)),
+	};
+}
+
+/** Project a live thread into its durable record. Only handles whose
+ * filesystem is still meaningful are persisted; finalized-and-removed
+ * worktrees keep just their checkpoint commit for continuation resumes. */
+export function threadRecordFromThread(
+	thread: SubagentThread,
+	state: "parked" | "completed" | "failed",
+	previous?: ThreadRecord,
+	now = Date.now(),
+): ThreadRecord {
+	const worktree = thread.worktree ? worktreeSnapshot(thread.worktree) : undefined;
+	return {
+		runId: thread.id,
+		createdAt: previous?.createdAt ?? now,
+		updatedAt: now,
+		generation: thread.generation,
+		agentName: thread.agentName,
+		task: thread.task,
+		cwd: thread.cwd,
+		executionCwd: thread.executionCwd,
+		...(thread.thinkingLevel ? { thinkingLevel: thread.thinkingLevel } : {}),
+		isolation: thread.isolation,
+		state,
+		elapsedMs: thread.elapsedMs,
+		...(thread.sessionId && thread.sessionDir ? { sessionId: thread.sessionId, sessionDir: thread.sessionDir } : {}),
+		...(worktree ? { worktree } : {}),
+		childPids: thread.control?.getChildPids?.() ?? [],
+		...(thread.lastResult ? { resultSummary: summarizeResult(thread.lastResult) } : {}),
+	};
+}
+
+/** Rebuild a displayable in-turn result from a persisted summary. The retained
+ * session holds the real context; this only lets subagent_wait/status show
+ * what the previous session's generation concluded. */
+export function restoredResultFromSummary(record: ThreadRecord): SingleResult | undefined {
+	const summary = record.resultSummary;
+	if (!summary) return undefined;
+	return {
+		agent: summary.agent,
+		task: summary.task,
+		exitCode: summary.exitCode,
+		messages: summary.output
+			? [{
+				role: "assistant",
+				content: [{ type: "text", text: summary.output }],
+				stopReason: "stop",
+			} as SingleResult["messages"][number]]
+			: [],
+		stderr: "",
+		usage: summary.usage,
+		isolation: record.isolation,
+		...(summary.model ? { model: summary.model } : {}),
+		...(summary.thinking ? { thinking: summary.thinking } : {}),
+		...(summary.stopReason ? { stopReason: summary.stopReason } : {}),
+		...(record.sessionId && record.sessionDir ? { sessionId: record.sessionId, sessionDir: record.sessionDir } : {}),
+	};
+}
+
+async function discardRecordArtifacts(record: ThreadRecord): Promise<void> {
+	if (record.sessionDir) {
+		await rm(record.sessionDir, { recursive: true, force: true }).catch(() => undefined);
+	}
+	if (record.worktree && (record.worktree.state === "active" || record.worktree.state === "retained")) {
+		const worktree = await restoreWorktreeIsolation(record.worktree).catch(() => undefined);
+		await worktree?.discard().catch(() => undefined);
+	}
+}
+
+/** Drop records past their retention age along with their artifacts. Runs at
+ * extension load; the fixed ages honor the no-config-knobs policy. */
+export async function pruneThreadRecords(
+	configPath: string,
+	now = Date.now(),
+): Promise<void> {
+	const path = getThreadsManifestPath(configPath);
+	await withFileMutationQueue(path, async () => {
+		const records = await readThreadRecords(configPath);
+		if (records.length === 0) return;
+		let changed = false;
+		const kept: ThreadRecord[] = [];
+		for (const record of records) {
+			const maxAge = record.state === "parked" ? PARKED_RECORD_MAX_AGE_MS : SETTLED_RECORD_MAX_AGE_MS;
+			if (now - record.updatedAt <= maxAge) {
+				kept.push(record);
+				continue;
+			}
+			changed = true;
+			await discardRecordArtifacts(record);
+		}
+		if (changed) await writeManifest(configPath, kept);
+	});
+}
+
+/** Paths a manifest still references; used by the state-root sweep so
+ * freshly created-but-unrecorded directories are never touched. */
+export function referencedDurablePaths(records: readonly ThreadRecord[]): Set<string> {
+	const paths = new Set<string>();
+	for (const record of records) {
+		if (record.sessionDir) paths.add(record.sessionDir);
+		if (record.worktree) {
+			paths.add(record.worktree.tempDir);
+			if (existsSync(record.worktree.worktreePath)) paths.add(record.worktree.worktreePath);
+		}
+	}
+	return paths;
+}

package/src/fixloop.ts

@@ -18,7 +18,13 @@
 import { isWriteCapableAgent, type AgentConfig } from "./agents.ts";
 import { getResultOutput, isFailedResult, reviewVerdict, type SingleResult } from "./spawn.ts";
 import { formatUsageCompact, sumUsage } from "./monitor.ts";
-import type { SubagentsConfig } from "./config.ts";
+
+/**
+ * Worker fixes allowed after REVIEW_FAIL: one fix, one re-review. Anything
+ * still unresolved is handed back to the main window instead of burning more
+ * rounds, keeping chain latency and cost bounded.
+ */
+export const MAX_FIX_ROUNDS = 1;
 
 /**
  * Whether a completed result should trigger the auto-fix loop instead of being
@@ -27,8 +33,7 @@ import type { SubagentsConfig } from "./config.ts";
  * normally. Loop-internal re-review results never reach this path (they are
  * awaited inside the loop, not delivered through the completion flow).
  */
-export function shouldTriggerFixLoop(result: SingleResult, config: SubagentsConfig): boolean {
-	if (config.maxFixRounds <= 0) return false;
+export function shouldTriggerFixLoop(result: SingleResult): boolean {
 	if (result.agent !== "reviewer") return false;
 	if (isFailedResult(result)) return false;
 	// A dispatch crash (spawn infra, delivery API, ...) is never a real review
@@ -97,8 +102,8 @@ export function canStartManagedWorkflow(
 	if (isWriteCapableAgent(agent)) return true;
 	if (agent.name === "reviewer") {
 		// Hold a stable diff snapshot against every discoverable writer even when
-		// this review is advisory or maxFixRounds=0. Classification happens only
-		// after the read-only child returns, too late to acquire the lane safely.
+		// this review is advisory. Classification happens only after the read-only
+		// child returns, too late to acquire the lane safely.
 		return availability.writer;
 	}
 	return false;
@@ -108,10 +113,10 @@ export function canStartManagedWorkflow(
  * machine verdict is advisory and cannot start any write-capable child. */
 export function getManagedWorkflowPlan(
 	result: SingleResult,
-	config: SubagentsConfig,
 	availability: WorkflowAgentAvailability,
+	advisoryReview = false,
 ): ManagedWorkflowPlan | undefined {
-	if (result.parked || result.dispatchFailed || isFailedResult(result)) return undefined;
+	if (result.dispatchFailed || isFailedResult(result)) return undefined;
 	if (result.agent === "worker" || result.agent === "cleaner") {
 		if (!availability.documenter && !availability.reviewer) return undefined;
 		return {
@@ -123,6 +128,9 @@ export function getManagedWorkflowPlan(
 	// owns the writer lane but delivers directly without an automatic code gate.
 	if (result.agent === "documenter") return undefined;
 	if (result.agent !== "reviewer") return undefined;
+	// An advisory dispatch never chains: the caller asked for a report, so even
+	// a stray gate verdict must be delivered rather than acted on.
+	if (advisoryReview) return undefined;
 
 	const output = getResultOutput(result);
 	const verdict = reviewVerdict(output);
@@ -135,7 +143,7 @@ export function getManagedWorkflowPlan(
 	) {
 		return { kind: "review-pass-sync", initialRelation: "pre-documentation review" };
 	}
-	if (verdict === "fail" && availability.worker && shouldTriggerFixLoop(result, config)) {
+	if (verdict === "fail" && availability.worker && shouldTriggerFixLoop(result)) {
 		return { kind: "auto-fix", initialRelation: "initial review" };
 	}
 	return undefined;
@@ -145,11 +153,12 @@ export function getManagedWorkflowPlan(
  * Build the worker task brief for one fix round from a reviewer's findings.
  * The worker gets the full review text — findings plus their fix instructions
  * — and closes every finding either by implementing the instruction or by
- * shipping a sounder fix with an explicit per-finding pushback.
+ * shipping a sounder fix with an explicit per-finding pushback. The standing
+ * pushback and release-boundary contract lives in the worker system prompt;
+ * the brief carries only what is specific to this round.
  */
 export function buildFixTaskBrief(reviewerResult: SingleResult, round: number, maxRounds: number): string {
 	const review = getResultOutput(reviewerResult);
-	const remaining = maxRounds - round;
 	return [
 		`Auto-fix round ${round} of ${maxRounds} (triggered by a failed review).`,
 		``,
@@ -158,18 +167,12 @@ export function buildFixTaskBrief(reviewerResult: SingleResult, round: number, m
 		review,
 		`---`,
 		``,
-		`Each finding in the reviewer's report carries a fix instruction. Close EVERY finding — there is no severity triage; all of them get fixed.`,
-		`You own the fix: when an instruction is factually wrong, clearly out of scope, or a sounder fix exists, implement YOUR fix instead,`,
-		`then push back explicitly per finding — cite it, refute the instruction's reasoning, and state what you shipped instead.`,
-		`A pushback without a working alternative or concrete reasoning will be re-opened.`,
-		`Do NOT refactor unrelated code beyond what the findings require.`,
-		`Synchronize any existing README/docs/examples/comments directly affected by your fixes; do not broaden into standalone documentation maintenance.`,
-		`Do NOT commit, push, publish, tag, or release; do not bump versions. The parent chain still owns re-review and any conditional final documentation sync.`,
-		`After editing, run the project's format/build/tests when they exist and report`,
-		`exactly what you changed (paths + short rationale) plus any pushback, so a reviewer can verify.`,
-		remaining > 0
-			? `A reviewer will re-review your changes automatically after you finish.`
-			: `This is the last auto-fix round; the workflow conditionally runs any needed final documentation sync and then delivers.`,
+		`Close EVERY finding — there is no severity triage; all of them get fixed. Each finding carries a fix instruction:`,
+		`follow it, or ship a sounder fix and push back per finding with your reasoning.`,
+		`Do NOT refactor unrelated code. Synchronize any existing README/docs/examples/comments directly affected by your fixes.`,
+		`Run the project's format/build/tests when they exist, then report exactly what you changed (paths + short rationale)`,
+		`plus any pushback, so a reviewer can verify.`,
+		`A reviewer re-reviews your changes automatically after you finish; anything still unresolved after that re-review goes back to the main window.`,
 	].join("\n");
 }
 
@@ -206,11 +209,11 @@ export function buildFinalDocumenterBrief(
 		`Final documentation sync: the review gate settled and you are the last managed stage before delivery.`,
 		``,
 		...reportSections,
-		`Inspect the actual git diff (the complete pending diff) and relevant implementation; the reports are only leads.`,
-		`Apply every documentation note the reviews recorded, then synchronize stale README/docs, examples, API comments, docstrings, and explanatory comments with the behavior that will be committed.`,
-		`Change documentation surfaces only; never alter runtime behavior or tests to make prose true.`,
-		`Make zero edits when the diff creates no documentation drift.`,
-		`Do NOT commit, push, publish, tag, or release; do not bump versions. The parent workflow delivers directly after you; no fresh reviewer runs.`,
+		`Inspect the actual git diff and relevant implementation; the reports are only leads.`,
+		`Apply every documentation note the reviews recorded, then synchronize stale README/docs, examples, API comments, docstrings,`,
+		`and explanatory comments with the behavior that will be committed.`,
+		`Change documentation surfaces only; make zero edits when the diff creates no documentation drift.`,
+		`The workflow delivers directly after you; no fresh reviewer runs.`,
 		`Report exact documentation/comment paths changed, or state explicitly that no sync was needed.`,
 	].join("\n");
 }
@@ -310,15 +313,13 @@ export function buildFinalReviewBrief(
 		`---`,
 		``,
 		`Run \`git status\` and \`git diff\` and inspect the actual pending code; the report is context, not proof.`,
-		`Remain read-only. Verify correctness, regressions, and tests.`,
-		`Attach a concrete fix instruction to EVERY gate finding: what to change, where, and how to verify the fix.`,
-		`A worker will implement your instructions unless it can justify a sounder fix and push back, so make each instruction specific enough to act on.`,
+		`Remain read-only. Attach a concrete fix instruction to EVERY gate finding: what to change, where, and how to verify the fix`,
+		`— a worker will implement your instructions unless it can justify a sounder fix and push back.`,
 		...(options.documenterPending
 			? [
-				`A conditional documentation sync is available AFTER this gate, so documentation drift is not a code-gate finding.`,
-				`If documentation is stale, add a separate short "## Documentation notes" list and emit the standalone line`,
-				`DOCUMENTATION: NEEDED. If no documentation update is needed, emit DOCUMENTATION: CLEAN instead.`,
-				`Always emit exactly one of those standalone documentation lines; fail the gate only for code or test findings.`,
+				`A conditional documentation sync is available AFTER this gate, so documentation drift is not a code-gate finding:`,
+				`record it under "## Documentation notes" and emit the standalone line DOCUMENTATION: NEEDED,`,
+				`or DOCUMENTATION: CLEAN when no documentation update is needed.`,
 			]
 			: [
 				`No documenter is pending, so documentation drift is an ordinary gate finding.`,
@@ -352,15 +353,14 @@ export function buildReReviewBrief(
 		review,
 		`---`,
 		``,
-		`The worker's report (what it changed, plus any pushback where it replaced your fix instruction with its own fix):`,
+		`The worker's report (what it changed, plus any pushback where it replaced your fix instruction):`,
 		`---`,
 		workerReport,
 		`---`,
 		``,
 		`Rule on EVERY previous finding: resolved, or still open. Judge the code as it now stands — a finding is`,
 		`resolved when the pending diff fixes it soundly, whether or not the worker followed your fix instruction.`,
-		`A finding the worker pushed back on must be adjudicated ONCE — accept the worker's fix unless you can`,
-		`concretely refute its reasoning; never simply restate the finding for another round.`,
+		`Adjudicate each pushback once: accept the worker's fix unless you can concretely refute its reasoning.`,
 		`Run \`git diff\` to see what changed, then add NEW findings only for defects this round's edits introduced or exposed.`,
 		`Re-review never opens findings unrelated to this round's edits; issues the earlier review missed belong to a fresh gate.`,
 		`Do NOT re-open a finding you verified as resolved.`,

package/src/format.ts

@@ -100,11 +100,6 @@ export function formatCompletionBlock(
 	const startupRetryNote = result.startupRetries
 		? ` (recovered after ${result.startupRetries} startup retr${result.startupRetries === 1 ? "y" : "ies"} — concurrent pi startup race)`
 		: "";
-	const relations = [
-		result.forkedFromRunId !== undefined ? `forked from #${result.forkedFromRunId}` : undefined,
-		(result.forkChildRunIds?.length ?? 0) > 0 ? `fork children ${result.forkChildRunIds!.map((id) => `#${id}`).join(", ")}` : undefined,
-	].filter((value): value is string => Boolean(value));
-	const relationNote = relations.length > 0 ? ` · ${relations.join(" · ")}` : "";
 	const runNote = result.runId !== undefined ? ` · run #${result.runId}` : "";
 	const lines = [`### [${result.agent}] ${status}${usage ? ` (${usage})` : ""}${fallbackNote}${startupRetryNote}${runNote}`, "", `Task: ${formatTaskSummary(result.task, 80, false)}`, ""];
 	if (result.isolation === "worktree") {
@@ -118,13 +113,11 @@ export function formatCompletionBlock(
 							? "worktree · changes applied, but cleanup failed; recovery artifacts retained"
 							: "worktree · integration failed; recovery artifacts retained"
 						: "worktree · isolated";
-		lines.push(`Isolation: ${isolation}${relationNote}`);
+		lines.push(`Isolation: ${isolation}`);
 		if (result.integrationWorktreePath) lines.push(`Retained worktree: ${result.integrationWorktreePath}`);
 		if (result.integrationPatchPath) lines.push(`Retained patch: ${result.integrationPatchPath}`);
 		if (result.integrationError) lines.push(`Integration error: ${result.integrationError}`);
 		lines.push("");
-	} else if (relations.length > 0) {
-		lines.push(`Relation: ${relations.join(" · ")}`, "");
 	}
 	lines.push(text);
 	// Failed-tool diagnostics are deliberate opt-in via subagent_status: agents

package/src/index.ts

@@ -29,6 +29,7 @@ import { buildDelegationDirective } from "./prompt.ts";
 import { createRuntime } from "./runtime.ts";
 import { runSetup } from "./setup.ts";
 import { currentSubagentDepth } from "./spawn.ts";
+import { bootstrapDurableState } from "./thread-lifecycle.ts";
 import { registerLookupTools } from "./tools.ts";
 import { clearActiveRunsWidget } from "./widget.ts";
 
@@ -77,6 +78,12 @@ export default function (pi: ExtensionAPI): void {
 
 	registerAnnouncements(pi, runtime);
 
+	// Durable bootstrap: restore parked/settled threads from the manifest so a
+	// reload or restart keeps status and resume working, then age out old
+	// records and sweep leaked temp/state directories. Fire-and-forget; every
+	// stage is best-effort and never blocks registration.
+	void bootstrapDurableState(runtime);
+
 	// Proactive dispatch: inject the delegation directive into the parent system prompt.
 	pi.on("before_agent_start", async (event, ctx) => {
 		const config = await loadConfig(configPath);
@@ -86,7 +93,7 @@ export default function (pi: ExtensionAPI): void {
 			enabledNames: config.enabledAgents,
 			projectTrusted: ctx.isProjectTrusted?.() === true,
 		});
-		const directive = buildDelegationDirective(agents, { maxFixRounds: config.maxFixRounds });
+		const directive = buildDelegationDirective(agents);
 		if (!directive) return undefined;
 		return { systemPrompt: `${event.systemPrompt}\n${directive}` };
 	});

package/src/models.ts

@@ -86,6 +86,22 @@ export function findModelByRef(
 	return normalized ? models.find((model) => modelRef(model) === normalized) : undefined;
 }
 
+/** Split persisted agent model overrides into the ones Pi still reports as
+ * available and the stale ones. Stale refs are dropped at session start (with
+ * a user notice) so the config never carries models that can no longer run. */
+export function filterUnavailableModelOverrides(
+	agentModels: Record<string, string>,
+	models: readonly Model<Api>[],
+): { kept: Record<string, string>; dropped: Array<{ agent: string; ref: string }> } {
+	const kept: Record<string, string> = {};
+	const dropped: Array<{ agent: string; ref: string }> = [];
+	for (const [agent, ref] of Object.entries(agentModels)) {
+		if (findModelByRef(models, ref)) kept[agent] = ref;
+		else dropped.push({ agent, ref });
+	}
+	return { kept, dropped };
+}
+
 /**
  * Resolve one agent's runtime route:
  *