@ferris1225/pi-subagents 4.1.8 → 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

@@ -20,11 +20,11 @@ import { getResultOutput, isFailedResult, reviewVerdict, type SingleResult } fro
 import { formatUsageCompact, sumUsage } from "./monitor.ts";
 
 /**
- * Worker fixes allowed after REVIEW_FAIL. Each fix is followed by a reviewer
- * re-review; this cap does not suppress the post-writer review gate or its
- * conditional/reviewer-disabled documentation fallback.
+ * 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 = 2;
+export const MAX_FIX_ROUNDS = 1;
 
 /**
  * Whether a completed result should trigger the auto-fix loop instead of being
@@ -114,8 +114,9 @@ export function canStartManagedWorkflow(
 export function getManagedWorkflowPlan(
 	result: SingleResult,
 	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 {
@@ -127,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);
@@ -149,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).`,
 		``,
@@ -162,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");
 }
 
@@ -210,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");
 }
@@ -314,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.`,
@@ -356,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);

package/src/monitor.ts

@@ -18,8 +18,8 @@ import type { IsolationMode, WorktreeFinalizationStatus } from "./worktree.ts";
 // Types
 // ---------------------------------------------------------------------------
 
-export type RunStatus = "queued" | "running" | "steering" | "interrupting" | "parked" | "done" | "failed";
-export type ContinuationKind = "resume-retained" | "resume-appended" | "fork-retained" | "fork-appended" | "retarget";
+export type RunStatus = "queued" | "running" | "interrupting" | "parked" | "done" | "failed";
+export type ContinuationKind = "resume-retained" | "resume-appended";
 export type WorkflowStageStatus = "done" | "active" | "pending" | "changes" | "failed";
 
 /** Ephemeral projection of one real or currently planned managed stage. It is
@@ -31,7 +31,7 @@ export interface WorkflowStage {
 }
 
 export function isRunActiveStatus(status: RunStatus): boolean {
-	return status === "queued" || status === "running" || status === "steering" || status === "interrupting";
+	return status === "queued" || status === "running" || status === "interrupting";
 }
 
 /** Durable integration projection of a worktree-isolated run: pending before
@@ -57,8 +57,6 @@ export interface RunView {
 	/** Short worktree-group identity (mkdtemp suffix) shared by every run inside
 	 * one isolated worktree; changes when a continuation worktree is created. */
 	worktreeId?: string;
-	forkedFromRunId?: number;
-	forkChildRunIds?: number[];
 	status: RunStatus;
 	usage: UsageStats;
 	/** Concise current activity ("thinking", "read src/index.ts"); last writer wins. */
@@ -94,7 +92,6 @@ export interface RunChainMeta {
 	parentRunId?: number;
 	isolation?: IsolationMode;
 	worktreeId?: string;
-	forkedFromRunId?: number;
 	continuationKind?: ContinuationKind;
 }
 
@@ -325,13 +322,10 @@ export function formatElapsed(run: RunView, now: number = Date.now()): string {
 	return formatDuration(elapsedMilliseconds(run, now));
 }
 
-export function continuationLabel(kind: ContinuationKind | undefined, sourceRunId?: number): string | undefined {
+export function continuationLabel(kind: ContinuationKind | undefined): string | undefined {
 	switch (kind) {
 		case "resume-retained": return "resume: current objective";
 		case "resume-appended": return "resume: appended objective";
-		case "fork-retained": return `fork${sourceRunId === undefined ? "" : ` #${sourceRunId}`}: current objective`;
-		case "fork-appended": return `fork${sourceRunId === undefined ? "" : ` #${sourceRunId}`}: appended objective`;
-		case "retarget": return "retarget: replacement objective";
 		default: return undefined;
 	}
 }
@@ -452,6 +446,26 @@ export class MonitorStore {
 		return this.nextId++;
 	}
 
+	/** Keep newly allocated ids above a restored id so reload-restored threads
+	 * never collide with runs started in the current process. */
+	ensureNextIdAbove(id: number): void {
+		if (id >= this.nextId) this.nextId = id + 1;
+	}
+
+	/** Re-register a durable thread restored from a previous process. The row
+	 * keeps its stable id and historical elapsed time. */
+	restoreRun(view: Pick<RunView, "id" | "agent" | "task" | "status"> & Partial<RunView>): void {
+		if (this.find(view.id)) return;
+		this.runs.push({
+			label: runLabel(view.task),
+			usage: emptyUsage(),
+			elapsedMs: 0,
+			...view,
+		});
+		this.ensureNextIdAbove(view.id);
+		this.notify();
+	}
+
 	addRun(agent: string, task: string, model?: string, thinking?: string, meta?: RunChainMeta): number {
 		const id = this.reserveRunId();
 		this.runs.push({
@@ -468,7 +482,6 @@ export class MonitorStore {
 			...(meta?.relationLabel ? { relationLabel: meta.relationLabel } : {}),
 			...(meta?.parentRunId !== undefined ? { parentRunId: meta.parentRunId } : {}),
 			...(meta?.isolation ? { isolation: meta.isolation, integrationStatus: meta.isolation === "worktree" ? "pending" : undefined, ...(meta.worktreeId ? { worktreeId: meta.worktreeId } : {}) } : {}),
-			...(meta?.forkedFromRunId !== undefined ? { forkedFromRunId: meta.forkedFromRunId } : {}),
 			...(meta?.continuationKind ? { continuationKind: meta.continuationKind } : {}),
 		});
 		this.notify();
@@ -479,8 +492,8 @@ export class MonitorStore {
 		const run = this.find(id);
 		if (!run) return;
 		const previousStatus = run.status;
-		const wasExecuting = previousStatus === "running" || previousStatus === "steering" || previousStatus === "interrupting";
-		const isExecuting = status === "running" || status === "steering" || status === "interrupting";
+		const wasExecuting = previousStatus === "running" || previousStatus === "interrupting";
+		const isExecuting = status === "running" || status === "interrupting";
 		const now = Date.now();
 		run.status = status;
 		if (isExecuting && !wasExecuting) {
@@ -582,18 +595,8 @@ export class MonitorStore {
 		this.notify();
 	}
 
-	setForkRelation(sourceRunId: number, childRunId: number): void {
-		const source = this.find(sourceRunId);
-		if (source) {
-			source.forkChildRunIds ??= [];
-			if (!source.forkChildRunIds.includes(childRunId)) source.forkChildRunIds.push(childRunId);
-		}
-		const child = this.find(childRunId);
-		if (child) child.forkedFromRunId = sourceRunId;
-		this.notify();
-	}
 
-	/** Update the objective shown for a queued retarget or resumed generation. */
+	/** Update the objective shown for a resumed generation. */
 	setTask(id: number, task: string): void {
 		const run = this.find(id);
 		if (!run) return;
@@ -706,7 +709,7 @@ export class MonitorStore {
 	summarize(run: RunView): string {
 		const usage = formatUsageCompact(run.usage);
 		const parts = [run.managedWorkflow ? `${run.agent} workflow` : run.agent];
-		const continuation = continuationLabel(run.continuationKind, run.forkedFromRunId);
+		const continuation = continuationLabel(run.continuationKind);
 		if (continuation) parts.push(continuation);
 		if (run.relationLabel) parts.push(run.relationLabel);
 		if (!run.managedWorkflow && run.model) parts.push(run.model);
@@ -743,8 +746,6 @@ export function statusIcon(status: RunStatus, theme: Theme): string {
 	switch (status) {
 		case "running":
 			return theme.fg("accent", "●");
-		case "steering":
-			return theme.fg("accent", "◆");
 		case "interrupting":
 			return theme.fg("warning", "◐");
 		case "parked":
@@ -765,8 +766,6 @@ export function statusLabel(status: RunStatus): string {
 			return "ready";
 		case "running":
 			return "running";
-		case "steering":
-			return "steering";
 		case "interrupting":
 			return "interrupting";
 		case "parked":