@ferris1225/pi-subagents 4.1.7 → 4.1.9

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":

package/src/prompt.ts

@@ -13,7 +13,6 @@ function bullets(lines: readonly string[]): string {
 
 export function buildDelegationDirective(
 	agents: AgentConfig[],
-	options: { maxFixRounds?: number } = {},
 ): string {
 	if (agents.length === 0) return "";
 
@@ -24,7 +23,7 @@ export function buildDelegationDirective(
 	const hasDocumenter = agents.some((agent) => agent.name === "documenter");
 	const hasReviewer = agents.some((agent) => agent.name === "reviewer");
 	const hasMultiple = agents.length > 1;
-	const autoFixEnabled = hasWorker && (options.maxFixRounds ?? 1) > 0;
+	const autoFixEnabled = hasWorker;
 	const codeWriterNames = [
 		...(hasWorker ? ["worker"] : []),
 		...(hasCleaner ? ["cleaner"] : []),
@@ -62,21 +61,21 @@ export function buildDelegationDirective(
 			: []),
 		...(hasCleaner
 			? [
-				`Use \`cleaner\` only as the separate evidence-first entry for user-authorized cleanup, removal, simplification, duplicate-code consolidation, or maintenance; never substitute it for \`worker\`. It applies every safe proven in-scope cut without item-by-item approval. Generic or read-only audit, review, code-health, plan, or cleanup-candidate assessment goes to ${hasReviewer ? "`reviewer`" : "direct main-context inspection because `reviewer` is disabled"}. Never dispatch cleaner by PR count or as the pre-commit gate.`,
+				`Use \`cleaner\` only for user-authorized cleanup, removal, simplification, or duplicate-code consolidation; it applies every safe proven in-scope cut without item-by-item approval. Read-only audits and code-health reviews go to ${hasReviewer ? "`reviewer`" : "the main context because `reviewer` is disabled"}. Never dispatch cleaner by PR count or as the pre-commit gate.`,
 			]
 			: []),
 		...(hasDocumenter
 			? [
-				`Use \`documenter\` directly only for explicit whole-codebase maintenance or standalone documentation/comment work; a top-level documenter delivers directly without an automatic reviewer.${codeWriterNames.length > 0 ? ` ${codeWriterNames.join("/")} must sync existing docs they directly affect; runtime runs documenter only after REVIEW_PASS with DOCUMENTATION: NEEDED or a missing marker, or as the reviewer-disabled fallback—never dispatch a duplicate.` : ""} It never changes runtime behavior, versions, or release state.`,
+				`Use \`documenter\` directly only for explicit whole-codebase or standalone documentation/comment work; a top-level documenter delivers without an automatic reviewer.${codeWriterNames.length > 0 ? ` ${codeWriterNames.join("/")} must sync existing docs they directly affect; runtime runs documenter only after REVIEW_PASS with DOCUMENTATION: NEEDED or a missing marker, or as the reviewer-disabled fallback—never dispatch a duplicate.` : ""} It never changes runtime behavior, versions, or release state.`,
 			]
 			: []),
 		...(hasReviewer
 			? [
-				`Use \`reviewer\` for read-only assessments or a gate.${reviewedWriterNames.length > 0 ? ` Successful ${reviewedWriterNames.join("/")} runs already get one fresh read-only reviewer gate, independent of the writer.` : ""} Advisory output has no VERDICT and cannot authorize follow-up edits${hasDocumenter ? "; gates classify docs separately for the enabled documenter." : "."}`,
+				`Use \`reviewer\` for read-only assessments or a gate.${reviewedWriterNames.length > 0 ? ` Successful ${reviewedWriterNames.join("/")} runs already get one fresh read-only reviewer gate, independent of the writer.` : ""} Advisory output has no VERDICT and cannot authorize follow-up edits${hasDocumenter ? "; gates classify docs separately for the enabled documenter." : "."} Re-verifying your own fixes? Dispatch with \`advisory: true\`: the report returns to you and never starts the auto-fix chain.`,
 			]
 			: []),
 		"Brief each child with the complete goal, exact paths, constraints, and expected output; it has no conversation memory.",
-		"Children are leaf processes without delegation tools; use `subagent_control fork` on a parked/settled thread for an independent continuation.",
+		"Children are leaf processes without delegation tools; use `subagent_control resume` on a parked/settled thread to continue its retained context.",
 		...(hasMultiple
 			? [
 				"Dispatch independent work in one `tasks` array and let the resumed main agent start dependent work only after prerequisites finish.",
@@ -101,10 +100,10 @@ export function buildDelegationDirective(
 			? [
 				...(hasDocumenter
 					? [
-						`A direct REVIEW_PASS with DOCUMENTATION: CLEAN delivers immediately; NEEDED or a missing marker runs one documentation sync. A direct REVIEW_FAIL ${autoFixEnabled ? "keeps bounded worker/reviewer auto-fix, with docs considered only after its terminal REVIEW_PASS." : "cannot start fixes while worker/fix rounds are disabled."}`,
+						`A direct REVIEW_PASS with DOCUMENTATION: CLEAN delivers immediately; NEEDED or a missing marker runs one documentation sync. A direct REVIEW_FAIL ${autoFixEnabled ? "keeps bounded worker/reviewer auto-fix, with docs considered only after its terminal REVIEW_PASS." : "cannot start fixes while worker is 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.",
+				"Resolve every gate finding; do not bypass the auto-fix/re-review cap. A reviewer report without a standalone VERDICT is advisory and cannot trigger writes.",
 				"Use multi-model cross-review only when explicitly requested or for genuinely high-risk security, unsafe/FFI, persistence-migration, or concurrency changes.",
 			]
 			: []),

package/src/rpc-run.ts

@@ -1,7 +1,7 @@
 /*
  * Persistent pi RPC child transport for one logical sub-agent generation.
  *
- * A child stays alive across prompt/steer/abort/retarget operations and speaks
+ * A child stays alive across prompt/abort operations and speaks
  * strict LF-delimited JSONL. The process is terminated only after the logical
  * run settles, is parked/stopped, or fails. Session files remain owned by the
  * parent runtime so a later generation can resume the same thread.
@@ -16,6 +16,7 @@ import { StringDecoder } from "node:string_decoder";
 import type { Message } from "@earendil-works/pi-ai";
 import { SUBAGENT_TOOL_NAMES, type AgentConfig } from "./agents.ts";
 import type { ThinkingLevel } from "./config.ts";
+import { writeTempOwnerMarker } from "./temp-hygiene.ts";
 import type { IsolationMode, WorktreeFinalizationStatus } from "./worktree.ts";
 
 export const DEPTH_ENV_VAR = "PI_SUBAGENT_DEPTH";
@@ -82,8 +83,6 @@ export interface RpcSingleResult {
 	sessionDir?: string;
 	/** Original task/project cwd used for result-artifact retention buckets. */
 	projectCwd?: string;
-	/** Internal disposition: dispatch suppresses completion delivery for parks. */
-	parked?: boolean;
 	/** Stable logical run id assigned by dispatch (also present on queued results). */
 	runId?: number;
 	/** Filesystem isolation selected for this logical thread. */
@@ -95,15 +94,13 @@ export interface RpcSingleResult {
 	/** Retained only when integration/cleanup failed; never contains patch data. */
 	integrationWorktreePath?: string;
 	integrationPatchPath?: string;
-	/** Session-fork relationships between stable logical run ids. */
-	forkedFromRunId?: number;
-	forkChildRunIds?: number[];
 }
 
 export type SubagentLiveEvent =
-	| { kind: "status"; status: "queued" | "running" | "steering" | "interrupting" | "parked" | "done" | "failed" }
+	| { kind: "status"; status: "queued" | "running" | "interrupting" | "done" | "failed" }
 	| { kind: "model"; model?: string; thinking?: ThinkingLevel; fallbackFrom?: string }
 	| { kind: "usage"; usage: UsageStats; model?: string }
+	| { kind: "session"; sessionId: string; sessionDir: string }
 	| { kind: "tool_start"; toolCallId?: string; toolName: string; args: unknown }
 	| { kind: "tool_end"; toolCallId?: string; toolName: string; isError: boolean }
 	| { kind: "thinking" }
@@ -113,17 +110,12 @@ export type RpcControlPhase =
 	| "queued"
 	| "starting"
 	| "running"
-	| "steering"
 	| "interrupting"
 	| "retrying"
-	| "parked"
 	| "settled"
 	| "stopped";
 
 interface AttemptControl {
-	steer(instruction: string): Promise<void>;
-	retarget(objective: string): Promise<void>;
-	park(): Promise<void>;
 	stop(reason?: string): Promise<void>;
 }
 
@@ -138,9 +130,9 @@ export class RpcRunControl {
 	private attempt?: { token: number; control: AttemptControl };
 	private nextToken = 1;
 	private serial: Promise<void> = Promise.resolve();
-	private parkRequested = false;
 	private stopRequested = false;
 	private stopMessage = "Subagent was aborted";
+	private childPids = new Set<number>();
 
 	constructor(
 		objective: string,
@@ -158,10 +150,6 @@ export class RpcRunControl {
 		return this.phase;
 	}
 
-	isParkRequested(): boolean {
-		return this.parkRequested;
-	}
-
 	isStopRequested(): boolean {
 		return this.stopRequested;
 	}
@@ -170,15 +158,15 @@ export class RpcRunControl {
 		return this.stopMessage;
 	}
 
-	/** Update a not-yet-started/retrying objective without launching a process. */
-	retargetPending(objective: string): void {
-		this.objective = objective;
+	/** Pids of every child process this generation spawned. Persisted with the
+	 * thread record so a later load can kill orphans that still hold the
+	 * retained session. */
+	noteChildPid(pid: number): void {
+		if (Number.isInteger(pid) && pid > 0) this.childPids.add(pid);
 	}
 
-	/** Mark queued/starting work for park without waiting on an RPC abort event. */
-	parkPending(): void {
-		this.parkRequested = true;
-		this.setPhase("parked");
+	getChildPids(): number[] {
+		return [...this.childPids];
 	}
 
 	markStarting(): void {
@@ -186,12 +174,12 @@ export class RpcRunControl {
 	}
 
 	markRetrying(): void {
-		if (!this.parkRequested && !this.stopRequested) this.setPhase("retrying");
+		if (!this.stopRequested) this.setPhase("retrying");
 	}
 
 	markSettled(): void {
 		this.attempt = undefined;
-		if (!this.parkRequested && !this.stopRequested) this.setPhase("settled");
+		if (!this.stopRequested) this.setPhase("settled");
 	}
 
 	/** Allocate an attempt token used to reject state updates from old children. */
@@ -212,32 +200,6 @@ export class RpcRunControl {
 		this.setPhase(phase);
 	}
 
-	async steer(instruction: string): Promise<void> {
-		return this.serialize(async () => {
-			const attempt = this.attempt?.control;
-			if (!attempt) throw new Error(`Thread is ${this.phase}; steering requires a running child.`);
-			await attempt.steer(instruction);
-		});
-	}
-
-	async retarget(objective: string): Promise<void> {
-		return this.serialize(async () => {
-			this.objective = objective;
-			const attempt = this.attempt?.control;
-			if (!attempt) return;
-			await attempt.retarget(objective);
-		});
-	}
-
-	async park(): Promise<void> {
-		return this.serialize(async () => {
-			this.parkRequested = true;
-			const attempt = this.attempt?.control;
-			if (attempt) await attempt.park();
-			this.setPhase("parked");
-		});
-	}
-
 	async stop(reason = "Subagent was aborted"): Promise<void> {
 		return this.serialize(async () => {
 			this.stopRequested = true;
@@ -369,6 +331,7 @@ export async function writeChildRetryPolicyExtension(
 	modelRef?: string,
 ): Promise<ChildRetryPolicyExtension> {
 	const dir = await mkdtemp(join(tmpdir(), "pi-subagents-policy-"));
+	writeTempOwnerMarker(dir);
 	const filePath = join(dir, "no-provider-retries.mjs");
 	const slash = modelRef?.indexOf("/") ?? -1;
 	const selectedProvider = slash > 0 ? modelRef!.slice(0, slash) : undefined;
@@ -398,6 +361,7 @@ export async function writeChildRetryPolicyExtension(
 
 async function writePromptToTempFile(agentName: string, prompt: string): Promise<{ dir: string; filePath: string }> {
 	const dir = await mkdtemp(join(tmpdir(), "pi-subagents-"));
+	writeTempOwnerMarker(dir);
 	const safeName = agentName.replace(/[^\w.-]+/g, "_");
 	const filePath = join(dir, `prompt-${safeName}.md`);
 	try {
@@ -541,11 +505,6 @@ export async function runRpcAgentAttempt(options: RunRpcAttemptOptions): Promise
 	let abortSettlement: Deferred<void> | undefined;
 	let initialPromptResolved = false;
 	const initialPrompt = deferred<{ accepted: boolean; error?: Error }>();
-	let continuationCommandInFlight = false;
-	let continuationAccepted = false;
-	let continuationTurnStarted = false;
-	let continuationTurnCompleted = false;
-	let deferredAgentSettlement = false;
 	const pendingRequests = new Map<string, PendingRequest>();
 	const outcome = deferred<void>();
 	const processClosed = deferred<void>();
@@ -562,13 +521,8 @@ export async function runRpcAgentAttempt(options: RunRpcAttemptOptions): Promise
 
 	const setAttemptPhase = (phase: RpcControlPhase): void => {
 		if (attemptToken !== undefined) control?.updateAttemptPhase(attemptToken, phase);
-		switch (phase) {
-			case "running":
-			case "steering":
-			case "interrupting":
-			case "parked":
-				emit({ kind: "status", status: phase });
-				break;
+		if (phase === "running" || phase === "interrupting") {
+			emit({ kind: "status", status: phase });
 		}
 	};
 
@@ -685,142 +639,6 @@ export async function runRpcAgentAttempt(options: RunRpcAttemptOptions): Promise
 	};
 
 	const attemptControl: AttemptControl = {
-		async steer(instruction: string): Promise<void> {
-			if (finished) throw new Error("Thread already settled before it could be steered.");
-			const acceptance = await initialPrompt.promise;
-			if (!acceptance.accepted) throw acceptance.error ?? new Error("The initial prompt was rejected.");
-			setAttemptPhase("steering");
-			// Prompt+streamingBehavior performs the active→steer / idle→new-prompt
-			// choice atomically inside Pi. Hold any old agent_settled event until this
-			// command is accepted so an extension-handler race cannot drop the steer.
-			continuationCommandInFlight = true;
-			continuationAccepted = false;
-			continuationTurnStarted = false;
-			continuationTurnCompleted = false;
-			deferredAgentSettlement = false;
-			try {
-				await send({ type: "prompt", message: asPlainTextRpcPrompt(instruction), streamingBehavior: "steer" });
-				continuationAccepted = true;
-				if (deferredAgentSettlement && !continuationTurnStarted) {
-					// A handled input can succeed without starting a turn. Confirm the
-					// server is idle before consuming the delayed settlement.
-					const state = await send({ type: "get_state" }).catch(() => undefined);
-					if ((state?.data as { isStreaming?: unknown } | undefined)?.isStreaming === false) {
-						continuationAccepted = false;
-						deferredAgentSettlement = false;
-						settleRun();
-					}
-				}
-			} catch (error) {
-				continuationAccepted = false;
-				if (deferredAgentSettlement) {
-					deferredAgentSettlement = false;
-					settleRun();
-				}
-				throw error;
-			} finally {
-				continuationCommandInFlight = false;
-			}
-			// Remain visibly steering until the next turn starts.
-		},
-		async retarget(objective: string): Promise<void> {
-			if (finished) throw new Error("Thread already settled before it could be retargeted.");
-			setAttemptPhase("interrupting");
-			result.task = objective;
-			const accepted = await abortAcceptedPrompt();
-			if (!accepted) {
-				if (!closed) await processClosed.promise;
-				return;
-			}
-			if (finished || closed) throw new Error("Thread exited while retargeting.");
-			// The aborted assistant message remains in the retained session/history,
-			// but it must not classify the replacement objective as aborted.
-			result.stopReason = undefined;
-			result.errorMessage = undefined;
-			result.exitCode = 0;
-			// Tool failures belong to the abandoned objective. Keep them in session
-			// history, but do not classify a successful replacement as failed.
-			result.failedTools = undefined;
-			try {
-				await send({ type: "prompt", message: asPlainTextRpcPrompt(objective) });
-				setAttemptPhase("running");
-			} catch (error) {
-				const promptError = error instanceof Error ? error : new Error(String(error));
-				result.exitCode = 1;
-				result.stopReason = "error";
-				result.errorMessage = `Replacement prompt was rejected: ${promptError.message}`;
-				if (promptError instanceof RpcCommandRejectedError) result.rpcPromptRejected = true;
-				finish();
-				terminate();
-				if (!closed) await processClosed.promise;
-				throw promptError;
-			}
-		},
-		async park(): Promise<void> {
-			const markParked = (): void => {
-				result.parked = true;
-				result.exitCode = 0;
-				result.stopReason = undefined;
-				result.errorMessage = undefined;
-				result.rpcStartupFailed = undefined;
-				result.rpcPromptRejected = undefined;
-			};
-			if (finished) {
-				if (!closed) await processClosed.promise;
-				if (result.parked) return;
-				// Handshake/startup already tore the child down. Convert a pre-prompt
-				// settlement into a park instead of throwing past the control tool.
-				if (!result.rpcPromptAccepted) {
-					markParked();
-					return;
-				}
-				throw new Error("Thread already settled before it could be parked.");
-			}
-			setAttemptPhase("interrupting");
-			if (!initialPromptResolved) {
-				const parked = new Error("Run was parked before its initial prompt.");
-				resolveInitialPrompt(false, parked);
-				rejectPending(parked);
-				markParked();
-				setAttemptPhase("parked");
-				finish();
-				terminate();
-				if (!closed) await processClosed.promise;
-				return;
-			}
-			// Bound the abort settlement exactly like stop: a child that never
-			// settles after abort must not hold the control operation forever.
-			let parkTimer: ReturnType<typeof setTimeout> | undefined;
-			let parkTimedOut = false;
-			const parkDeadline = new Promise<boolean>((resolve) => {
-				parkTimer = setTimeout(() => {
-					parkTimedOut = true;
-					resolve(false);
-				}, RPC_ABORT_SETTLE_TIMEOUT_MS);
-				if (typeof parkTimer.unref === "function") parkTimer.unref();
-			});
-			let accepted: boolean;
-			try {
-				accepted = await Promise.race([abortAcceptedPrompt(), parkDeadline]);
-			} catch {
-				/* a rejected abort still parks; termination below is the bounded fallback */
-				accepted = false;
-			} finally {
-				if (parkTimer) clearTimeout(parkTimer);
-			}
-			if (abortSettlement) {
-				const stable = abortSettlement;
-				abortSettlement = undefined;
-				stable.resolve();
-			}
-			if (!accepted && !parkTimedOut && !closed) await processClosed.promise;
-			if (finished && accepted) throw new Error("Thread exited while parking.");
-			markParked();
-			setAttemptPhase("parked");
-			finish();
-			terminate();
-			if (!closed) await processClosed.promise;
-		},
 		async stop(reason = "Subagent was aborted"): Promise<void> {
 			if (finished) {
 				if (!closed) await processClosed.promise;
@@ -862,6 +680,7 @@ export async function runRpcAgentAttempt(options: RunRpcAttemptOptions): Promise
 	};
 
 	if (attemptToken !== undefined) control?.attach(attemptToken, attemptControl);
+	if (proc.pid !== undefined) control?.noteChildPid(proc.pid);
 	control?.markStarting();
 
 	const processLine = (rawLine: string): void => {
@@ -929,15 +748,8 @@ export async function runRpcAgentAttempt(options: RunRpcAttemptOptions): Promise
 			emit({ kind: "status", status: "running" });
 		}
 		if (event.type === "turn_start") {
-			if (continuationCommandInFlight || continuationAccepted) {
-				continuationTurnStarted = true;
-			}
 			setAttemptPhase("running");
 		}
-		if (event.type === "turn_end" && continuationTurnStarted) {
-			continuationTurnCompleted = true;
-			deferredAgentSettlement = false;
-		}
 
 		if (event.type === "message_update") {
 			const type = event.assistantMessageEvent?.type;
@@ -998,18 +810,6 @@ export async function runRpcAgentAttempt(options: RunRpcAttemptOptions): Promise
 				stable.resolve();
 				return;
 			}
-			if ((continuationCommandInFlight || continuationAccepted) && !continuationTurnCompleted) {
-				// Pi may emit an old settlement while an extension handler is yielding
-				// and the atomic prompt command starts the continuation. Its successful
-				// response guarantees a new/queued turn, so defer this stale event until
-				// that continuation has completed a turn.
-				deferredAgentSettlement = true;
-				return;
-			}
-			continuationAccepted = false;
-			continuationTurnStarted = false;
-			continuationTurnCompleted = false;
-			deferredAgentSettlement = false;
 			settleRun();
 		}
 	};
@@ -1098,13 +898,7 @@ export async function runRpcAgentAttempt(options: RunRpcAttemptOptions): Promise
 	}
 
 	try {
-		if (control?.isParkRequested()) {
-			resolveInitialPrompt(false, new Error("Run was parked before its initial prompt."));
-			result.parked = true;
-			result.exitCode = 0;
-			finish();
-			terminate();
-		} else if (control?.isStopRequested()) {
+		if (control?.isStopRequested()) {
 			resolveInitialPrompt(false, new Error("Run was stopped before its initial prompt."));
 			await attemptControl.stop();
 		} else {
@@ -1123,13 +917,13 @@ export async function runRpcAgentAttempt(options: RunRpcAttemptOptions): Promise
 				await send({ type: "get_state" }, readyTimeoutMs);
 			} catch (error) {
 				const handshakeError = error instanceof Error ? error : new Error(String(error));
-				if (!control?.isParkRequested() && !control?.isStopRequested()) {
+				if (!control?.isStopRequested()) {
 					failBeforePrompt(handshakeError, true);
 				} else {
 					resolveInitialPrompt(false, handshakeError);
 				}
 			}
-			if (!finished && !initialPromptResolved && !control?.isParkRequested() && !control?.isStopRequested()) {
+			if (!finished && !initialPromptResolved && !control?.isStopRequested()) {
 				// Pi starts the agent immediately after prompt preflight, before its
 				// success response necessarily reaches stdout. From this point on, a
 				// missing ACK is ambiguous and must never be recovered by replay.