lsd-pi 1.1.2 → 1.1.3

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

@@ -1,7 +1,6 @@
-import { mkdirSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync } from "node:fs";
+import { getAgentDir, getPermissionMode, isToolCallEventType, setPermissionMode, type ExtensionAPI, type ExtensionCommandContext, type PermissionMode } from "@gsd/pi-coding-agent";
 import { join } from "node:path";
-import type { ExtensionAPI, ExtensionCommandContext, PermissionMode } from "@gsd/pi-coding-agent";
-import { getPermissionMode, isToolCallEventType, setPermissionMode } from "@gsd/pi-coding-agent";
 
 const PLAN_ENTRY_TYPE = "plan-mode-state";
 const PLAN_APPROVAL_QUESTION_ID = "plan_mode_approval";
@@ -58,9 +57,15 @@ const BLOCKED_TOOLS = new Set([
   "write",
   "edit",
 ]);
+const DEFAULT_APPROVAL_PERMISSION_MODE: RestorablePermissionMode = "auto";
+const APPROVE_AUTO_LABEL = "Approve & switch to Auto mode";
+const APPROVE_BYPASS_LABEL = "Approve & switch to Bypass mode";
+const REVISE_LABEL = "Revise plan";
+const CANCEL_LABEL = "Cancel";
 
 type PlanApprovalStatus = "pending" | "approved" | "revising" | "cancelled";
 type RestorablePermissionMode = Exclude<PermissionMode, "plan">;
+type ModelRef = { provider: string; id: string };
 
 interface PlanModeState {
   active: boolean;
@@ -68,19 +73,65 @@ interface PlanModeState {
   latestPlanPath?: string;
   approvalStatus: PlanApprovalStatus;
   previousMode?: RestorablePermissionMode;
+  preplanModel?: ModelRef;
+  targetPermissionMode?: PermissionMode;
 }
 
-let state: PlanModeState = {
+const INITIAL_STATE: PlanModeState = {
   active: false,
   task: "",
+  latestPlanPath: undefined,
   approvalStatus: "cancelled",
+  previousMode: undefined,
+  preplanModel: undefined,
+  targetPermissionMode: undefined,
 };
+
+let state: PlanModeState = { ...INITIAL_STATE };
 let startedFromFlag = false;
 
 function isPlanModeActive(): boolean {
   return getPermissionMode() === "plan";
 }
 
+function parseQualifiedModelRef(value: unknown): ModelRef | undefined {
+  if (typeof value !== "string") return undefined;
+  const trimmed = value.trim();
+  if (!trimmed) return undefined;
+  const parts = trimmed.split("/");
+  if (parts.length !== 2) return undefined;
+  const [provider, id] = parts.map((part) => part.trim());
+  if (!provider || !id) return undefined;
+  return { provider, id };
+}
+
+export function readPlanModeReasoningModel(): string | undefined {
+  try {
+    const settingsPath = join(getAgentDir(), "settings.json");
+    if (!existsSync(settingsPath)) return undefined;
+    const raw = readFileSync(settingsPath, "utf-8");
+    const parsed = JSON.parse(raw) as { planModeReasoningModel?: unknown };
+    const model = parseQualifiedModelRef(parsed.planModeReasoningModel);
+    return model ? `${model.provider}/${model.id}` : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function sameModel(left: ModelRef | undefined, right: ModelRef | undefined): boolean {
+  return !!left && !!right && left.provider === right.provider && left.id === right.id;
+}
+
+function resolveModelFromContext(ctx: any, modelRef: ModelRef): any | undefined {
+  const allModels = typeof ctx?.modelRegistry?.getAll === "function" ? ctx.modelRegistry.getAll() : [];
+  return allModels.find((model: any) => model.provider === modelRef.provider && model.id === modelRef.id);
+}
+
+function setPermissionModeAndEnv(mode: PermissionMode): void {
+  setPermissionMode(mode);
+  process.env.LUCENT_CODE_PERMISSION_MODE = mode;
+}
+
 function saveState(pi: ExtensionAPI): void {
   pi.appendEntry<PlanModeState>(PLAN_ENTRY_TYPE, { ...state });
 }
@@ -90,15 +141,11 @@ function setState(pi: ExtensionAPI, next: PlanModeState): void {
   saveState(pi);
 }
 
-function clearState(pi: ExtensionAPI): void {
-  state = {
-    active: false,
-    task: "",
-    latestPlanPath: undefined,
-    approvalStatus: "cancelled",
-    previousMode: undefined,
-  };
-  saveState(pi);
+function resetState(pi: ExtensionAPI, overrides: Partial<PlanModeState> = {}): void {
+  setState(pi, {
+    ...INITIAL_STATE,
+    ...overrides,
+  });
 }
 
 function ensurePlanDir(): string {
@@ -124,35 +171,73 @@ function restoreStateFromSession(ctx: ExtensionCommandContext | any): void {
 
 function enablePlanMode(
   pi: ExtensionAPI,
-  next: Partial<Pick<PlanModeState, "task" | "latestPlanPath" | "approvalStatus" | "previousMode">> = {},
+  currentModel: ModelRef | undefined,
+  next: Partial<Pick<PlanModeState, "task" | "latestPlanPath" | "approvalStatus" | "previousMode" | "preplanModel" | "targetPermissionMode">> = {},
 ): void {
   const currentMode = getPermissionMode();
-  const previousMode: RestorablePermissionMode = currentMode === "plan"
-    ? (state.previousMode ?? "accept-on-edit")
-    : currentMode;
+  const enteringPlanMode = currentMode !== "plan";
+  const previousMode: RestorablePermissionMode = enteringPlanMode
+    ? currentMode
+    : (state.previousMode ?? "accept-on-edit");
 
-  setPermissionMode("plan");
-  process.env.LUCENT_CODE_PERMISSION_MODE = "plan";
+  setPermissionModeAndEnv("plan");
   setState(pi, {
     active: true,
     task: next.task ?? state.task,
     latestPlanPath: next.latestPlanPath ?? state.latestPlanPath,
     approvalStatus: next.approvalStatus ?? state.approvalStatus ?? "pending",
     previousMode: next.previousMode ?? previousMode,
+    preplanModel: next.preplanModel ?? (enteringPlanMode ? (currentModel ?? state.preplanModel) : state.preplanModel),
+    targetPermissionMode: next.targetPermissionMode ?? state.targetPermissionMode,
   });
 }
 
-function disablePlanMode(pi: ExtensionAPI, approvalStatus: PlanApprovalStatus, clearTask = false): RestorablePermissionMode {
-  const restoreMode = state.previousMode ?? "accept-on-edit";
-  setPermissionMode(restoreMode);
-  process.env.LUCENT_CODE_PERMISSION_MODE = restoreMode;
+function leavePlanMode(
+  pi: ExtensionAPI,
+  approvalStatus: PlanApprovalStatus,
+  nextPermissionMode: RestorablePermissionMode,
+  clearTask = false,
+): RestorablePermissionMode {
+  setPermissionModeAndEnv(nextPermissionMode);
   setState(pi, {
     active: false,
     task: clearTask ? "" : state.task,
     latestPlanPath: state.latestPlanPath,
     approvalStatus,
-    previousMode: restoreMode,
+    previousMode: state.previousMode,
+    preplanModel: state.preplanModel,
+    targetPermissionMode: state.targetPermissionMode ?? nextPermissionMode,
   });
+  return nextPermissionMode;
+}
+
+async function setModelIfNeeded(pi: ExtensionAPI, ctx: any, modelRef: ModelRef | undefined): Promise<void> {
+  if (!modelRef) return;
+  const currentModel = parseQualifiedModelRef(ctx?.model ? `${ctx.model.provider}/${ctx.model.id}` : undefined);
+  if (sameModel(currentModel, modelRef)) return;
+  const model = resolveModelFromContext(ctx, modelRef);
+  if (!model) return;
+  await pi.setModel(model, { persist: false });
+}
+
+async function approvePlan(pi: ExtensionAPI, ctx: any, permissionMode: RestorablePermissionMode): Promise<void> {
+  const reasoningModel = parseQualifiedModelRef(readPlanModeReasoningModel());
+  if (reasoningModel) {
+    await setModelIfNeeded(pi, ctx, reasoningModel);
+  }
+
+  state = {
+    ...state,
+    targetPermissionMode: permissionMode,
+  };
+  leavePlanMode(pi, "approved", permissionMode);
+}
+
+async function cancelPlan(pi: ExtensionAPI, ctx: any, clearTask = true): Promise<RestorablePermissionMode> {
+  const restoreMode = state.previousMode ?? "accept-on-edit";
+  await setModelIfNeeded(pi, ctx, state.preplanModel);
+  leavePlanMode(pi, "cancelled", restoreMode, clearTask);
+  resetState(pi, { approvalStatus: "cancelled" });
   return restoreMode;
 }
 
@@ -168,6 +253,49 @@ function buildPlanModeSystemPrompt(): string {
   return details.join(" ");
 }
 
+function buildApprovalSteeringMessage(planPath: string): string {
+  return [
+    `Plan artifact saved at ${planPath}.`,
+    "Present approval options now using ask_user_questions with exactly one single-select question.",
+    `Use question id \"${PLAN_APPROVAL_QUESTION_ID}\" and ask the user what to do next.`,
+    "Important: ask_user_questions single-select supports only 2-3 explicit options.",
+    "Use exactly these 3 options:",
+    `1. ${APPROVE_AUTO_LABEL} (Recommended)`,
+    `2. ${APPROVE_BYPASS_LABEL}`,
+    `3. ${REVISE_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 free-text note.`,
+    "If the dialog is dismissed or the user gives no answer, continue planning.",
+  ].join(" ");
+}
+
+function approvalSelectionToPermissionMode(selected: string): RestorablePermissionMode | undefined {
+  if (selected.includes(APPROVE_AUTO_LABEL)) return "auto";
+  if (selected.includes(APPROVE_BYPASS_LABEL)) return "danger-full-access";
+  return undefined;
+}
+
+function selectionRequestsCancel(selected: string | string[]): boolean {
+  const values = Array.isArray(selected) ? selected : [selected];
+  return values.some((value) => {
+    if (typeof value !== "string") return false;
+    if (value.includes(CANCEL_LABEL)) return true;
+    const normalized = value.replace(/^user_note:\s*/i, "").trim().toLowerCase();
+    return normalized === "cancel" || normalized.includes("cancel plan");
+  });
+}
+
+export const __testing = {
+  getState(): PlanModeState {
+    return { ...state };
+  },
+  resetState(): void {
+    state = { ...INITIAL_STATE };
+    startedFromFlag = false;
+  },
+  parseQualifiedModelRef,
+  approvalSelectionToPermissionMode,
+};
+
 export default function planCommand(pi: ExtensionAPI) {
   pi.registerFlag("plan", {
     description: "Start the session in plan mode and require a persisted .lsd/plan markdown plan before execution",
@@ -178,8 +306,7 @@ export default function planCommand(pi: ExtensionAPI) {
     restoreStateFromSession(ctx);
     startedFromFlag = false;
     if (state.active) {
-      setPermissionMode("plan");
-      process.env.LUCENT_CODE_PERMISSION_MODE = "plan";
+      setPermissionModeAndEnv("plan");
     }
   });
 
@@ -190,7 +317,7 @@ export default function planCommand(pi: ExtensionAPI) {
     };
   });
 
-  pi.on("input", async (event) => {
+  pi.on("input", async (event, ctx) => {
     const planFlag = pi.getFlag("plan");
     if (startedFromFlag || planFlag !== true || event.source !== "interactive") {
       return { action: "continue" as const };
@@ -198,9 +325,11 @@ export default function planCommand(pi: ExtensionAPI) {
 
     startedFromFlag = true;
     ensurePlanDir();
-    enablePlanMode(pi, {
+    enablePlanMode(pi, ctx.model ? { provider: ctx.model.provider, id: ctx.model.id } : undefined, {
       task: event.text.trim(),
       approvalStatus: "pending",
+      latestPlanPath: undefined,
+      targetPermissionMode: undefined,
     });
 
     return { action: "continue" as const };
@@ -235,16 +364,24 @@ export default function planCommand(pi: ExtensionAPI) {
     }
   });
 
-  pi.on("tool_result", async (event) => {
+  pi.on("tool_result", async (event, ctx) => {
     if (event.toolName === "write" || event.toolName === "edit") {
       const input = event.input as { path?: string } | undefined;
       const path = input?.path;
-      if (path && PLAN_DIR_RE.test(path)) {
+      if (path && PLAN_DIR_RE.test(path) && isPlanModeActive()) {
         setState(pi, {
           ...state,
           latestPlanPath: path,
-          approvalStatus: state.approvalStatus === "revising" ? "pending" : state.approvalStatus,
+          approvalStatus: "pending",
+          targetPermissionMode: undefined,
         });
+
+        if (!ctx.hasUI) {
+          await approvePlan(pi, ctx, DEFAULT_APPROVAL_PERMISSION_MODE);
+          return;
+        }
+
+        pi.sendUserMessage(buildApprovalSteeringMessage(path), { deliverAs: "steer" });
       }
       return;
     }
@@ -260,22 +397,28 @@ export default function planCommand(pi: ExtensionAPI) {
     const answer = details.response.answers[PLAN_APPROVAL_QUESTION_ID];
     if (!answer) return;
 
-    const selected = Array.isArray(answer.selected) ? answer.selected[0] : answer.selected;
-    if (typeof selected !== "string") return;
+    const selected = Array.isArray(answer.selected) ? answer.selected : [answer.selected];
+    if (!selected.every((value) => typeof value === "string")) return;
 
-    if (selected.includes("Approve plan")) {
-      disablePlanMode(pi, "approved");
+    const targetPermissionMode = approvalSelectionToPermissionMode(selected[0]);
+    if (targetPermissionMode) {
+      state = {
+        ...state,
+        targetPermissionMode,
+      };
+      await approvePlan(pi, ctx, targetPermissionMode);
       return;
     }
 
-    if (selected.includes("Revise plan")) {
-      enablePlanMode(pi, { approvalStatus: "revising" });
+    if (selected.some((value) => value.includes(REVISE_LABEL))) {
+      enablePlanMode(pi, ctx.model ? { provider: ctx.model.provider, id: ctx.model.id } : undefined, {
+        approvalStatus: "revising",
+      });
       return;
     }
 
-    if (selected.includes("Cancel")) {
-      disablePlanMode(pi, "cancelled", true);
-      clearState(pi);
+    if (selectionRequestsCancel(selected)) {
+      await cancelPlan(pi, ctx, true);
     }
   });
 
@@ -283,16 +426,18 @@ export default function planCommand(pi: ExtensionAPI) {
     description: "Toggle plan mode. While active, only investigative tools and writes under .lsd/plan/ are allowed",
     async handler(args: string, ctx: ExtensionCommandContext) {
       if (isPlanModeActive()) {
-        disablePlanMode(pi, "cancelled");
+        await cancelPlan(pi, ctx, true);
         ctx.ui.notify("Plan mode disabled.", "info");
         return;
       }
 
       ensurePlanDir();
       const task = args.trim();
-      enablePlanMode(pi, {
+      enablePlanMode(pi, ctx.model ? { provider: ctx.model.provider, id: ctx.model.id } : undefined, {
         task,
+        latestPlanPath: undefined,
         approvalStatus: "pending",
+        targetPermissionMode: undefined,
       });
       ctx.ui.notify(
         task
@@ -310,8 +455,8 @@ export default function planCommand(pi: ExtensionAPI) {
         ctx.ui.notify("Plan mode is not active.", "info");
         return;
       }
-      const restoreMode = disablePlanMode(pi, "approved");
-      ctx.ui.notify(`Plan mode disabled. Permission mode restored to ${restoreMode}.`, "info");
+      await approvePlan(pi, ctx, DEFAULT_APPROVAL_PERMISSION_MODE);
+      ctx.ui.notify(`Plan approved. Permission mode switched to ${DEFAULT_APPROVAL_PERMISSION_MODE}.`, "info");
     },
   });
 
@@ -319,9 +464,10 @@ export default function planCommand(pi: ExtensionAPI) {
     description: "Cancel the current plan-mode session without executing",
     async handler(_args: string, ctx: ExtensionCommandContext) {
       if (isPlanModeActive()) {
-        disablePlanMode(pi, "cancelled", true);
+        await cancelPlan(pi, ctx, true);
+      } else {
+        resetState(pi, { approvalStatus: "cancelled" });
       }
-      clearState(pi);
       ctx.ui.notify("Plan mode cancelled.", "info");
     },
   });

package/src/resources/extensions/subagent/agents.ts

@@ -25,6 +25,16 @@ export interface AgentDiscoveryResult {
 	projectAgentsDir: string | null;
 }
 
+function normalizeAgentModel(model: string | undefined): string | undefined {
+	const trimmed = model?.trim();
+	if (!trimmed) return undefined;
+	if (trimmed === "$budget_model") return trimmed;
+	if (trimmed.includes(" ")) return undefined;
+	if (!trimmed.includes("/")) return trimmed;
+	const parts = trimmed.split("/");
+	return parts.length === 2 && parts.every(Boolean) ? trimmed : undefined;
+}
+
 function loadAgentsFromDir(dir: string, source: "user" | "project"): AgentConfig[] {
 	const agents: AgentConfig[] = [];
 
@@ -66,7 +76,7 @@ function loadAgentsFromDir(dir: string, source: "user" | "project"): AgentConfig
 			name: frontmatter.name,
 			description: frontmatter.description,
 			tools: tools && tools.length > 0 ? tools : undefined,
-			model: frontmatter.model,
+			model: normalizeAgentModel(frontmatter.model),
 			systemPrompt: body,
 			source,
 			filePath,

package/src/resources/extensions/subagent/configured-model.ts

@@ -1,5 +1,6 @@
 import type { AgentConfig } from "./agents.js";
 import type { SharedPreferences } from "../shared/preferences.js";
+import { normalizeSubagentModel } from "./model-resolution.js";
 
 export function resolveConfiguredSubagentModel(
 	agent: AgentConfig,
@@ -9,7 +10,7 @@ export function resolveConfiguredSubagentModel(
 	const configuredModel = agent.model?.trim();
 	if (!configuredModel) return undefined;
 	if (configuredModel === "$budget_model") {
-		return settingsBudgetModel?.trim() || preferences?.subagent?.budget_model?.trim() || undefined;
+		return normalizeSubagentModel(settingsBudgetModel) ?? normalizeSubagentModel(preferences?.subagent?.budget_model);
 	}
-	return configuredModel;
+	return normalizeSubagentModel(configuredModel);
 }

package/src/resources/extensions/subagent/index.ts

@@ -12,7 +12,7 @@
  * Uses JSON mode to capture structured output from subagents.
  */
 
-import { spawn, execSync, type ChildProcess } from "node:child_process";
+import { spawn, execFileSync, type ChildProcess } from "node:child_process";
 import * as crypto from "node:crypto";
 import * as fs from "node:fs";
 import * as os from "node:os";
@@ -31,6 +31,7 @@ import { Container, Markdown, Spacer, Text } from "@gsd/pi-tui";
 import { Type } from "@sinclair/typebox";
 import { formatTokenCount } from "../shared/mod.js";
 import { type AgentConfig, type AgentScope, discoverAgents } from "./agents.js";
+import { buildSubagentProcessArgs, getBundledExtensionPathsFromEnv } from "./launch-helpers.js";
 import {
 	type IsolationEnvironment,
 	type IsolationMode,
@@ -42,7 +43,10 @@ import {
 import { registerWorker, updateWorker } from "./worker-registry.js";
 import { handleSubagentPermissionRequest, isSubagentPermissionRequest } from "./approval-proxy.js";
 import { resolveConfiguredSubagentModel } from "./configured-model.js";
-import { resolveSubagentModel } from "./model-resolution.js";
+import {
+	normalizeSubagentModel,
+	resolveSubagentModel,
+} from "./model-resolution.js";
 import { loadEffectivePreferences } from "../shared/preferences.js";
 import { CmuxClient, shellEscape } from "../cmux/index.js";
 
@@ -51,7 +55,7 @@ const MAX_CONCURRENCY = 4;
 const COLLAPSED_ITEM_COUNT = 10;
 const liveSubagentProcesses = new Set<ChildProcess>();
 
-async function stopLiveSubagents(): Promise<void> {
+export async function stopLiveSubagents(): Promise<void> {
 	const active = Array.from(liveSubagentProcesses);
 	if (active.length === 0) return;
 
@@ -274,26 +278,14 @@ function readBudgetSubagentModelFromSettings(): string | undefined {
 		if (!fs.existsSync(settingsPath)) return undefined;
 		const raw = fs.readFileSync(settingsPath, "utf-8");
 		const parsed = JSON.parse(raw) as { budgetSubagentModel?: unknown };
-		return typeof parsed.budgetSubagentModel === "string" ? parsed.budgetSubagentModel.trim() || undefined : undefined;
+		return typeof parsed.budgetSubagentModel === "string"
+			? normalizeSubagentModel(parsed.budgetSubagentModel)
+			: undefined;
 	} catch {
 		return undefined;
 	}
 }
 
-function buildSubagentProcessArgs(
-	agent: AgentConfig,
-	task: string,
-	tmpPromptPath: string | null,
-	model: string | undefined,
-): string[] {
-	const args: string[] = ["--mode", "json", "-p", "--no-session"];
-	if (model) args.push("--model", model);
-	if (agent.tools && agent.tools.length > 0) args.push("--tools", agent.tools.join(","));
-	if (tmpPromptPath) args.push("--append-system-prompt", tmpPromptPath);
-	args.push(`Task: ${task}`);
-	return args;
-}
-
 function resolveSubagentCliPath(defaultCwd: string): string | null {
 	const candidates = [process.env.GSD_BIN_PATH, process.env.LSD_BIN_PATH, process.argv[1]]
 		.map((value) => value?.trim())
@@ -310,7 +302,7 @@ function resolveSubagentCliPath(defaultCwd: string): string | null {
 
 	for (const binName of ["lsd", "gsd"]) {
 		try {
-			const resolved = execSync(`which ${binName}`, { encoding: "utf-8" }).trim();
+			const resolved = execFileSync("which", [binName], { encoding: "utf-8" }).trim();
 			if (resolved) return resolved;
 		} catch {
 			/* ignore */
@@ -325,13 +317,13 @@ function processSubagentEventLine(
 	currentResult: SingleResult,
 	emitUpdate: () => void,
 	proc?: ChildProcess,
-): void {
-	if (!line.trim()) return;
+): boolean {
+	if (!line.trim()) return false;
 	let event: any;
 	try {
 		event = JSON.parse(line);
 	} catch {
-		return;
+		return false;
 	}
 
 	if (proc && isSubagentPermissionRequest(event)) {
@@ -339,10 +331,10 @@ function processSubagentEventLine(
 			requestFileChangeApproval,
 			requestClassifierDecision,
 		});
-		return;
+		return false;
 	}
 
-	if (event.type === "message_end" && event.message) {
+	if ((event.type === "message_end" || event.type === "turn_end") && event.message) {
 		const msg = event.message as Message;
 		currentResult.messages.push(msg);
 
@@ -357,7 +349,7 @@ function processSubagentEventLine(
 				currentResult.usage.cost += usage.cost?.total || 0;
 				currentResult.usage.contextTokens = usage.totalTokens || 0;
 			}
-			if (msg.model) currentResult.model = msg.model;
+			if (msg.model && (!currentResult.model || msg.model.includes("/"))) currentResult.model = msg.model;
 			if (msg.stopReason) currentResult.stopReason = msg.stopReason;
 			if (msg.errorMessage) currentResult.errorMessage = msg.errorMessage;
 		}
@@ -368,6 +360,8 @@ function processSubagentEventLine(
 		currentResult.messages.push(event.message as Message);
 		emitUpdate();
 	}
+
+	return event.type === "agent_end";
 }
 
 async function waitForFile(filePath: string, signal: AbortSignal | undefined, timeoutMs = 30 * 60 * 1000): Promise<boolean> {
@@ -453,8 +447,8 @@ async function runSingleAgent(
 		let wasAborted = false;
 
 		const exitCode = await new Promise<number>((resolve) => {
-			const bundledPaths = (process.env.GSD_BUNDLED_EXTENSION_PATHS ?? "").split(path.delimiter).map(s => s.trim()).filter(Boolean);
-			const extensionArgs = bundledPaths.flatMap(p => ["--extension", p]);
+			const bundledPaths = getBundledExtensionPathsFromEnv();
+			const extensionArgs = bundledPaths.flatMap((p) => ["--extension", p]);
 			const cliPath = resolveSubagentCliPath(cwd ?? defaultCwd);
 			if (!cliPath) {
 				currentResult.stderr += "Unable to resolve LSD/GSD CLI path for subagent launch.";
@@ -466,14 +460,25 @@ async function runSingleAgent(
 				[cliPath, ...extensionArgs, ...args],
 				{ cwd: cwd ?? defaultCwd, shell: false, stdio: ["pipe", "pipe", "pipe"] },
 			);
+			proc.stdin.end();
 			liveSubagentProcesses.add(proc);
 			let buffer = "";
+			let completionSeen = false;
 
 			proc.stdout.on("data", (data) => {
 				buffer += data.toString();
 				const lines = buffer.split("\n");
 				buffer = lines.pop() || "";
-				for (const line of lines) processSubagentEventLine(line, currentResult, emitUpdate, proc);
+				for (const line of lines) {
+					if (processSubagentEventLine(line, currentResult, emitUpdate, proc)) {
+						completionSeen = true;
+						try {
+							proc.kill("SIGTERM");
+						} catch {
+							/* ignore */
+						}
+					}
+				}
 			});
 
 			proc.stderr.on("data", (data) => {
@@ -482,8 +487,11 @@ async function runSingleAgent(
 
 			proc.on("close", (code) => {
 				liveSubagentProcesses.delete(proc);
-				if (buffer.trim()) processSubagentEventLine(buffer, currentResult, emitUpdate, proc);
-				resolve(code ?? 0);
+				if (buffer.trim()) {
+					const completedOnFlush = processSubagentEventLine(buffer, currentResult, emitUpdate, proc);
+					completionSeen = completionSeen || completedOnFlush;
+				}
+				resolve(completionSeen && (code === null || code === 143 || code === 15) ? 0 : (code ?? 0));
 			});
 
 			proc.on("error", () => {

package/src/resources/extensions/subagent/launch-helpers.ts

@@ -0,0 +1,30 @@
+import * as path from "node:path";
+
+import type { AgentConfig } from "./agents.js";
+
+export function getBundledExtensionPathsFromEnv(env: NodeJS.ProcessEnv = process.env): string[] {
+	const rawPaths = [env.GSD_BUNDLED_EXTENSION_PATHS, env.LSD_BUNDLED_EXTENSION_PATHS]
+		.map((value) => value?.trim())
+		.filter((value): value is string => Boolean(value));
+	const unique = new Set<string>();
+	for (const raw of rawPaths) {
+		for (const entry of raw.split(path.delimiter).map((value) => value.trim()).filter(Boolean)) {
+			unique.add(entry);
+		}
+	}
+	return Array.from(unique);
+}
+
+export function buildSubagentProcessArgs(
+	agent: AgentConfig,
+	task: string,
+	tmpPromptPath: string | null,
+	model: string | undefined,
+): string[] {
+	const args: string[] = ["--mode", "json", "-p", "--no-session"];
+	if (model) args.push("--model", model);
+	if (agent.tools && agent.tools.length > 0) args.push("--tools", agent.tools.join(","));
+	if (tmpPromptPath) args.push("--append-system-prompt", tmpPromptPath);
+	args.push(`Task: ${task}`);
+	return args;
+}