@ferris1225/pi-subagents 4.1.2 → 4.1.4

package/src/fixloop.ts

@@ -1,17 +1,19 @@
 /**
  * Managed workflow policy and handoff formatting.
  *
- * Successful top-level writers can continue through documentation sync and an
- * independent final review. A direct passing reviewer is also forced through
- * documentation sync plus a fresh review when documenter is enabled. Any final
- * gate failure may then use the established worker → optional documenter →
- * reviewer fix rounds. Internal steps are launched by dispatch directly, so
- * they never re-enter this top-level policy or wake the main agent mid-chain.
+ * Successful top-level writers continue through an independent code review
+ * gate; bounded worker → reviewer fix rounds close its findings; one final
+ * documentation sync runs after the gate settles, so code fixes never
+ * invalidate an earlier docs pass and reviewers stay focused on code. A direct
+ * passing reviewer gets that same single final documentation sync instead of a
+ * second gate; a direct failing reviewer uses the same fix rounds plus the
+ * final sync. Internal steps are launched by dispatch directly, so they never
+ * re-enter this top-level policy or wake the main agent mid-chain.
  */
 
 import { isWriteCapableAgent, type AgentConfig } from "./agents.ts";
 import { getResultOutput, isFailedResult, reviewVerdict, type SingleResult } from "./spawn.ts";
-import { extractKeyFragments, formatUsageCompact, sumUsage } from "./monitor.ts";
+import { formatUsageCompact, sumUsage } from "./monitor.ts";
 import type { SubagentsConfig } from "./config.ts";
 
 /**
@@ -107,7 +109,9 @@ export function getManagedWorkflowPlan(
 	if (result.agent !== "reviewer") return undefined;
 
 	const verdict = reviewVerdict(getResultOutput(result));
-	if (verdict === "pass" && availability.documenter && availability.reviewer) {
+	// The pass stands as the code gate; documenter then syncs docs once and the
+	// workflow delivers without a second gate.
+	if (verdict === "pass" && availability.documenter) {
 		return { kind: "review-pass-sync", initialRelation: "pre-documentation review" };
 	}
 	if (verdict === "fail" && availability.worker && shouldTriggerFixLoop(result, config)) {
@@ -135,77 +139,56 @@ export function buildFixTaskBrief(reviewerResult: SingleResult, round: number, m
 		`Fix EVERY finding in the reviewer's findings list — there is no severity triage; all of them get fixed.`,
 		`If a finding is factually wrong or clearly out of scope, say so explicitly instead of fixing it.`,
 		`Do NOT refactor unrelated code beyond what the findings require.`,
-		`Do NOT commit, push, publish, tag, or release; do not bump versions. The parent chain still owns documentation sync and final review.`,
+		`Do NOT commit, push, publish, tag, or release; do not bump versions. The parent chain still owns re-review and the final documentation sync.`,
 		`After editing, run the project's format/build/tests when they exist and report`,
 		`exactly what you changed (paths + short rationale) 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; optional documentation sync and a fresh reviewer still run before final delivery.`,
+			: `This is the last auto-fix round; the workflow runs any enabled final documentation sync and then delivers.`,
 	].join("\n");
 }
 
-interface DocumentationBriefOptions {
-	title: string;
-	reports: Array<{ label: string; result: SingleResult }>;
-	closing: string;
-}
-
-function buildDocumentationBrief(options: DocumentationBriefOptions): string {
-	const reportSections = options.reports.flatMap(({ label, result }) => [
-		`${label}:`,
-		`---`,
-		getResultOutput(result),
-		`---`,
-		``,
-	]);
+/** Build the single documentation handoff that runs after the review gate
+ * settles. The last writer's report (top-level writer or final fix-round
+ * worker) and the terminal gate review are leads; the pending diff stays
+ * authoritative. At most one of the two is undefined in every managed flow. */
+export function buildFinalDocumenterBrief(
+	lastWriterResult?: SingleResult,
+	finalReviewResult?: SingleResult,
+): string {
+	const reportSections = [
+		...(lastWriterResult
+			? [
+				`The last writer (${lastWriterResult.agent}) reported:`,
+				`---`,
+				getResultOutput(lastWriterResult),
+				`---`,
+				``,
+			]
+			: []),
+		...(finalReviewResult
+			? [
+				`The final gate review reported:`,
+				`---`,
+				getResultOutput(finalReviewResult),
+				`---`,
+				``,
+			]
+			: []),
+	];
 	return [
-		options.title,
+		`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 report is only a lead.`,
-		`Synchronize stale README/docs, examples, API comments, docstrings, and explanatory comments with the behavior that will be committed.`,
+		`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. ${options.closing}`,
+		`Do NOT commit, push, publish, tag, or release; do not bump versions. The parent 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");
 }
 
-/** Build the pre-commit documentation handoff after one auto-fix worker. */
-export function buildDocumenterTaskBrief(
-	workerResult: SingleResult,
-	round: number,
-	reviewerResult?: SingleResult,
-): string {
-	return buildDocumentationBrief({
-		title: `Documentation sync after auto-fix round ${round}.`,
-		reports: [
-			...(reviewerResult ? [{ label: "The triggering reviewer reported", result: reviewerResult }] : []),
-			{ label: "The worker reported", result: workerResult },
-		],
-		closing: "a fresh reviewer gate runs after you.",
-	});
-}
-
-/** Build the automatic documentation stage after a successful top-level writer. */
-export function buildPostWriterDocumenterBrief(writerResult: SingleResult): string {
-	return buildDocumentationBrief({
-		title: `Documentation sync after successful top-level ${writerResult.agent}.`,
-		reports: [{ label: `The ${writerResult.agent} reported`, result: writerResult }],
-		closing: "the managed workflow owns any final reviewer and delivery.",
-	});
-}
-
-/** A direct passing review cannot be the final gate while documenter is enabled:
- * the preliminary report is context, but the actual pending diff is authoritative. */
-export function buildReviewPassDocumenterBrief(reviewerResult: SingleResult): string {
-	return buildDocumentationBrief({
-		title: "Documentation sync required before accepting a direct passing review.",
-		reports: [{ label: "The preliminary reviewer reported", result: reviewerResult }],
-		closing: "the preliminary pass is not final and a fresh reviewer gate runs after you.",
-	});
-}
-
 /**
  * One step of an auto-fix chain as delivered: the run id (so the condensed
  * summary can point at per-run detail via subagent_status), the result, and
@@ -224,16 +207,6 @@ export interface ManagedWorkflowOutcome {
 	steps: ChainStep[];
 }
 
-/** Max distinguishing fragments kept in a one-line chain summary. */
-export const CHAIN_SUMMARY_FRAGMENTS_MAX = 3;
-
-/** The most telling fragments (paths, quoted phrases, symbols) of a run's final
- * output: for a worker these are the paths it changed, for a reviewer the
- * issues it found. Capped so summaries stay one line. */
-export function chainKeyFragments(result: SingleResult): string[] {
-	return extractKeyFragments(getResultOutput(result)).slice(0, CHAIN_SUMMARY_FRAGMENTS_MAX);
-}
-
 function workflowResultStatus(result: SingleResult): string {
 	if (isFailedResult(result)) return "failed";
 	if (result.agent === "reviewer") {
@@ -244,15 +217,8 @@ function workflowResultStatus(result: SingleResult): string {
 }
 
 function workflowStepLine(step: ChainStep): string {
-	const fragments = chainKeyFragments(step.result);
-	const writer = step.result.agent === "worker" || step.result.agent === "cleaner" || step.result.agent === "documenter";
-	const suffix = fragments.length > 0
-		? writer
-			? ` — changed: ${fragments.join(" · ")}`
-			: ` — ${fragments.join(" · ")}`
-		: "";
 	const id = step.runId !== undefined ? `#${step.runId} ` : "";
-	return `- ${id}${step.result.agent} · ${step.relation} · ${workflowResultStatus(step.result)}${suffix}`;
+	return `- ${id}${step.result.agent} · ${step.relation} · ${workflowResultStatus(step.result)}`;
 }
 
 function appendWorkflowFooter(lines: string[], steps: readonly ChainStep[]): void {
@@ -260,7 +226,13 @@ function appendWorkflowFooter(lines: string[], steps: readonly ChainStep[]): voi
 	const usage = formatUsageCompact(total);
 	lines.push("", `Totals: ${steps.length} run${steps.length === 1 ? "" : "s"}${usage ? ` · ${usage}` : ""}`);
 	const ids = steps.filter((step) => step.runId !== undefined).map((step) => `#${step.runId}`);
-	lines.push(`Full per-run reports (output, usage, failed tools): subagent_status ${ids.join(" ")}`);
+	lines.push(`Per-run details: subagent_status ${ids.join(" ")}`);
+}
+
+function formatWorkflowSummary(title: string, steps: readonly ChainStep[]): string {
+	const lines = [title, "", ...steps.map(workflowStepLine)];
+	appendWorkflowFooter(lines, steps);
+	return lines.join("\n");
 }
 
 /** Condensed compatibility summary for a direct REVIEW_FAIL auto-fix chain. */
@@ -269,13 +241,10 @@ export function formatChainSummary(
 	terminalResult: SingleResult = steps[steps.length - 1]!.result,
 ): string {
 	const rounds = steps.filter((step) => step.relation.startsWith("fix round")).length;
-	const lines = [
+	return formatWorkflowSummary(
 		`## Auto-fix chain: ${Math.max(1, rounds)} round${rounds === 1 ? "" : "s"} — final ${workflowResultStatus(terminalResult)}`,
-		"",
-		...steps.map(workflowStepLine),
-	];
-	appendWorkflowFooter(lines, steps);
-	return lines.join("\n");
+		steps,
+	);
 }
 
 /** One clear final delivery for all newly managed writer/documenter workflows. */
@@ -286,42 +255,42 @@ export function formatManagedWorkflowSummary(
 	const route = steps.map((step) => step.result.agent).join(" → ");
 	const fixRounds = steps.filter((step) => step.relation.startsWith("fix round")).length;
 	const roundNote = fixRounds > 0 ? ` · ${fixRounds} fix round${fixRounds === 1 ? "" : "s"}` : "";
-	const lines = [
+	return formatWorkflowSummary(
 		`## Managed workflow: ${route}${roundNote} — final ${workflowResultStatus(terminalResult)}`,
-		"",
-		...steps.map(workflowStepLine),
-	];
-	appendWorkflowFooter(lines, steps);
-	return lines.join("\n");
+		steps,
+	);
+}
+
+export interface GateBriefOptions {
+	/** A final documenter runs after the gate settles. Documentation drift is
+	 * then routed to it as non-gating notes instead of failing the gate. */
+	documenterPending: boolean;
 }
 
-/** Build the first independent final gate after a top-level writer or required
- * post-pass documentation sync. Reports carry intent; the actual pending diff
- * remains authoritative. */
+/** Build the code gate that runs directly after a top-level writer, before any
+ * documentation. Reports carry intent; the actual pending diff remains
+ * authoritative. */
 export function buildFinalReviewBrief(
 	initialResult: SingleResult,
-	documenterResult?: SingleResult,
+	options: GateBriefOptions,
 ): string {
-	const documenterSection = documenterResult
-		? [
-			``,
-			`The documenter's full sync report:`,
-			`---`,
-			getResultOutput(documenterResult),
-			`---`,
-		]
-		: [];
 	return [
-		`Fresh final gate for a managed ${initialResult.agent} workflow.`,
+		`Fresh code gate for a managed ${initialResult.agent} workflow.`,
 		``,
 		`The top-level ${initialResult.agent}'s full report:`,
 		`---`,
 		getResultOutput(initialResult),
 		`---`,
-		...documenterSection,
 		``,
-		`Run \`git status\` and \`git diff\` and inspect the actual pending code and documentation; reports are context, not proof.`,
-		`Remain read-only. Verify correctness, regressions, tests, documentation drift, and that documenter was the last writer when it ran.`,
+		`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.`,
+		...(options.documenterPending
+			? [
+				`Documentation sync runs AFTER this gate, so documentation drift is not a gate finding: record needed`,
+				`documentation updates as a separate short "## Documentation notes" list for the final documenter,`,
+				`and fail the gate only for code or test findings.`,
+			]
+			: []),
 		`This is an acceptance gate, not an advisory audit. End with exactly one standalone machine verdict line:`,
 		`VERDICT: REVIEW_PASS when no finding remains, otherwise VERDICT: REVIEW_FAIL.`,
 	].join("\n");
@@ -329,29 +298,19 @@ export function buildFinalReviewBrief(
 
 /**
  * The re-review brief handed to the reviewer after a worker fix round. Includes
- * the prior review, worker report, and optional documenter report so the
- * reviewer can adjudicate rejections instead of restating findings. The
- * convergence contract keeps rounds from ping-ponging: rule on the open
- * findings once, add only defects this round's edits introduced, never re-open
- * a verified resolution.
+ * the prior review and worker report so the reviewer can adjudicate rejections
+ * instead of restating findings. The convergence contract keeps rounds from
+ * ping-ponging: rule on the open findings once, add only defects this round's
+ * edits introduced, never re-open a verified resolution.
  */
 export function buildReReviewBrief(
 	reviewerResult: SingleResult,
 	round: number,
 	workerResult: SingleResult,
-	documenterResult?: SingleResult,
+	options: GateBriefOptions = { documenterPending: false },
 ): string {
 	const review = getResultOutput(reviewerResult);
 	const workerReport = getResultOutput(workerResult);
-	const documenterSection = documenterResult
-		? [
-			``,
-			`The documenter's pre-commit sync report:`,
-			`---`,
-			getResultOutput(documenterResult),
-			`---`,
-		]
-		: [];
 	return [
 		`Re-review after auto-fix round ${round}.`,
 		``,
@@ -364,7 +323,6 @@ export function buildReReviewBrief(
 		`---`,
 		workerReport,
 		`---`,
-		...documenterSection,
 		``,
 		`Rule on EVERY previous finding: resolved, or still open. A finding the worker rejected must be`,
 		`adjudicated ONCE — accept the rejection unless you can concretely refute the worker's reasoning;`,
@@ -372,6 +330,11 @@ export function buildReReviewBrief(
 		`Run \`git diff\` to see what changed, then add NEW findings only when they are defects this round's`,
 		`edits introduced or exposed (or a load-bearing issue the earlier review genuinely missed).`,
 		`Do NOT re-open a finding you verified as resolved.`,
+		...(options.documenterPending
+			? [
+				`Carry any unresolved "## Documentation notes" forward verbatim; the final documenter applies them after the chain settles.`,
+			]
+			: []),
 		`REQUEST_CHANGES only while an open finding remains; otherwise APPROVE.`,
 		`End with your machine-readable verdict line as usual (VERDICT: REVIEW_PASS / REVIEW_FAIL).`,
 	].join("\n");

package/src/monitor.ts

@@ -19,6 +19,7 @@ import type { IsolationMode, WorktreeFinalizationStatus } from "./worktree.ts";
 // ---------------------------------------------------------------------------
 
 export type RunStatus = "queued" | "running" | "steering" | "interrupting" | "parked" | "done" | "failed";
+export type ContinuationKind = "resume-retained" | "resume-appended" | "fork-retained" | "fork-appended" | "retarget";
 
 export function isRunActiveStatus(status: RunStatus): boolean {
 	return status === "queued" || status === "running" || status === "steering" || status === "interrupting";
@@ -45,16 +46,25 @@ export interface RunView {
 	usage: UsageStats;
 	/** Concise current activity ("thinking", "read src/index.ts"); last writer wins. */
 	activity?: string;
-	/** Epoch ms when the run started executing (set on first "running" status). */
+	/** Epoch ms when this logical run first started executing. */
 	startedAt?: number;
-	/** Epoch ms when the run finished (set on "done"/"failed"). */
+	/** Epoch ms when the current active segment started. */
+	activeSince?: number;
+	/** Cumulative active execution time from closed segments; parked time is excluded. */
+	elapsedMs: number;
+	/** Epoch ms when the latest active segment stopped. */
 	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 chain, e.g. "fix round 1" or "re-review round 1". */
 	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;
 }
 
 /** Optional metadata for documenter/reviewer/fix children of a stable parent run. */
@@ -64,6 +74,7 @@ export interface RunChainMeta {
 	parentRunId?: number;
 	isolation?: IsolationMode;
 	forkedFromRunId?: number;
+	continuationKind?: ContinuationKind;
 }
 
 // ---------------------------------------------------------------------------
@@ -276,10 +287,32 @@ export function formatDuration(ms: number): string {
 	return `${hours}h${String(minutes % 60).padStart(2, "0")}m`;
 }
 
-/** Elapsed wall time of a run: live while running, final once finished. */
+/** Cumulative active time across generations; parked gaps never count. */
+export function elapsedMilliseconds(run: RunView, now: number = Date.now()): number {
+	let elapsed = run.elapsedMs ?? 0;
+	if (run.activeSince !== undefined) elapsed += Math.max(0, now - run.activeSince);
+	// Keep formatting tolerant of older/synthetic RunView values that predate
+	// segmented timing and carry only startedAt/endedAt.
+	if (elapsed === 0 && run.startedAt !== undefined && run.activeSince === undefined) {
+		elapsed = Math.max(0, (run.endedAt ?? now) - run.startedAt);
+	}
+	return elapsed;
+}
+
 export function formatElapsed(run: RunView, now: number = Date.now()): string {
-	if (run.startedAt === undefined) return "";
-	return formatDuration((run.endedAt ?? now) - run.startedAt);
+	if (run.startedAt === undefined && run.elapsedMs <= 0) return "";
+	return formatDuration(elapsedMilliseconds(run, now));
+}
+
+export function continuationLabel(kind: ContinuationKind | undefined, sourceRunId?: number): 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;
+	}
 }
 
 /** Max length of the argument target inside a formatted activity line. */
@@ -409,11 +442,13 @@ export class MonitorStore {
 			thinking,
 			status: "queued",
 			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?.forkedFromRunId !== undefined ? { forkedFromRunId: meta.forkedFromRunId } : {}),
+			...(meta?.continuationKind ? { continuationKind: meta.continuationKind } : {}),
 		});
 		this.notify();
 		return id;
@@ -422,17 +457,33 @@ export class MonitorStore {
 	setStatus(id: number, status: RunStatus): void {
 		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 now = Date.now();
 		run.status = status;
-		if (status === "running" || status === "steering" || status === "interrupting") {
-			if (run.startedAt === undefined) run.startedAt = Date.now();
-			// 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;
-		} else if ((status === "parked" || status === "done" || status === "failed") && run.endedAt === undefined) {
-			run.endedAt = Date.now();
+		if (isExecuting && !wasExecuting) {
+			run.startedAt ??= now;
+			run.activeSince = now;
+			run.endedAt = undefined;
+		} else if (!isExecuting && wasExecuting && run.activeSince !== undefined) {
+			run.elapsedMs += Math.max(0, now - run.activeSince);
+			run.activeSince = undefined;
 		}
+		if ((status === "parked" || status === "done" || status === "failed") && run.endedAt === undefined) {
+			run.endedAt = now;
+		}
+		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;
 		this.notify();
 	}
+
 	setUsage(id: number, usage: UsageStats, model?: string): void {
 		const run = this.find(id);
 		if (!run) return;
@@ -503,26 +554,38 @@ export class MonitorStore {
 		this.notify();
 	}
 
-	/** Reflect the currently owned internal stage when a managed parent is parked
-	 * or inspected between children; the stable id and original task stay intact. */
-	setAgent(id: number, agent: string): void {
+	/** Update the objective shown for a queued retarget or resumed generation. */
+	setTask(id: number, task: string): void {
 		const run = this.find(id);
 		if (!run) return;
-		run.agent = agent;
+		run.task = task;
+		run.label = runLabel(task);
 		this.notify();
 	}
 
-	/** Update the objective shown for a queued retarget or resumed generation. */
-	setTask(id: number, task: string): void {
+	setContinuationKind(id: number, kind: ContinuationKind): void {
 		const run = this.find(id);
 		if (!run) return;
-		run.task = task;
-		run.label = runLabel(task);
+		run.continuationKind = kind;
 		this.notify();
 	}
 
-	/** Reuse a stable logical run id for a resumed generation. */
-	restartRun(id: number, agent: string, task: string, model?: string, thinking?: string, isolation?: IsolationMode): void {
+	getElapsedMs(id: number, now: number = Date.now()): number | undefined {
+		const run = this.find(id);
+		return run ? elapsedMilliseconds(run, now) : undefined;
+	}
+
+	/** Reuse a stable logical run id for a resumed generation without discarding
+	 * active time accumulated by earlier generations. */
+	restartRun(
+		id: number,
+		agent: string,
+		task: string,
+		model?: string,
+		thinking?: string,
+		isolation?: IsolationMode,
+		meta?: { elapsedMs?: number; continuationKind?: ContinuationKind },
+	): void {
 		const run = this.find(id);
 		if (!run) {
 			this.runs.push({
@@ -535,6 +598,8 @@ export class MonitorStore {
 				...(isolation ? { isolation, integrationStatus: isolation === "worktree" ? "pending" as const : undefined } : {}),
 				status: "queued",
 				usage: emptyUsage(),
+				elapsedMs: meta?.elapsedMs ?? 0,
+				continuationKind: meta?.continuationKind,
 			});
 			this.notify();
 			return;
@@ -549,8 +614,11 @@ export class MonitorStore {
 		run.status = "queued";
 		run.usage = emptyUsage();
 		run.activity = undefined;
-		run.startedAt = undefined;
+		run.managedWorkflow = undefined;
+		run.activeSince = undefined;
 		run.endedAt = undefined;
+		run.elapsedMs = Math.max(run.elapsedMs, meta?.elapsedMs ?? 0);
+		run.continuationKind = meta?.continuationKind;
 		this.notify();
 	}
 
@@ -589,12 +657,14 @@ export class MonitorStore {
 
 	summarize(run: RunView): string {
 		const usage = formatUsageCompact(run.usage);
-		const parts = [run.agent];
+		const parts = [run.managedWorkflow ? `${run.agent} workflow` : run.agent];
+		const continuation = continuationLabel(run.continuationKind, run.forkedFromRunId);
+		if (continuation) parts.push(continuation);
 		if (run.relationLabel) parts.push(run.relationLabel);
-		if (run.model) parts.push(run.model);
-		if (run.thinking) parts.push(`thinking ${run.thinking}`);
+		if (!run.managedWorkflow && run.model) parts.push(run.model);
+		if (!run.managedWorkflow && run.thinking) parts.push(`thinking ${run.thinking}`);
 		if (run.isolation === "worktree") parts.push(`worktree ${run.integrationStatus ?? "active"}`);
-		if (usage) parts.push(usage);
+		if (!run.managedWorkflow && usage) parts.push(usage);
 		const elapsed = formatElapsed(run);
 		if (elapsed) parts.push(elapsed);
 		return parts.join(" · ");

package/src/prompt.ts

@@ -34,8 +34,8 @@ export function buildDelegationDirective(
 		...(hasDocumenter ? ["documenter"] : []),
 	];
 	const automaticWriterRoute = [
-		...(hasDocumenter ? ["documenter"] : []),
 		...(hasReviewer ? ["reviewer"] : []),
+		...(hasDocumenter ? ["documenter"] : []),
 	].join(" → ");
 	const namedWorktreeTargets = [
 		...(hasWorker ? ["worker"] : []),
@@ -65,7 +65,7 @@ export function buildDelegationDirective(
 			: []),
 		...(hasDocumenter
 			? [
-				`Use \`documenter\` directly for explicit whole-codebase maintenance or standalone documentation work.${codeWriterNames.length > 0 ? ` Successful ${codeWriterNames.join("/")} runs already auto-sync the actual diff; never dispatch a duplicate.` : ""} Zero edits is valid and broad mode is never inferred. It changes docs/comments only and never runtime behavior, versions, release state, or ${hasReviewer ? "the final reviewer gate" : "direct final verification"}.`,
+				`Use \`documenter\` directly for explicit whole-codebase maintenance or standalone documentation work.${codeWriterNames.length > 0 ? ` Successful ${codeWriterNames.join("/")} runs already auto-sync the actual diff once after the review gate; never dispatch a duplicate.` : ""} Zero edits is valid and broad mode is never inferred. It changes docs/comments only and never runtime behavior, versions, or release state.`,
 			]
 			: []),
 		...(hasReviewer
@@ -103,7 +103,7 @@ export function buildDelegationDirective(
 			? [
 				...(hasDocumenter
 					? [
-						`A direct REVIEW_PASS is preliminary: runtime runs documenter on the pending diff, then a fresh reviewer. A direct REVIEW_FAIL ${autoFixEnabled ? "keeps auto-fix; maxFixRounds limits worker fixes only, not initial docs/review." : "cannot start fixes while worker/fix rounds are disabled."}`,
+						`A direct REVIEW_PASS is final for code: runtime runs the final documentation sync once and delivers. A direct REVIEW_FAIL ${autoFixEnabled ? "keeps auto-fix; maxFixRounds limits worker fixes only, not the final documentation sync." : "cannot start fixes while worker/fix rounds are disabled."}`,
 					]
 					: []),
 				"Resolve every gate finding; do not bypass the configured auto-fix/re-review cap. A reviewer report without a standalone VERDICT is advisory and cannot trigger writes.",

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 } from "./agents.ts";
+import { SUBAGENT_TOOL_NAMES, type AgentConfig } from "./agents.ts";
 import type { ThinkingLevel } from "./config.ts";
 import type { IsolationMode, WorktreeFinalizationStatus } from "./worktree.ts";
 
@@ -469,7 +469,7 @@ export interface RunRpcAttemptOptions {
 /** Run one persistent RPC child until a stable `agent_settled` or control action. */
 export async function runRpcAgentAttempt(options: RunRpcAttemptOptions): Promise<RpcSingleResult> {
 	const { agent, agentName, task, thinkingLevel, idleTimeoutMs, signal, onLive, control } = options;
-	const args: string[] = ["--mode", "rpc", "--exclude-tools", "subagent,subagent_control"];
+	const args: string[] = ["--mode", "rpc", "--exclude-tools", SUBAGENT_TOOL_NAMES.join(",")];
 	if (options.sessionDir && options.sessionId) {
 		args.push("--session-dir", options.sessionDir);
 		args.push(sessionExists(options.sessionDir, options.sessionId) ? "--session" : "--session-id", options.sessionId);
@@ -478,7 +478,10 @@ export async function runRpcAgentAttempt(options: RunRpcAttemptOptions): Promise
 	}
 	if (agent.model) args.push("--model", agent.model);
 	args.push("--thinking", thinkingLevel);
-	if (agent.tools && agent.tools.length > 0) args.push("--tools", agent.tools.join(","));
+	if (agent.tools) {
+		if (agent.tools.length > 0) args.push("--tools", agent.tools.join(","));
+		else args.push("--no-tools");
+	}
 
 	let tmpPromptDir: string | null = null;
 	let tmpPromptPath: string | null = null;

package/src/runtime.ts

@@ -67,6 +67,8 @@ export interface SubagentThread {
 	lifecycleOperation?: ThreadLifecycleOperation;
 	sessionId?: string;
 	sessionDir?: string;
+	/** Active execution time accumulated across retained resume generations. */
+	elapsedMs: number;
 	/** Most recent generation result, retained for parked destructive-stop output. */
 	lastResult?: SingleResult;
 	/** A destructive stop retires context even if the active child settles later. */
@@ -92,6 +94,8 @@ export interface SubagentThread {
 export interface SubagentRuntime {
 	configPath: string;
 	backgroundQueue: BackgroundTaskQueue;
+	/** Live parent tool names from ExtensionAPI, read again for each child launch. */
+	getActiveTools: () => string[];
 	/** False after session_shutdown; guards delivery and queue work. */
 	sessionActive: boolean;
 	/** Deliver a batch of completion messages to the main window, waking it only
@@ -128,6 +132,7 @@ export function createRuntime(pi: ExtensionAPI, configPath: string): SubagentRun
 	const runtime: SubagentRuntime = {
 		configPath,
 		backgroundQueue,
+		getActiveTools: () => pi.getActiveTools(),
 		sessionActive: true,
 		sendCompletionGroup: (items) => {
 			if (!runtime.sessionActive || items.length === 0) return;