lsd-pi 1.3.2 → 1.3.7

package/src/resources/extensions/browser-tools/tools/state-persistence.ts

@@ -3,93 +3,36 @@ import { Type } from "@sinclair/typebox";
 import type { ToolDeps } from "../state.js";
 
 /**
- * State persistence tools — save/restore cookies, localStorage, sessionStorage.
+ * State persistence — save/restore cookies, localStorage, sessionStorage.
  */
 
 const STATE_DIR = ".gsd/browser-state";
 
 export function registerStatePersistenceTools(pi: ExtensionAPI, deps: ToolDeps): void {
-	// -------------------------------------------------------------------------
-	// browser_save_state
-	// -------------------------------------------------------------------------
 	pi.registerTool({
-		name: "browser_save_state",
-		label: "Browser Save State",
+		name: "browser_state",
+		label: "Browser State",
 		description:
-			"Save cookies, localStorage, and sessionStorage to disk so authenticated sessions survive browser restarts. " +
-			"State files are written to .gsd/browser-state/ and should be gitignored (may contain auth tokens). " +
-			"Never displays secret values in output.",
+			"Save or restore browser state (cookies, localStorage, sessionStorage) to persist sessions across browser restarts. " +
+			"State files written to .gsd/browser-state/ (should be gitignored).",
 		parameters: Type.Object({
-			name: Type.Optional(
-				Type.String({ description: "Name for the state file (default: 'default'). Used as the filename stem." }),
-			),
+			action: Type.Union([
+				Type.Literal("save"),
+				Type.Literal("restore"),
+			], { description: "'save' — persist current state, 'restore' — load previously saved state" }),
+			name: Type.Optional(Type.String({ description: "State file name (default: 'default'). Used as filename stem." })),
 		}),
 
 		async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
 			try {
-				const { context: ctx, page: p } = await deps.ensureBrowser();
-				const name = deps.sanitizeArtifactName(params.name ?? "default", "default");
-
-				const { mkdir, writeFile } = await import("node:fs/promises");
-				const path = await import("node:path");
-				const stateDir = path.resolve(process.cwd(), STATE_DIR);
-				await mkdir(stateDir, { recursive: true });
-
-				// 1. Playwright storageState: cookies + localStorage
-				const storageState = await ctx.storageState();
-
-				// 2. sessionStorage: must be extracted per-origin via page.evaluate
-				const sessionStorageData: Record<string, Record<string, string>> = {};
-				try {
-					const origin = new URL(p.url()).origin;
-					const ssData = await p.evaluate(() => {
-						const data: Record<string, string> = {};
-						for (let i = 0; i < sessionStorage.length; i++) {
-							const key = sessionStorage.key(i);
-							if (key) data[key] = sessionStorage.getItem(key) ?? "";
-						}
-						return data;
-					});
-					if (Object.keys(ssData).length > 0) {
-						sessionStorageData[origin] = ssData;
-					}
-				} catch {
-					// Page may not have a valid origin (about:blank, etc.)
+				if (params.action === "save") {
+					return await saveState(deps, params.name ?? "default");
+				} else {
+					return await restoreState(deps, params.name ?? "default");
 				}
-
-				const combined = {
-					storageState,
-					sessionStorage: sessionStorageData,
-					savedAt: new Date().toISOString(),
-					url: p.url(),
-				};
-
-				const filePath = path.join(stateDir, `${name}.json`);
-				await writeFile(filePath, JSON.stringify(combined, null, 2));
-
-				// Ensure .gitignore covers the state dir
-				const gitignorePath = path.resolve(process.cwd(), STATE_DIR, ".gitignore");
-				await writeFile(gitignorePath, "*\n!.gitignore\n").catch(() => { /* best-effort — .gitignore may already exist or dir may be read-only */ });
-
-				const cookieCount = storageState.cookies?.length ?? 0;
-				const localStorageOrigins = storageState.origins?.length ?? 0;
-				const sessionStorageOrigins = Object.keys(sessionStorageData).length;
-
-				return {
-					content: [{
-						type: "text",
-						text: `State saved: ${filePath}\nCookies: ${cookieCount}\nlocalStorage origins: ${localStorageOrigins}\nsessionStorage origins: ${sessionStorageOrigins}`,
-					}],
-					details: {
-						path: filePath,
-						cookieCount,
-						localStorageOrigins,
-						sessionStorageOrigins,
-					},
-				};
 			} catch (err: any) {
 				return {
-					content: [{ type: "text", text: `Save state failed: ${err.message}` }],
+					content: [{ type: "text" as const, text: `State '${params.action}' failed: ${err.message}` }],
 					details: { error: err.message },
 					isError: true,
 				};
@@ -97,106 +40,85 @@ export function registerStatePersistenceTools(pi: ExtensionAPI, deps: ToolDeps):
 		},
 	});
 
-	// -------------------------------------------------------------------------
-	// browser_restore_state
-	// -------------------------------------------------------------------------
-	pi.registerTool({
-		name: "browser_restore_state",
-		label: "Browser Restore State",
-		description:
-			"Restore cookies, localStorage, and sessionStorage from a previously saved state file. " +
-			"Injects cookies via context.addCookies() and storage via page.evaluate(). " +
-			"For full fidelity, restore before navigating to the target site.",
-		parameters: Type.Object({
-			name: Type.Optional(
-				Type.String({ description: "Name of the state file to restore (default: 'default')." }),
-			),
-		}),
-
-		async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
-			try {
-				const { context: ctx, page: p } = await deps.ensureBrowser();
-				const name = deps.sanitizeArtifactName(params.name ?? "default", "default");
-
-				const { readFile } = await import("node:fs/promises");
-				const path = await import("node:path");
-				const filePath = path.join(process.cwd(), STATE_DIR, `${name}.json`);
-
-				let raw: string;
-				try {
-					raw = await readFile(filePath, "utf-8");
-				} catch {
-					return {
-						content: [{ type: "text", text: `State file not found: ${filePath}` }],
-						details: { error: "file_not_found", path: filePath },
-						isError: true,
-					};
-				}
-
-				const combined = JSON.parse(raw);
-				const storageState = combined.storageState;
-				const sessionStorageData: Record<string, Record<string, string>> = combined.sessionStorage ?? {};
-
-				// 1. Restore cookies
-				let cookieCount = 0;
-				if (storageState?.cookies?.length) {
-					await ctx.addCookies(storageState.cookies);
-					cookieCount = storageState.cookies.length;
-				}
-
-				// 2. Restore localStorage via page.evaluate
-				let localStorageOrigins = 0;
-				if (storageState?.origins?.length) {
-					for (const origin of storageState.origins) {
-						try {
-							await p.evaluate((items: Array<{ name: string; value: string }>) => {
-								for (const { name, value } of items) {
-									localStorage.setItem(name, value);
-								}
-							}, origin.localStorage ?? []);
-							localStorageOrigins++;
-						} catch {
-							// Origin mismatch — localStorage can only be set on matching origin
-						}
-					}
+	async function saveState(deps: ToolDeps, name: string) {
+		const { context: ctx, page: p } = await deps.ensureBrowser();
+		name = deps.sanitizeArtifactName(name, "default");
+		const { mkdir, writeFile } = await import("node:fs/promises");
+		const path = await import("node:path");
+		const stateDir = path.resolve(process.cwd(), STATE_DIR);
+		await mkdir(stateDir, { recursive: true });
+
+		const storageState = await ctx.storageState();
+		const sessionStorageData: Record<string, Record<string, string>> = {};
+		try {
+			const origin = new URL(p.url()).origin;
+			const ssData = await p.evaluate(() => {
+				const data: Record<string, string> = {};
+				for (let i = 0; i < sessionStorage.length; i++) {
+					const key = sessionStorage.key(i);
+					if (key) data[key] = sessionStorage.getItem(key) ?? "";
 				}
-
-				// 3. Restore sessionStorage via page.evaluate
-				let sessionStorageOrigins = 0;
-				for (const [_origin, data] of Object.entries(sessionStorageData)) {
-					try {
-						await p.evaluate((items: Record<string, string>) => {
-							for (const [key, value] of Object.entries(items)) {
-								sessionStorage.setItem(key, value);
-							}
-						}, data);
-						sessionStorageOrigins++;
-					} catch {
-						// Origin mismatch
-					}
-				}
-
-				return {
-					content: [{
-						type: "text",
-						text: `State restored from: ${filePath}\nCookies: ${cookieCount}\nlocalStorage origins: ${localStorageOrigins}\nsessionStorage origins: ${sessionStorageOrigins}\nSaved at: ${combined.savedAt ?? "unknown"}`,
-					}],
-					details: {
-						path: filePath,
-						cookieCount,
-						localStorageOrigins,
-						sessionStorageOrigins,
-						savedAt: combined.savedAt,
-						savedUrl: combined.url,
-					},
-				};
-			} catch (err: any) {
-				return {
-					content: [{ type: "text", text: `Restore state failed: ${err.message}` }],
-					details: { error: err.message },
-					isError: true,
-				};
+				return data;
+			});
+			if (Object.keys(ssData).length > 0) sessionStorageData[origin] = ssData;
+		} catch { /* Page may not have a valid origin */ }
+
+		const combined = { storageState, sessionStorage: sessionStorageData, savedAt: new Date().toISOString(), url: p.url() };
+		const filePath = path.join(stateDir, `${name}.json`);
+		await writeFile(filePath, JSON.stringify(combined, null, 2));
+
+		const gitignorePath = path.resolve(process.cwd(), STATE_DIR, ".gitignore");
+		await writeFile(gitignorePath, "*\n!.gitignore\n").catch(() => { /* best-effort */ });
+
+		return {
+			content: [{ type: "text" as const, text: `State saved: ${filePath}\nCookies: ${storageState.cookies?.length ?? 0}\nlocalStorage origins: ${storageState.origins?.length ?? 0}\nsessionStorage origins: ${Object.keys(sessionStorageData).length}` }],
+			details: { path: filePath, cookieCount: storageState.cookies?.length ?? 0, localStorageOrigins: storageState.origins?.length ?? 0, sessionStorageOrigins: Object.keys(sessionStorageData).length },
+		};
+	}
+
+	async function restoreState(deps: ToolDeps, name: string) {
+		const { context: ctx, page: p } = await deps.ensureBrowser();
+		name = deps.sanitizeArtifactName(name, "default");
+		const { readFile } = await import("node:fs/promises");
+		const path = await import("node:path");
+		const filePath = path.join(process.cwd(), STATE_DIR, `${name}.json`);
+
+		let raw: string;
+		try { raw = await readFile(filePath, "utf-8"); } catch {
+			return { content: [{ type: "text" as const, text: `State file not found: ${filePath}` }], details: { error: "file_not_found", path: filePath }, isError: true };
+		}
+
+		const combined = JSON.parse(raw);
+		const storageState = combined.storageState;
+		const sessionStorageData: Record<string, Record<string, string>> = combined.sessionStorage ?? {};
+
+		let cookieCount = 0;
+		if (storageState?.cookies?.length) {
+			await ctx.addCookies(storageState.cookies);
+			cookieCount = storageState.cookies.length;
+		}
+
+		let localStorageOrigins = 0;
+		if (storageState?.origins?.length) {
+			for (const origin of storageState.origins) {
+				try {
+					await p.evaluate((items: Array<{ name: string; value: string }>) => { for (const { name, value } of items) localStorage.setItem(name, value); }, origin.localStorage ?? []);
+					localStorageOrigins++;
+				} catch { /* Origin mismatch */ }
 			}
-		},
-	});
+		}
+
+		let sessionStorageOrigins = 0;
+		for (const [_origin, data] of Object.entries(sessionStorageData)) {
+			try {
+				await p.evaluate((items: Record<string, string>) => { for (const [key, value] of Object.entries(items)) sessionStorage.setItem(key, value); }, data);
+				sessionStorageOrigins++;
+			} catch { /* Origin mismatch */ }
+		}
+
+		return {
+			content: [{ type: "text" as const, text: `State restored from: ${filePath}\nCookies: ${cookieCount}\nlocalStorage origins: ${localStorageOrigins}\nsessionStorage origins: ${sessionStorageOrigins}` }],
+			details: { path: filePath, cookieCount, localStorageOrigins, sessionStorageOrigins, savedAt: combined.savedAt, savedUrl: combined.url },
+		};
+	}
 }

package/src/resources/extensions/browser-tools/utils.ts

@@ -625,7 +625,7 @@ export function formatVersionedRef(version: number, key: string): string {
 }
 
 export function staleRefGuidance(refDisplay: string, reason: string): string {
-	return `Ref ${refDisplay} could not be resolved (${reason}). The ref is likely stale after DOM/navigation changes. Call browser_snapshot_refs again to refresh refs.`;
+	return `Ref ${refDisplay} could not be resolved (${reason}). The ref is likely stale after DOM/navigation changes. Call browser_ref with action='snapshot' to refresh refs.`;
 }
 
 // ---------------------------------------------------------------------------

package/src/resources/extensions/cache-timer/index.ts

@@ -22,6 +22,7 @@ const IS_CACHE_TIMER_FORCED_OFF = process.env.LSD_DISABLE_CACHE_TIMER === "1" ||
 
 // ANSI color codes for timer display
 const ANSI_RESET = "\x1b[0m";
+const ANSI_GREEN = "\x1b[32m";
 const ANSI_YELLOW = "\x1b[33m";
 const ANSI_RED = "\x1b[31m";
 
@@ -68,8 +69,8 @@ function formatElapsed(ms: number): string {
         // 5–10 minutes: yellow
         return `${ANSI_YELLOW}⏱ ${time}${ANSI_RESET}`;
     }
-    // Under 5 minutes: plain (inherits footer dim styling)
-    return `⏱ ${time}`;
+    // Under 5 minutes: green
+    return `${ANSI_GREEN}⏱ ${time}${ANSI_RESET}`;
 }
 
 export default function cacheTimerExtension(pi: ExtensionAPI) {

package/src/resources/extensions/slash-commands/extension-manifest.json

@@ -2,11 +2,11 @@
 	"id": "slash-commands",
 	"name": "Slash Commands",
 	"version": "1.0.0",
-	"description": "Bundled slash commands for context inspection, planning, and lazy tool search",
+	"description": "Bundled slash commands for context inspection, planning, fast mode, and lazy tool search",
 	"tier": "bundled",
 	"requires": { "platform": ">=2.29.0" },
 	"provides": {
-		"commands": ["audit", "clear", "context", "plan", "execute", "cancel-plan", "tools"],
+		"commands": ["audit", "clear", "context", "fast", "plan", "execute", "cancel-plan", "tools"],
 		"tools": ["tool_search", "tool_enable"],
 		"flags": ["plan"]
 	}

package/src/resources/extensions/slash-commands/fast.ts

@@ -0,0 +1,89 @@
+import { getAgentDir, SettingsManager, type ExtensionAPI, type ExtensionCommandContext } from "@gsd/pi-coding-agent";
+
+type FastCommandAction = "toggle" | "on" | "off" | "status" | "invalid";
+
+function parseFastCommandAction(args: string): FastCommandAction {
+	const normalized = args.trim().toLowerCase();
+	if (!normalized) return "toggle";
+	if (normalized === "on") return "on";
+	if (normalized === "off") return "off";
+	if (normalized === "status") return "status";
+	return "invalid";
+}
+
+function supportsFastMode(model: ExtensionCommandContext["model"]): boolean {
+	if (!model) return false;
+	if (model.api === "openai-codex-responses") return true;
+	if (model.api !== "openai-responses") return false;
+	if (model.provider !== "openai") return false;
+	return model.capabilities?.supportsServiceTier === true;
+}
+
+function getModelLabel(model: ExtensionCommandContext["model"]): string {
+	if (!model) return "no active model";
+	return `${model.provider}/${model.id}`;
+}
+
+function getSettingsManager(): SettingsManager {
+	return SettingsManager.create(process.cwd(), getAgentDir());
+}
+
+export const __testing = {
+	parseFastCommandAction,
+	supportsFastMode,
+};
+
+export default function fastCommand(pi: ExtensionAPI) {
+	pi.registerCommand("fast", {
+		description: "Toggle fast mode for OpenAI/Codex models (service_tier=priority)",
+		getArgumentCompletions(prefix: string) {
+			const options = [
+				{ value: "on", label: "on", description: "Enable fast mode" },
+				{ value: "off", label: "off", description: "Disable fast mode" },
+				{ value: "status", label: "status", description: "Show current fast-mode status" },
+			];
+			const query = prefix.trim().toLowerCase();
+			return options.filter((item) => item.value.startsWith(query));
+		},
+		async handler(args: string, ctx: ExtensionCommandContext) {
+			const settings = getSettingsManager() as SettingsManager & {
+				getFastMode: () => boolean;
+				setFastMode: (enabled: boolean) => void;
+			};
+			const current = settings.getFastMode();
+			const action = parseFastCommandAction(args);
+			const model = ctx.model;
+			const supported = supportsFastMode(model);
+			const modelLabel = getModelLabel(model);
+
+			if (action === "invalid") {
+				ctx.ui.notify("Usage: /fast [on|off|status]", "warning");
+				return;
+			}
+
+			if (action === "status") {
+				ctx.ui.notify(
+					`Fast mode: ${current ? "ON" : "OFF"} · model ${modelLabel} is ${supported ? "supported" : "unsupported"}`,
+					"info",
+				);
+				return;
+			}
+
+			const next = action === "toggle" ? !current : action === "on";
+			settings.setFastMode(next);
+
+			if (!supported) {
+				ctx.ui.notify(
+					`Fast mode: ${next ? "ON" : "OFF"} (saved). Current model ${modelLabel} does not support fast mode.`,
+					"warning",
+				);
+				return;
+			}
+
+			ctx.ui.notify(
+				`Fast mode: ${next ? "ON" : "OFF"} (saved). ${next ? "Requests will include service_tier=priority." : "Requests will omit service_tier."}`,
+				"info",
+			);
+		},
+	});
+}

package/src/resources/extensions/slash-commands/index.ts

@@ -2,6 +2,7 @@ import type { ExtensionAPI } from "@gsd/pi-coding-agent";
 import auditCommand from "./audit.js";
 import clearCommand from "./clear.js";
 import contextCommand from "./context.js";
+import fastCommand from "./fast.js";
 import initCommand from "./init.js";
 import planCommand from "./plan.js";
 import toolSearchExtension from "./tools.js";
@@ -10,6 +11,7 @@ export default function slashCommands(pi: ExtensionAPI) {
     auditCommand(pi);
     clearCommand(pi);
     contextCommand(pi);
+    fastCommand(pi);
     initCommand(pi);
     planCommand(pi);
     toolSearchExtension(pi);

package/src/resources/extensions/slash-commands/plan.ts

@@ -38,9 +38,8 @@ const BLOCKED_TOOLS = new Set([
   "async_bash",
   "bg_shell",
   "browser_navigate",
-  "browser_go_back",
-  "browser_go_forward",
-  "browser_reload",
+  "browser_pages",
+  "browser_frames",
   "browser_click",
   "browser_drag",
   "browser_type",
@@ -51,18 +50,13 @@ const BLOCKED_TOOLS = new Set([
   "browser_select_option",
   "browser_set_checked",
   "browser_set_viewport",
-  "browser_click_ref",
-  "browser_hover_ref",
-  "browser_fill_ref",
+  "browser_ref",
   "browser_act",
   "browser_batch",
   "browser_fill_form",
-  "browser_mock_route",
-  "browser_block_urls",
-  "browser_clear_routes",
+  "browser_network",
   "browser_emulate_device",
-  "browser_save_state",
-  "browser_restore_state",
+  "browser_state",
   "browser_generate_test",
   "browser_verify",
   "write",
@@ -80,6 +74,7 @@ const REVISE_LABEL = "Revise plan";
 const CANCEL_LABEL = "Cancel";
 const DEFAULT_PLAN_REVIEW_AGENT = "generic";
 const DEFAULT_PLAN_CODING_AGENT = "worker";
+const MIN_PLAN_CONFIDENCE = 8;
 
 type PlanApprovalStatus = "pending" | "approved" | "revising" | "cancelled";
 type RestorablePermissionMode = Exclude<PermissionMode, "plan">;
@@ -455,6 +450,9 @@ function buildPlanModeSystemPrompt(): string {
     "You are currently in plan mode.",
     "Investigate, clarify scope, and produce a persisted execution plan before making source changes.",
     "If requirements are ambiguous or constraints are missing, ask concise clarifying questions before drafting or saving a plan.",
+    `Before writing or updating a plan artifact, make sure your confidence is at least ${MIN_PLAN_CONFIDENCE}/10. If confidence is lower, investigate more or ask clarifying questions first.`,
+    "Include an explicit confidence line in every saved plan, for example: \"Confidence: 8/10\" or higher.",
+    "When adjusting an existing saved plan, prefer the edit tool for targeted changes. Rewrite the whole file only when the structure changes substantially or an exact edit is impractical.",
     "Do not modify source files or run side-effect commands while plan mode is active.",
     "Persist plan artifacts under .lsd/plan/.",
   ];
@@ -489,7 +487,7 @@ function buildApprovalActionInstructions(): string {
 
   return [
     "Ask for plan approval now via exactly one ask_user_questions tool call.",
-    `Question 1 (single-select) id \"${PLAN_APPROVAL_ACTION_QUESTION_ID}\": ask what to do next with the plan.`,
+    `Question 1 (single-select) id \"${PLAN_APPROVAL_ACTION_QUESTION_ID}\": ask what to do next with the plan. In the question text, tell the user that if they choose \"${REVISE_LABEL}\" they should type exact requested changes in the dialog notes field before submitting.`,
     `Question 1 options: ${APPROVE_LABEL}, ${REVIEW_LABEL}, ${REVISE_LABEL}. Put "${APPROVE_LABEL}" first with a "(Recommended)" suffix in the description, not in the label.`,
     `Do not include \"${CANCEL_LABEL}\" as an explicit option — if the user wants to cancel they should choose \"None of the above\" and type \"${CANCEL_LABEL}\" in the note.`,
     `Question 2 (single-select) id \"${PLAN_APPROVAL_PERMISSION_QUESTION_ID}\": ask which execution mode to use.`,
@@ -560,6 +558,25 @@ function buildReviewSteeringMessage(planPath: string, planMarkdown?: string): st
   return details.join("\n\n");
 }
 
+function buildRevisionSteeringMessage(planPath: string, requestedChanges?: string): string {
+  const details = [
+    `The user selected \"${REVISE_LABEL}\" for ${planPath}.`,
+    "Revise the existing saved plan instead of drafting a fresh replacement unless a full rewrite is genuinely necessary.",
+    "Prefer the edit tool for targeted adjustments to the current plan artifact. Use write only if the structure changes substantially or an exact edit is impractical.",
+    `Before saving the revised plan, make sure confidence is at least ${MIN_PLAN_CONFIDENCE}/10. If lower, investigate more or ask clarifying questions first.`,
+    "Keep an explicit confidence line in the plan, for example: \"Confidence: 8/10\" or higher.",
+  ];
+
+  if (requestedChanges) {
+    details.push(`User-requested changes: ${requestedChanges}`);
+  } else {
+    details.push("No concrete revision note was provided yet. Ask one concise clarifying question about what should change before editing the plan.");
+  }
+
+  details.push("After revising the saved plan artifact, ask for approval again.");
+  return details.join("\n\n");
+}
+
 function approvalSelectionToExecutionMode(
   selected: string | undefined,
 ): { permissionMode: RestorablePermissionMode; executeWithSubagent: boolean } | undefined {
@@ -589,6 +606,12 @@ function getAnswerValues(answer: AskUserAnswer | undefined): string[] {
   return values;
 }
 
+function getAnswerNote(answer: AskUserAnswer | undefined): string | undefined {
+  if (typeof answer?.notes !== "string") return undefined;
+  const note = answer.notes.trim();
+  return note.length > 0 ? note : undefined;
+}
+
 function selectionRequestsCancel(selected: string[]): boolean {
   return selected.some((value) => {
     if (typeof value !== "string") return false;
@@ -612,6 +635,8 @@ export const __testing = {
   buildApprovalSteeringMessage,
   buildPlanPreviewMessage,
   buildReviewSteeringMessage,
+  buildRevisionSteeringMessage,
+  buildPlanModeSystemPrompt,
   buildAutoSuggestPlanModeSystemPrompt,
   readAutoSuggestPlanModeSetting,
   PLAN_SUGGEST_QUESTION_ID,
@@ -830,9 +855,14 @@ export default function planCommand(pi: ExtensionAPI) {
     }
 
     if (actionSelection.includes(REVISE_LABEL)) {
+      const requestedChanges = getAnswerNote(actionAnswer);
       enablePlanMode(pi, ctx.model ? { provider: ctx.model.provider, id: ctx.model.id } : undefined, {
         approvalStatus: "revising",
       });
+      pi.sendUserMessage(
+        buildRevisionSteeringMessage(state.latestPlanPath ?? "the latest plan", requestedChanges),
+        { deliverAs: "steer" },
+      );
     }
   });
 

package/src/resources/extensions/subagent/background-job-manager.ts

@@ -31,6 +31,11 @@ type BackgroundJobMetadata = {
     model?: string;
 };
 
+type InProcessHandleLike = {
+    abort: () => void;
+    dispose: () => void;
+};
+
 export class BackgroundJobManager {
     private jobs = new Map<string, BackgroundSubagentJob>();
     private evictionTimers = new Map<string, ReturnType<typeof setTimeout>>();
@@ -80,6 +85,29 @@ export class BackgroundJobManager {
         return this.attachJob(agentName, task, cwd, abortController, resultPromise, metadata);
     }
 
+    /**
+     * Adopt an in-process subagent handle into background tracking.
+     */
+    adoptHandle(
+        agentName: string,
+        task: string,
+        cwd: string,
+        handle: InProcessHandleLike,
+        resultPromise: Promise<BackgroundJobResult>,
+        metadata?: BackgroundJobMetadata,
+    ): string {
+        const abortController = new AbortController();
+        const onAbort = () => handle.abort();
+        abortController.signal.addEventListener("abort", onAbort, { once: true });
+
+        const wrapped = resultPromise.finally(() => {
+            abortController.signal.removeEventListener("abort", onAbort);
+            handle.dispose();
+        });
+
+        return this.attachJob(agentName, task, cwd, abortController, wrapped, metadata);
+    }
+
     /**
      * Cancel a running job.
      */