@ferris1225/pi-subagents 4.1.23 → 4.2.0

package/src/monitor.ts

@@ -20,7 +20,6 @@ import type { IsolationMode, WorktreeFinalizationStatus } from "./worktree.ts";
 
 export type RunStatus = "queued" | "running" | "interrupting" | "parked" | "done" | "failed";
 export type ContinuationKind = "resume-retained" | "resume-appended";
-export type WorkflowStageStatus = "done" | "active" | "pending" | "changes" | "failed";
 
 /** Why a queued run has produced no output yet. Three genuinely different
  * situations used to be reported as one "queued": waiting for a free process
@@ -32,19 +31,6 @@ export type WorkflowStageStatus = "done" | "active" | "pending" | "changes" | "f
  * "queued"; cleared on every transition out of it. */
 export type RunWaitReason = "process-slot" | "repository-lane" | "starting";
 
-/** Ephemeral projection of one real or currently planned managed stage. It is
- * live monitor state only; durable results remain the per-run chain records. */
-export interface WorkflowStage {
-	agent: string;
-	relation: string;
-	status: WorkflowStageStatus;
-	/** Telemetry snapshot frozen when the stage settled (the live child row
-	 * leaves the monitor at that moment); the active stage reads its live child. */
-	model?: string;
-	usage?: UsageStats;
-	elapsedMs?: number;
-}
-
 export function isRunActiveStatus(status: RunStatus): boolean {
 	return status === "queued" || status === "running" || status === "interrupting";
 }
@@ -88,45 +74,19 @@ export interface RunView {
 	endedAt?: number;
 	/** Why this generation reused retained context, shown in the widget/status. */
 	continuationKind?: ContinuationKind;
-	/** When set, this is an internal managed-workflow step. */
-	groupId?: string;
-	/** Human-readable role within a workflow, e.g. "final review" or "final documentation sync". */
-	relationLabel?: string;
-	/** Stable owning run whose row represents the whole managed workflow. */
-	parentRunId?: number;
-	/** This stable top-level row currently owns a multi-stage managed workflow.
-	 * Its elapsed time is workflow-wide; active child rows own stage telemetry. */
-	managedWorkflow?: boolean;
-	/** Live-only stage timeline retained on the parent while completed internal
-	 * child rows leave the monitor. */
-	workflowStages?: WorkflowStage[];
 }
 
-/** Optional metadata for documenter/reviewer/fix children of a stable parent run. */
+/** Extra metadata for a run whose row must carry isolation or resume context. */
 export interface RunChainMeta {
-	groupId?: string;
-	relationLabel?: string;
-	parentRunId?: number;
 	isolation?: IsolationMode;
 	worktreeId?: string;
 	continuationKind?: ContinuationKind;
 	/** Initial wait reason; defaults to "process-slot" (a fresh dispatch enters
-	 * the process queue). Workflow-internal children pass "starting" because
-	 * they spawn immediately and never wait for a slot. */
+	 * the process queue). Children spawned outside the queue pass "starting"
+	 * because they never wait for a slot. */
 	waitReason?: RunWaitReason;
 }
 
-/** Ephemeral activity of the parent pi model while its agent loop runs: the
- * live model/thinking ref and a one-line "what is it doing now". Not a run —
- * no id, usage, or chain machinery; the view disappears when the loop settles. */
-export interface MainActivity {
-	model?: string;
-	thinking?: string;
-	activity?: string;
-	/** Epoch ms when the current agent loop started. */
-	activeSince: number;
-}
-
 // ---------------------------------------------------------------------------
 // Formatting helpers
 // ---------------------------------------------------------------------------
@@ -299,6 +259,17 @@ export function runLabel(task: string): string {
 		: `${takeGraphemes(chars, RUN_LABEL_MAX - 1)}${TASK_SUMMARY_ELLIPSIS}`;
 }
 
+/** Narrow an already-extracted run label to a smaller budget, keeping its
+ * tail: runLabel tail-weights path fragments because the filename is the
+ * recognisable part, and a second squeeze must not trade that tail away.
+ * Grapheme-safe. */
+export function shrinkRunLabel(text: string, maxWidth: number): string {
+	if (maxWidth <= 0) return "";
+	if (visibleWidth(text) <= maxWidth) return text;
+	const chars = [...graphemeSegmenter.segment(text)].map((s) => s.segment);
+	return `${TASK_SUMMARY_ELLIPSIS}${tailGraphemes(chars, maxWidth - 1)}`;
+}
+
 function formatTokens(count: number): string {
 	if (count >= 1_000_000) return `${(count / 1_000_000).toFixed(1)}M`;
 	if (count >= 1_000) return `${(count / 1_000).toFixed(1)}k`;
@@ -483,71 +454,6 @@ export class MonitorStore {
 	private runs: RunView[] = [];
 	private nextId = 1;
 	private subscribers = new Set<() => void>();
-	private mainModel?: string;
-	private mainThinking?: string;
-	private mainActivity?: string;
-	private mainActiveSince?: number;
-
-	// --- parent pi model activity ------------------------------------------
-	// Fed by the parent session's extension events (agent loop, streaming,
-	// tool executions); rendered as the widget's first line. Change-guarded so
-	// per-token streaming deltas do not flood subscribers.
-
-	setMainModel(model?: string): void {
-		if (!model || this.mainModel === model) return;
-		this.mainModel = model;
-		this.notify();
-	}
-
-	setMainThinking(thinking?: string): void {
-		if (!thinking || this.mainThinking === thinking) return;
-		this.mainThinking = thinking;
-		this.notify();
-	}
-
-	setMainActivity(text: string): void {
-		const activity = sanitizeActivityText(text) || undefined;
-		if (!activity || this.mainActivity === activity) return;
-		this.mainActivity = activity;
-		this.notify();
-	}
-
-	/** Record the main model starting a tool; the activity shows the tool's
-	 * most telling argument, same vocabulary as subagent rows. */
-	recordMainToolStart(toolName: string, activity: string): void {
-		const safeToolName = sanitizeActivityText(toolName) || "tool";
-		this.setMainActivity(activity || safeToolName);
-	}
-
-	/** Record a failed main-model tool; successful completions keep their last
-	 * activity until the next model event supplies a better description. */
-	recordMainToolEnd(toolName: string, isError: boolean): void {
-		if (isError) this.setMainActivity(`✗ ${sanitizeActivityText(toolName) || "tool"} failed`);
-	}
-
-	/** Track the parent agent loop: started at agent_start, cleared when the
-	 * loop settles (agent_end / agent_settled). */
-	setMainAgentActive(active: boolean): void {
-		if ((this.mainActiveSince !== undefined) === active) return;
-		this.mainActiveSince = active ? Date.now() : undefined;
-		this.mainActivity = undefined;
-		this.notify();
-	}
-
-	/** Live view of the parent model while its agent loop runs; undefined when idle. */
-	getMainActivity(): MainActivity | undefined {
-		if (this.mainActiveSince === undefined) return undefined;
-		return {
-			...(this.mainModel ? { model: this.mainModel } : {}),
-			...(this.mainThinking ? { thinking: this.mainThinking } : {}),
-			...(this.mainActivity ? { activity: this.mainActivity } : {}),
-			activeSince: this.mainActiveSince,
-		};
-	}
-
-	isMainAgentActive(): boolean {
-		return this.mainActiveSince !== undefined;
-	}
 
 	beginTurn(): void {
 		// Clear finished runs from a previous turn, but keep active and parked
@@ -597,9 +503,6 @@ export class MonitorStore {
 			waitReason: meta?.waitReason ?? "process-slot",
 			usage: emptyUsage(),
 			elapsedMs: 0,
-			...(meta?.groupId ? { groupId: meta.groupId } : {}),
-			...(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?.continuationKind ? { continuationKind: meta.continuationKind } : {}),
 		});
@@ -638,27 +541,6 @@ export class MonitorStore {
 		this.notify();
 	}
 
-	/** Switch a stable top-level row from one model run to workflow ownership.
-	 * The original role remains for identity; child rows show stage telemetry. */
-	setManagedWorkflow(id: number, active: boolean): void {
-		const run = this.find(id);
-		if (!run) return;
-		run.managedWorkflow = active || undefined;
-		if (!active) run.workflowStages = undefined;
-		this.notify();
-	}
-
-	/** Replace the live workflow projection atomically so renderers never observe
-	 * a half-updated fix/re-review plan. */
-	setWorkflowStages(id: number, stages: readonly WorkflowStage[]): void {
-		const run = this.find(id);
-		if (!run) return;
-		run.workflowStages = stages.length > 0
-			? stages.map((stage) => ({ ...stage }))
-			: undefined;
-		this.notify();
-	}
-
 	setUsage(id: number, usage: UsageStats, model?: string): void {
 		const run = this.find(id);
 		if (!run) return;
@@ -795,8 +677,6 @@ export class MonitorStore {
 		run.waitReason = "process-slot";
 		run.usage = emptyUsage();
 		run.activity = undefined;
-		run.managedWorkflow = undefined;
-		run.workflowStages = undefined;
 		run.activeSince = undefined;
 		run.endedAt = undefined;
 		run.elapsedMs = Math.max(run.elapsedMs, meta?.elapsedMs ?? 0);
@@ -814,10 +694,6 @@ export class MonitorStore {
 	 * finishRun calls from the old session remain safe no-ops. */
 	clear(): void {
 		this.runs = [];
-		this.mainModel = undefined;
-		this.mainThinking = undefined;
-		this.mainActivity = undefined;
-		this.mainActiveSince = undefined;
 		this.notify();
 	}
 
@@ -843,14 +719,13 @@ export class MonitorStore {
 
 	summarize(run: RunView): string {
 		const usage = formatUsageCompact(run.usage);
-		const parts = [run.managedWorkflow ? `${run.agent} workflow` : run.agent];
+		const parts = [run.agent];
 		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);
-		if (!run.managedWorkflow && run.thinking) parts.push(`thinking ${run.thinking}`);
+		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"}`);
-		if (!run.managedWorkflow && usage) parts.push(usage);
+		if (usage) parts.push(usage);
 		const elapsed = formatElapsed(run);
 		if (elapsed) parts.push(elapsed);
 		return parts.join(" · ");

package/src/prompt.ts

@@ -20,38 +20,21 @@ export function buildDelegationDirective(
 
 	const catalog = agents.map(formatCatalogEntry).join("\n");
 	const hasExplorer = agents.some((agent) => agent.name === "explorer");
-	const hasWorker = agents.some((agent) => agent.name === "worker");
-	const hasCleaner = agents.some((agent) => agent.name === "cleaner");
-	const hasDocumenter = agents.some((agent) => agent.name === "documenter");
-	const hasReviewer = agents.some((agent) => agent.name === "reviewer");
-	const hasSynthesizer = agents.some((agent) => agent.name === "synthesizer");
-	const codeWriterNames = [
-		...(hasWorker ? ["worker"] : []),
-		...(hasCleaner ? ["cleaner"] : []),
-	];
+	const hasExecutor = agents.some((agent) => agent.name === "executor");
 
 	const dispatchRules = [
-		`Delegate aggressively: child contexts are cheap, yours is scarce. Inline only trivial work — a lookup, a single focused edit, an answer already in context${hasWorker ? "; default every non-trivial implementation, fix, refactor, or test task to `worker`" : ""}.`,
+		`Delegate aggressively: child contexts are cheap, yours is scarce. Inline only trivial work — a lookup, a single focused edit, an answer already in context${hasExecutor ? "; default every non-trivial delegated task (implementation, fix, refactor, test, cleanup, docs sync, result merging) to `executor`" : ""}.`,
 		...(hasExplorer
 			? [
 				"`explorer`: split a broad question into parallel explorers with disjoint scopes. Its findings are leads, never proof — re-read load-bearing files before acting yourself (a child you brief re-verifies).",
 			]
 			: []),
-		...(hasCleaner
-			? ["`cleaner`: dispatch for requested cleanup AND proactively when finished work leaves dead code or duplication. Your brief is its edit authorization — every safe proven cut applies without per-item approval; never a gate. Scope: the uncommitted diff, or whatever your brief names (Git range, directory)."]
-			: []),
-		...(hasDocumenter
-			? ["`documenter`: standalone docs/comment work; dispatch it proactively when a change — yours or a child's — leaves README/docs/comment drift no writer already synced; cheap and may make zero edits."]
-			: []),
-		...(hasReviewer
+		...(hasExecutor
 			? [
-				`\`reviewer\`: read-only assessments and gates${codeWriterNames.length > 0 ? `; successful ${codeWriterNames.join("/")} runs get one fresh gate, and failing gates are fixed by the reviewer itself in bounded fix/re-review rounds (a still-failing gate returns to you). Pass \`review: "none"\` for mechanical, low-risk edits you verify yourself; keep the default gate whenever behavior can change` : ""}. Advisory output has no VERDICT and cannot authorize edits.`,
+				"`executor`: brief it as the edit authorization. For cleanup, name the scope (uncommitted diff, Git range, directory) — every safe proven cut applies without per-item approval; finding no safe cut is a valid result. After a wide fan-out, pass the result-artifact paths to one executor and read its merged brief instead of every result yourself.",
 			]
 			: []),
-		...(hasSynthesizer
-			? ["`synthesizer`: after a wide fan-out, pass the result-artifact paths to one synthesizer and read its brief instead of every result yourself."]
-			: []),
-		`Parallelize by default: map the todo list onto ONE \`tasks\` dispatch. One child owns one deliverable and its files; only genuinely dependent work waits for its prerequisite.`,
+		"Parallelize by default: map the todo list onto ONE `tasks` dispatch. One child owns one deliverable and its files; only genuinely dependent work waits for its prerequisite.",
 		"Brief each child completely — goal, exact paths, constraints, expected output; it has no conversation memory and cannot delegate. Resume parked threads with `subagent_control resume`.",
 	];
 
@@ -63,13 +46,7 @@ export function buildDelegationDirective(
 
 	const verificationRules = [
 		"Never report an unrun check as passed; surface unavailable checks and pre-existing failures, and inspect actual changes before reporting completion.",
-		...(hasReviewer
-			? [
-				"A REVIEW_FAIL from a gate you dispatched directly returns its findings to you: fix them inline or via a briefed worker without waiting for the user, then re-verify ONCE. If the gate still fails, report the remaining findings and move on — never loop gate dispatches.",
-				"Multi-model cross-review only when explicitly requested or for high-risk security, FFI, migration, or concurrency changes.",
-			]
-			: []),
-		"Commit or push only when explicitly requested, applicable checks pass, and no review finding remains unresolved.",
+		"Commit or push only when explicitly requested and applicable checks pass.",
 	];
 
 	return `
@@ -86,6 +63,6 @@ ${bullets(dispatchRules)}
 Result handoff:
 ${bullets(handoffRules)}
 
-Review and verification:
+Verification:
 ${bullets(verificationRules)}`;
 }

package/src/recovery.ts

@@ -1,145 +1,145 @@
-/** Durable handoff for worktree integration/cleanup failures across sessions. */
-
-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 { stripVTControlCharacters } from "node:util";
-import type { WorktreeFinalization } from "./worktree.ts";
-
-export const RECOVERY_MANIFEST_FILE_NAME = "pi-subagents-recovery.json";
-const RECOVERY_MANIFEST_VERSION = 1;
-
-export interface RecoveryRecord {
-	runId: number;
-	createdAt: number;
-	integrated: boolean;
-	worktreePath?: string;
-	patchPath?: string;
-	error?: string;
-}
-
-interface RecoveryManifest {
-	version: number;
-	records: RecoveryRecord[];
-}
-
-export function getRecoveryManifestPath(configPath: string): string {
-	return join(dirname(configPath), RECOVERY_MANIFEST_FILE_NAME);
-}
-
-function normalizeRecord(value: unknown): RecoveryRecord | 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;
-	return {
-		runId: raw.runId,
-		createdAt: raw.createdAt,
-		integrated: raw.integrated === true,
-		...(typeof raw.worktreePath === "string" && raw.worktreePath ? { worktreePath: raw.worktreePath } : {}),
-		...(typeof raw.patchPath === "string" && raw.patchPath ? { patchPath: raw.patchPath } : {}),
-		...(typeof raw.error === "string" && raw.error ? { error: raw.error } : {}),
-	};
-}
-
-export async function readRecoveryRecords(configPath: string): Promise<RecoveryRecord[]> {
-	try {
-		const parsed = JSON.parse(await readFile(getRecoveryManifestPath(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 [];
-	}
-}
-
-function recoveryKey(record: RecoveryRecord): string {
-	return `${record.runId}\0${record.worktreePath ?? ""}\0${record.patchPath ?? ""}\0${record.error ?? ""}`;
-}
-
-async function writeManifest(path: string, records: readonly RecoveryRecord[]): Promise<void> {
-	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: RecoveryManifest = {
-			version: RECOVERY_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);
-	}
-}
-
-/** Merge retained artifacts into the durable manifest. */
-export async function persistRecoveryRecords(
-	configPath: string,
-	records: readonly RecoveryRecord[],
-): Promise<void> {
-	if (records.length === 0) return;
-	const path = getRecoveryManifestPath(configPath);
-	await withFileMutationQueue(path, async () => {
-		const merged = new Map<string, RecoveryRecord>();
-		for (const record of await readRecoveryRecords(configPath)) merged.set(recoveryKey(record), record);
-		for (const record of records) merged.set(recoveryKey(record), record);
-		await writeManifest(path, [...merged.values()]);
-	});
-}
-
-export function recoveryRecordFromFinalization(
-	runId: number,
-	finalization: WorktreeFinalization,
-	now = Date.now(),
-): RecoveryRecord {
-	return {
-		runId,
-		createdAt: now,
-		integrated: finalization.integrated,
-		...(finalization.worktreePath ? { worktreePath: finalization.worktreePath } : {}),
-		...(finalization.patchPath ? { patchPath: finalization.patchPath } : {}),
-		...(finalization.error ? { error: finalization.error } : {}),
-	};
-}
-
-/** Show retained recovery paths on every later session start until the user
- * removes the artifacts. Stale records are pruned automatically. */
-export async function announceRecoveryRecords(
-	configPath: string,
-	ctx: {
-		hasUI?: boolean;
-		ui: { notify(message: string, kind: "info" | "warning" | "error"): void };
-	},
-): Promise<void> {
-	if (ctx.hasUI === false) return;
-	const records = await readRecoveryRecords(configPath);
-	if (records.length === 0) return;
-	const live = records.filter((record) =>
-		(record.worktreePath ? existsSync(record.worktreePath) : false) ||
-		(record.patchPath ? existsSync(record.patchPath) : false),
-	);
-	if (live.length !== records.length) {
-		const path = getRecoveryManifestPath(configPath);
-		await withFileMutationQueue(path, () => writeManifest(path, live)).catch(() => undefined);
-	}
-	for (const record of live) {
-		const paths = [
-			record.worktreePath ? `worktree ${stripVTControlCharacters(record.worktreePath)}` : undefined,
-			record.patchPath ? `patch ${stripVTControlCharacters(record.patchPath)}` : undefined,
-		].filter(Boolean).join(" · ");
-		const reason = record.error ? ` · ${stripVTControlCharacters(record.error)}` : "";
-		ctx.ui.notify(
-			`pi-subagents recovery for run #${record.runId}: ${record.integrated ? "changes were applied but cleanup failed" : "integration failed"}${paths ? ` · retained ${paths}` : ""}${reason}`,
-			"error",
-		);
-	}
-}
+/** Durable handoff for worktree integration/cleanup failures across sessions. */
+
+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 { stripVTControlCharacters } from "node:util";
+import type { WorktreeFinalization } from "./worktree.ts";
+
+export const RECOVERY_MANIFEST_FILE_NAME = "pi-subagents-recovery.json";
+const RECOVERY_MANIFEST_VERSION = 1;
+
+export interface RecoveryRecord {
+	runId: number;
+	createdAt: number;
+	integrated: boolean;
+	worktreePath?: string;
+	patchPath?: string;
+	error?: string;
+}
+
+interface RecoveryManifest {
+	version: number;
+	records: RecoveryRecord[];
+}
+
+export function getRecoveryManifestPath(configPath: string): string {
+	return join(dirname(configPath), RECOVERY_MANIFEST_FILE_NAME);
+}
+
+function normalizeRecord(value: unknown): RecoveryRecord | 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;
+	return {
+		runId: raw.runId,
+		createdAt: raw.createdAt,
+		integrated: raw.integrated === true,
+		...(typeof raw.worktreePath === "string" && raw.worktreePath ? { worktreePath: raw.worktreePath } : {}),
+		...(typeof raw.patchPath === "string" && raw.patchPath ? { patchPath: raw.patchPath } : {}),
+		...(typeof raw.error === "string" && raw.error ? { error: raw.error } : {}),
+	};
+}
+
+export async function readRecoveryRecords(configPath: string): Promise<RecoveryRecord[]> {
+	try {
+		const parsed = JSON.parse(await readFile(getRecoveryManifestPath(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 [];
+	}
+}
+
+function recoveryKey(record: RecoveryRecord): string {
+	return `${record.runId}\0${record.worktreePath ?? ""}\0${record.patchPath ?? ""}\0${record.error ?? ""}`;
+}
+
+async function writeManifest(path: string, records: readonly RecoveryRecord[]): Promise<void> {
+	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: RecoveryManifest = {
+			version: RECOVERY_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);
+	}
+}
+
+/** Merge retained artifacts into the durable manifest. */
+export async function persistRecoveryRecords(
+	configPath: string,
+	records: readonly RecoveryRecord[],
+): Promise<void> {
+	if (records.length === 0) return;
+	const path = getRecoveryManifestPath(configPath);
+	await withFileMutationQueue(path, async () => {
+		const merged = new Map<string, RecoveryRecord>();
+		for (const record of await readRecoveryRecords(configPath)) merged.set(recoveryKey(record), record);
+		for (const record of records) merged.set(recoveryKey(record), record);
+		await writeManifest(path, [...merged.values()]);
+	});
+}
+
+export function recoveryRecordFromFinalization(
+	runId: number,
+	finalization: WorktreeFinalization,
+	now = Date.now(),
+): RecoveryRecord {
+	return {
+		runId,
+		createdAt: now,
+		integrated: finalization.integrated,
+		...(finalization.worktreePath ? { worktreePath: finalization.worktreePath } : {}),
+		...(finalization.patchPath ? { patchPath: finalization.patchPath } : {}),
+		...(finalization.error ? { error: finalization.error } : {}),
+	};
+}
+
+/** Show retained recovery paths on every later session start until the user
+ * removes the artifacts. Stale records are pruned automatically. */
+export async function announceRecoveryRecords(
+	configPath: string,
+	ctx: {
+		hasUI?: boolean;
+		ui: { notify(message: string, kind: "info" | "warning" | "error"): void };
+	},
+): Promise<void> {
+	if (ctx.hasUI === false) return;
+	const records = await readRecoveryRecords(configPath);
+	if (records.length === 0) return;
+	const live = records.filter((record) =>
+		(record.worktreePath ? existsSync(record.worktreePath) : false) ||
+		(record.patchPath ? existsSync(record.patchPath) : false),
+	);
+	if (live.length !== records.length) {
+		const path = getRecoveryManifestPath(configPath);
+		await withFileMutationQueue(path, () => writeManifest(path, live)).catch(() => undefined);
+	}
+	for (const record of live) {
+		const paths = [
+			record.worktreePath ? `worktree ${stripVTControlCharacters(record.worktreePath)}` : undefined,
+			record.patchPath ? `patch ${stripVTControlCharacters(record.patchPath)}` : undefined,
+		].filter(Boolean).join(" · ");
+		const reason = record.error ? ` · ${stripVTControlCharacters(record.error)}` : "";
+		ctx.ui.notify(
+			`pi-subagents recovery for run #${record.runId}: ${record.integrated ? "changes were applied but cleanup failed" : "integration failed"}${paths ? ` · retained ${paths}` : ""}${reason}`,
+			"error",
+		);
+	}
+}

package/src/runtime.ts

@@ -25,7 +25,6 @@ import { isRunActiveStatus, monitor } from "./monitor.ts";
 import type { RpcRunControl } from "./rpc-run.ts";
 import type { StartBackgroundInternal } from "./thread-lifecycle.ts";
 import { isFailedResult, type SingleResult } from "./spawn.ts";
-import type { ReviewMode } from "./workflow.ts";
 import type { IsolationMode, WorktreeFinalization, WorktreeIsolation } from "./worktree.ts";
 
 export type ThreadState =
@@ -51,15 +50,12 @@ export interface SubagentThread {
 	executionCwd: string;
 	thinkingLevel?: ThinkingLevel;
 	isolation: IsolationMode;
-	/** Dispatch-time gate intensity; "none" skips the automatic post-writer
-	 * reviewer for this thread (kept across resumes and reloads). */
-	review?: ReviewMode;
 	worktree?: WorktreeIsolation;
 	state: ThreadState;
 	control: RpcRunControl;
 	queueController?: AbortController;
-	/** Resolves only after the current generation's top-level child, downstream
-	 * managed workflow, and queue work have fully quiesced and released their
+	/** Resolves only after the current generation's child process, isolation
+	 * finalization, and queue work have fully quiesced and released their
 	 * concurrency slot. */
 	generationCompletion: Promise<void>;
 	/** Synchronous CAS used by lifecycle controls across their async preflight. */
@@ -122,8 +118,7 @@ export interface SubagentRuntime {
 	/** Resume setup that has claimed a thread but has not yet enqueued its
 	 * next generation. Shutdown invalidates these claims and waits for cleanup. */
 	preflightOperations: Set<Promise<void>>;
-	/** Every session directory retained for this parent session, including
-	 * managed-workflow internals that are not directly controllable. */
+	/** Every session directory retained for this parent session. */
 	sessionDirs: Set<string>;
 	retainSession: (result: Pick<SingleResult, "sessionDir">) => void;
 	retireThreadSession: (thread: SubagentThread) => void;
@@ -148,8 +143,6 @@ 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.
-			// Managed-workflow parents remain "running" through reviewer and
-			// documenter stages, so they are included without a special case.
 			const active = monitor
 				.getRuns()
 				.filter((run) => isRunActiveStatus(run.status))