gsd-pi 2.78.1-dev.84a383f51 → 2.78.1-dev.9d08d820b

package/src/resources/extensions/ollama/ollama-client.ts

@@ -19,8 +19,45 @@ import type {
 import { parseNDJsonStream } from "./ndjson-stream.js";
 
 const DEFAULT_HOST = "http://localhost:11434";
-const PROBE_TIMEOUT_MS = 1500;
-const REQUEST_TIMEOUT_MS = 10000;
+const DEFAULT_PROBE_TIMEOUT_MS = 1500;
+const DEFAULT_REQUEST_TIMEOUT_MS = 10000;
+export const MAX_TIMER_DELAY_MS = 2_147_483_647;
+
+/**
+ * Parse a positive integer from an environment variable, falling back to
+ * `fallback` when the var is unset, empty, non-numeric, zero, or negative.
+ *
+ * Defensive parsing: a typo like `OLLAMA_PROBE_TIMEOUT_MS=abc` or
+ * `OLLAMA_PROBE_TIMEOUT_MS=0` should not silently disable the timeout —
+ * fall back to the documented default instead.
+ */
+export function envPositiveInt(name: string, fallback: number): number {
+	const raw = process.env[name];
+	if (!raw) return fallback;
+	const parsed = Number.parseInt(raw, 10);
+	if (!Number.isFinite(parsed) || parsed <= 0) return fallback;
+	return Math.min(parsed, MAX_TIMER_DELAY_MS);
+}
+
+/**
+ * Effective probe timeout for the startup `isRunning()` health check.
+ * Override with `OLLAMA_PROBE_TIMEOUT_MS=<ms>` for slower networks (LAN
+ * Ollama hosts, cloud endpoints, contended cold starts).
+ *
+ * Resolved at call time — tests and downstream callers can mutate
+ * `process.env` between invocations and pick up the new value.
+ */
+export function getProbeTimeoutMs(): number {
+	return envPositiveInt("OLLAMA_PROBE_TIMEOUT_MS", DEFAULT_PROBE_TIMEOUT_MS);
+}
+
+/**
+ * Effective per-request timeout for REST calls. Override with
+ * `OLLAMA_REQUEST_TIMEOUT_MS=<ms>`.
+ */
+export function getRequestTimeoutMs(): number {
+	return envPositiveInt("OLLAMA_REQUEST_TIMEOUT_MS", DEFAULT_REQUEST_TIMEOUT_MS);
+}
 
 /**
  * Get the Ollama host URL from OLLAMA_HOST or default.
@@ -57,7 +94,7 @@ function withAuth(options: RequestInit = {}): RequestInit {
 	};
 }
 
-async function fetchWithTimeout(url: string, options: RequestInit = {}, timeoutMs = REQUEST_TIMEOUT_MS): Promise<Response> {
+async function fetchWithTimeout(url: string, options: RequestInit = {}, timeoutMs = getRequestTimeoutMs()): Promise<Response> {
 	const controller = new AbortController();
 	const timeout = setTimeout(() => controller.abort(), timeoutMs);
 	try {
@@ -77,7 +114,7 @@ export async function isRunning(): Promise<boolean> {
 		const host = getOllamaHost();
 		const isCloud = host.includes("ollama.com") || host.includes("cloud");
 		const probeUrl = isCloud ? `${host}/api/tags` : `${host}/`;
-		const timeout = isCloud ? REQUEST_TIMEOUT_MS : PROBE_TIMEOUT_MS;
+		const timeout = isCloud ? getRequestTimeoutMs() : getProbeTimeoutMs();
 		const response = await fetchWithTimeout(probeUrl, isCloud ? { method: "GET" } : {}, timeout);
 		return response.ok;
 	} catch {

package/src/resources/extensions/ollama/tests/model-capabilities.test.ts

@@ -84,6 +84,102 @@ describe("getModelCapabilities", () => {
 	});
 });
 
+// ─── Ordering / prefix-shadowing regression (#4991) ──────────────────────────
+//
+// The lookup is a linear scan over KNOWN_MODELS using `baseName.startsWith(pattern)`.
+// Cloud and long-variant model names share prefixes with their base families,
+// so the longer entries MUST appear earlier in the table — otherwise a base
+// like `qwen3` shadows `qwen3-coder`/`qwen3-next`/`qwen3.5` and the picker
+// reports the wrong context window. These tests pin the ordering.
+
+describe("getModelCapabilities — long-variant overrides aren't shadowed (#4991)", () => {
+	it("qwen3-coder reports 256K, not the qwen3 131K", () => {
+		const caps = getModelCapabilities("qwen3-coder:480b");
+		assert.equal(caps.contextWindow, 262144);
+		assert.equal(caps.ollamaOptions?.num_ctx, 262144);
+	});
+
+	it("qwen3-coder-next still resolves via the qwen3-coder entry", () => {
+		const caps = getModelCapabilities("qwen3-coder-next");
+		assert.equal(caps.contextWindow, 262144);
+	});
+
+	it("qwen3-next:80b reports 1M, not the qwen3 131K", () => {
+		const caps = getModelCapabilities("qwen3-next:80b");
+		assert.equal(caps.contextWindow, 1048576);
+	});
+
+	it("qwen3.5 / qwen3.6 cloud variants report 1M", () => {
+		assert.equal(getModelCapabilities("qwen3.5:397b").contextWindow, 1048576);
+		assert.equal(getModelCapabilities("qwen3.6:cloud").contextWindow, 1048576);
+	});
+
+	it("base qwen3 still resolves to its 131K entry", () => {
+		const caps = getModelCapabilities("qwen3:8b");
+		assert.equal(caps.contextWindow, 131072);
+	});
+
+	it("glm-5.1:cloud reports 200K", () => {
+		const caps = getModelCapabilities("glm-5.1:cloud");
+		assert.equal(caps.contextWindow, 204800);
+	});
+
+	it("glm-4.6:cloud reports 200K", () => {
+		const caps = getModelCapabilities("glm-4.6:cloud");
+		assert.equal(caps.contextWindow, 204800);
+	});
+
+	it("glm-4 base still resolves to its 131K entry", () => {
+		const caps = getModelCapabilities("glm-4:9b");
+		assert.equal(caps.contextWindow, 131072);
+	});
+
+	it("kimi-k2-thinking reports 256K (not shadowed by kimi-k2)", () => {
+		const caps = getModelCapabilities("kimi-k2-thinking");
+		assert.equal(caps.contextWindow, 262144);
+	});
+
+	it("kimi-k2.5:cloud and kimi-k2.6:cloud both report 256K", () => {
+		assert.equal(getModelCapabilities("kimi-k2.5:cloud").contextWindow, 262144);
+		assert.equal(getModelCapabilities("kimi-k2.6:cloud").contextWindow, 262144);
+	});
+
+	it("kimi-k2 base resolves to 256K", () => {
+		const caps = getModelCapabilities("kimi-k2:cloud");
+		assert.equal(caps.contextWindow, 262144);
+	});
+
+	it("minimax-m2.5:cloud and minimax-m2.7:cloud report 1M", () => {
+		assert.equal(getModelCapabilities("minimax-m2.5:cloud").contextWindow, 1048576);
+		assert.equal(getModelCapabilities("minimax-m2.7:cloud").contextWindow, 1048576);
+	});
+
+	it("minimax-m2 base resolves to 1M", () => {
+		const caps = getModelCapabilities("minimax-m2:cloud");
+		assert.equal(caps.contextWindow, 1048576);
+	});
+
+	it("ollamaOptions.num_ctx mirrors contextWindow for all new entries", () => {
+		// Inference time: num_ctx is what gets sent to Ollama on each chat.
+		// If contextWindow is right but num_ctx is stale, the model still
+		// gets truncated. Pin both sides.
+		for (const name of [
+			"qwen3-next:80b",
+			"qwen3-coder:480b",
+			"glm-5.1:cloud",
+			"kimi-k2-thinking",
+			"minimax-m2.7:cloud",
+		]) {
+			const caps = getModelCapabilities(name);
+			assert.equal(
+				caps.ollamaOptions?.num_ctx,
+				caps.contextWindow,
+				`${name}: num_ctx (${caps.ollamaOptions?.num_ctx}) must equal contextWindow (${caps.contextWindow})`,
+			);
+		}
+	});
+});
+
 // ─── estimateContextFromParams ───────────────────────────────────────────────
 
 describe("estimateContextFromParams", () => {

package/src/resources/extensions/ollama/tests/ollama-client-timeout-env.test.ts

@@ -0,0 +1,147 @@
+// GSD2 — Tests for OLLAMA_PROBE_TIMEOUT_MS / OLLAMA_REQUEST_TIMEOUT_MS env vars (#5003 / #4982)
+//
+// Pinned defaults: 1500 ms probe, 10 000 ms request. The defaults must be
+// preserved when the env var is unset, empty, non-numeric, zero, or negative
+// so a typo or fat-fingered value can't silently disable the timeout. When
+// the env var is set to a valid positive integer it overrides the default.
+
+import { describe, it, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import {
+	envPositiveInt,
+	getProbeTimeoutMs,
+	getRequestTimeoutMs,
+	MAX_TIMER_DELAY_MS,
+} from "../ollama-client.js";
+
+const PROBE_VAR = "OLLAMA_PROBE_TIMEOUT_MS";
+const REQUEST_VAR = "OLLAMA_REQUEST_TIMEOUT_MS";
+
+function withEnv(name: string, value: string | undefined, run: () => void): void {
+	const prior = process.env[name];
+	if (value === undefined) {
+		delete process.env[name];
+	} else {
+		process.env[name] = value;
+	}
+	try {
+		run();
+	} finally {
+		if (prior === undefined) {
+			delete process.env[name];
+		} else {
+			process.env[name] = prior;
+		}
+	}
+}
+
+describe("envPositiveInt — defensive fallback", () => {
+	it("returns fallback when var is unset", () => {
+		withEnv("__GSD_TEST_INT__", undefined, () => {
+			assert.equal(envPositiveInt("__GSD_TEST_INT__", 42), 42);
+		});
+	});
+
+	it("returns fallback when var is empty string", () => {
+		withEnv("__GSD_TEST_INT__", "", () => {
+			assert.equal(envPositiveInt("__GSD_TEST_INT__", 42), 42);
+		});
+	});
+
+	it("returns fallback when var is non-numeric", () => {
+		withEnv("__GSD_TEST_INT__", "abc", () => {
+			assert.equal(envPositiveInt("__GSD_TEST_INT__", 42), 42);
+		});
+	});
+
+	it("returns fallback when var is zero (would silently disable timeout)", () => {
+		withEnv("__GSD_TEST_INT__", "0", () => {
+			assert.equal(envPositiveInt("__GSD_TEST_INT__", 42), 42);
+		});
+	});
+
+	it("returns fallback when var is negative", () => {
+		withEnv("__GSD_TEST_INT__", "-100", () => {
+			assert.equal(envPositiveInt("__GSD_TEST_INT__", 42), 42);
+		});
+	});
+
+	it("returns parsed value when var is a positive integer", () => {
+		withEnv("__GSD_TEST_INT__", "5000", () => {
+			assert.equal(envPositiveInt("__GSD_TEST_INT__", 42), 5000);
+		});
+	});
+
+	it("parses leading digits and discards trailing junk (parseInt semantics)", () => {
+		withEnv("__GSD_TEST_INT__", "1500ms", () => {
+			assert.equal(envPositiveInt("__GSD_TEST_INT__", 42), 1500);
+		});
+	});
+
+	it("clamps values above MAX_TIMER_DELAY_MS to prevent setTimeout overflow", () => {
+		withEnv("__GSD_TEST_INT__", String(MAX_TIMER_DELAY_MS + 1), () => {
+			assert.equal(envPositiveInt("__GSD_TEST_INT__", 42), MAX_TIMER_DELAY_MS);
+		});
+	});
+
+	it("accepts MAX_TIMER_DELAY_MS exactly", () => {
+		withEnv("__GSD_TEST_INT__", String(MAX_TIMER_DELAY_MS), () => {
+			assert.equal(envPositiveInt("__GSD_TEST_INT__", 42), MAX_TIMER_DELAY_MS);
+		});
+	});
+});
+
+describe("getProbeTimeoutMs — OLLAMA_PROBE_TIMEOUT_MS override", () => {
+	beforeEach(() => {
+		delete process.env[PROBE_VAR];
+	});
+	afterEach(() => {
+		delete process.env[PROBE_VAR];
+	});
+
+	it("defaults to 1500 ms when unset", () => {
+		assert.equal(getProbeTimeoutMs(), 1500);
+	});
+
+	it("honours a positive override", () => {
+		process.env[PROBE_VAR] = "5000";
+		assert.equal(getProbeTimeoutMs(), 5000);
+	});
+
+	it("falls back to 1500 ms on a zero override (typo guard)", () => {
+		process.env[PROBE_VAR] = "0";
+		assert.equal(getProbeTimeoutMs(), 1500);
+	});
+
+	it("re-reads the env var on every call", () => {
+		process.env[PROBE_VAR] = "2000";
+		assert.equal(getProbeTimeoutMs(), 2000);
+		process.env[PROBE_VAR] = "8000";
+		assert.equal(getProbeTimeoutMs(), 8000);
+		delete process.env[PROBE_VAR];
+		assert.equal(getProbeTimeoutMs(), 1500);
+	});
+});
+
+describe("getRequestTimeoutMs — OLLAMA_REQUEST_TIMEOUT_MS override", () => {
+	beforeEach(() => {
+		delete process.env[REQUEST_VAR];
+	});
+	afterEach(() => {
+		delete process.env[REQUEST_VAR];
+	});
+
+	it("defaults to 10 000 ms when unset", () => {
+		assert.equal(getRequestTimeoutMs(), 10000);
+	});
+
+	it("honours a positive override", () => {
+		process.env[REQUEST_VAR] = "30000";
+		assert.equal(getRequestTimeoutMs(), 30000);
+	});
+
+	it("falls back to 10 000 ms on non-numeric input", () => {
+		process.env[REQUEST_VAR] = "thirty-seconds";
+		assert.equal(getRequestTimeoutMs(), 10000);
+	});
+});

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

@@ -36,6 +36,7 @@ import {
 } from "./isolation.js";
 import { registerWorker, updateWorker } from "./worker-registry.js";
 import { loadEffectiveGSDPreferences } from "../gsd/preferences.js";
+import { emitJournalEvent } from "../gsd/journal.js";
 import { CmuxClient, shellEscape } from "../cmux/index.js";
 
 const MAX_PARALLEL_TASKS = 8;
@@ -662,11 +663,13 @@ export default function (pi: ExtensionAPI) {
 			"Use chain mode to pipeline: scout finds context, planner designs, worker implements.",
 		].join(" "),
 		promptGuidelines: [
-			"Use subagent to delegate self-contained tasks that benefit from an isolated context window.",
-			"Use scout agent first when you need codebase context before implementing.",
-			"Use chain mode for scout→planner→worker or worker→reviewer→worker pipelines.",
-			"Use parallel mode when tasks are independent and don't need each other's output.",
-			"Always check available agents with /subagent before choosing one.",
+			"Prefer subagent dispatch over inline work whenever a task is self-contained — recon, planning, review, refactor, test writing, security audit, doc writing. Each dispatch gets a fresh context window, so your main session stays focused on synthesis.",
+			"Before reading more than ~3 files to understand something, dispatch the scout agent and work from its compressed report instead.",
+			"Before any change touching ≥2 packages, the orchestration kernel, auto-mode, or a public API, dispatch the planner agent first. Plan first, then implement.",
+			"You MUST use parallel mode when ≥2 ready tasks are independent of each other's output. Do not serialize independent tasks manually — that wastes wall time and context.",
+			"Use chain mode for sequential pipelines where each step's output feeds the next: scout → planner → worker, or worker → reviewer → worker.",
+			"Before opening a PR or marking a slice complete, dispatch the reviewer agent (and security agent if the change touches auth, network, parsing, file IO, or shell exec).",
+			"Always check available agents with /subagent before choosing one — there are bundled specialists plus any project-scoped agents.",
 		],
 		parameters: SubagentParams,
 
@@ -709,6 +712,141 @@ export default function (pi: ExtensionAPI) {
 				};
 			}
 
+			// Dispatch telemetry — emit invoked once per dispatch and completed before each return.
+			// Fresh flowId per dispatch (subagent runs aren't currently plumbed with the parent
+			// auto-mode flowId; per-dispatch ids still let us measure frequency, batch size, mode).
+			const dispatchMode: "single" | "parallel" | "chain" = hasChain ? "chain" : hasTasks ? "parallel" : "single";
+			const dispatchAgents = hasChain
+				? params.chain!.map((s) => s.agent)
+				: hasTasks
+					? params.tasks!.map((t) => t.agent)
+					: params.agent
+						? [params.agent]
+						: [];
+			const dispatchTasks = hasChain
+				? params.chain!.map((s) => s.task)
+				: hasTasks
+					? params.tasks!.map((t) => t.task)
+					: params.task
+						? [params.task]
+						: [];
+			const dispatchId = crypto.randomUUID();
+			const dispatchStartMs = Date.now();
+			let finalResults: SingleResult[] = [];
+			let dispatchCompletedEmitted = false;
+
+			emitJournalEvent(ctx.cwd, {
+				ts: new Date().toISOString(),
+				flowId: dispatchId,
+				seq: 0,
+				eventType: "subagent-invoked",
+				data: {
+					dispatchId,
+					mode: dispatchMode,
+					agents: dispatchAgents,
+					batchSize: dispatchAgents.length,
+					unitType: getCurrentPhase() ?? null,
+					isolated: useIsolation,
+				},
+			});
+
+			const zeroUsage = (): UsageStats => ({
+				input: 0,
+				output: 0,
+				cacheRead: 0,
+				cacheWrite: 0,
+				cost: 0,
+				contextTokens: 0,
+				turns: 0,
+			});
+			const errorMessageFor = (err: unknown): string =>
+				err instanceof Error ? err.message : String(err || "subagent dispatch failed");
+			const makeFailureResult = (err: unknown, agent: string, task: string, step?: number): SingleResult => {
+				const message = errorMessageFor(err);
+				return {
+					agent,
+					agentSource: "unknown",
+					task,
+					exitCode: 1,
+					messages: [],
+					stderr: message,
+					usage: zeroUsage(),
+					stopReason: signal?.aborted ? "aborted" : "error",
+					errorMessage: message,
+					...(step !== undefined ? { step } : {}),
+				};
+			};
+			const synthesizeFailureResults = (err: unknown): SingleResult[] => {
+				if (finalResults.length > 0) {
+					let patchedRunning = false;
+					const patched = finalResults.map((result) => {
+						if (result.exitCode !== -1) return result;
+						patchedRunning = true;
+						const message = errorMessageFor(err);
+						return {
+							...result,
+							exitCode: 1,
+							stderr: result.stderr || message,
+							stopReason: signal?.aborted ? "aborted" : "error",
+							errorMessage: result.errorMessage || message,
+							usage: result.usage ?? zeroUsage(),
+						};
+					});
+					if (patchedRunning || patched.some((result) => result.exitCode !== 0)) return patched;
+
+					const nextIndex = finalResults.length < dispatchAgents.length ? finalResults.length : 0;
+					if (nextIndex > 0) {
+						return [
+							...finalResults,
+							makeFailureResult(
+								err,
+								dispatchAgents[nextIndex] ?? "unknown",
+								dispatchTasks[nextIndex] ?? "",
+								dispatchMode === "chain" ? nextIndex + 1 : undefined,
+							),
+						];
+					}
+				}
+
+				const agentsForFailure = dispatchAgents.length > 0 ? dispatchAgents : ["unknown"];
+				return agentsForFailure.map((agent, index) =>
+					makeFailureResult(
+						err,
+						agent,
+						dispatchTasks[index] ?? "",
+						dispatchMode === "chain" ? index + 1 : undefined,
+					),
+				);
+			};
+			const finishDispatch = (results: SingleResult[]): void => {
+				if (dispatchCompletedEmitted) return;
+				finalResults = results;
+				dispatchCompletedEmitted = true;
+				const successCount = results.filter((r) => r.exitCode === 0).length;
+				const failureCount = results.filter((r) => r.exitCode !== 0).length;
+				const totalCost = results.reduce((s, r) => s + (r.usage?.cost ?? 0), 0);
+				const totalInputTokens = results.reduce((s, r) => s + (r.usage?.input ?? 0), 0);
+				const totalOutputTokens = results.reduce((s, r) => s + (r.usage?.output ?? 0), 0);
+				emitJournalEvent(ctx.cwd, {
+					ts: new Date().toISOString(),
+					flowId: dispatchId,
+					seq: 1,
+					eventType: "subagent-completed",
+					data: {
+						dispatchId,
+						mode: dispatchMode,
+						agents: dispatchAgents,
+						successCount,
+						failureCount,
+						totalCost,
+						totalInputTokens,
+						totalOutputTokens,
+						wallTimeMs: Date.now() - dispatchStartMs,
+					},
+				});
+			};
+
+			try {
 			if ((agentScope === "project" || agentScope === "both") && confirmProjectAgents && ctx.hasUI) {
 				const requestedAgentNames = new Set<string>();
 				if (params.chain) for (const step of params.chain) requestedAgentNames.add(step.agent);
@@ -726,16 +864,19 @@ export default function (pi: ExtensionAPI) {
 						"Run project-local agents?",
 						`Agents: ${names}\nSource: ${dir}\n\nProject agents are repo-controlled. Only continue for trusted repositories.`,
 					);
-					if (!ok)
+					if (!ok) {
+						finishDispatch([]);
 						return {
 							content: [{ type: "text", text: "Canceled: project-local agents not approved." }],
 							details: makeDetails(hasChain ? "chain" : hasTasks ? "parallel" : "single")([]),
 						};
+					}
 				}
 			}
 
 			if (params.chain && params.chain.length > 0) {
 				const results: SingleResult[] = [];
+				finalResults = results;
 				let previousOutput = "";
 
 				for (let i = 0; i < params.chain.length; i++) {
@@ -775,6 +916,7 @@ export default function (pi: ExtensionAPI) {
 					if (isError) {
 						const errorMsg =
 							result.errorMessage || result.stderr || getFinalOutput(result.messages) || "(no output)";
+						finishDispatch(results);
 						return {
 							content: [{ type: "text", text: `Chain stopped at step ${i + 1} (${step.agent}): ${errorMsg}` }],
 							details: makeDetails("chain")(results),
@@ -783,6 +925,7 @@ export default function (pi: ExtensionAPI) {
 					}
 					previousOutput = getFinalOutput(result.messages);
 				}
+				finishDispatch(results);
 				return {
 					content: [{ type: "text", text: getFinalOutput(results[results.length - 1].messages) || "(no output)" }],
 					details: makeDetails("chain")(results),
@@ -790,7 +933,8 @@ export default function (pi: ExtensionAPI) {
 			}
 
 			if (params.tasks && params.tasks.length > 0) {
-				if (params.tasks.length > MAX_PARALLEL_TASKS)
+				if (params.tasks.length > MAX_PARALLEL_TASKS) {
+					finishDispatch([]);
 					return {
 						content: [
 							{
@@ -800,6 +944,7 @@ export default function (pi: ExtensionAPI) {
 						],
 						details: makeDetails("parallel")([]),
 					};
+				}
 
 				// Track all results for streaming updates
 				const allResults: SingleResult[] = new Array(params.tasks.length);
@@ -816,6 +961,7 @@ export default function (pi: ExtensionAPI) {
 						usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, contextTokens: 0, turns: 0 },
 					};
 				}
+				finalResults = allResults;
 
 				const emitParallelUpdate = () => {
 					if (onUpdate) {
@@ -887,6 +1033,7 @@ export default function (pi: ExtensionAPI) {
 					emitParallelUpdate();
 					return result;
 				});
+				finalResults = results;
 
 				const successCount = results.filter((r) => r.exitCode === 0).length;
 				const summaries = results.map((r) => {
@@ -896,6 +1043,7 @@ export default function (pi: ExtensionAPI) {
 						: getFinalOutput(r.messages);
 					return `[${r.agent}] ${r.exitCode === 0 ? "completed" : `failed (exit ${r.exitCode})`}: ${output || "(no output)"}`;
 				});
+				finishDispatch(results);
 				return {
 					content: [
 						{
@@ -943,6 +1091,7 @@ export default function (pi: ExtensionAPI) {
 							onUpdate,
 							makeDetails("single"),
 						);
+					finalResults = [result];
 
 					// Capture and merge delta if isolated
 					if (isolation) {
@@ -956,6 +1105,7 @@ export default function (pi: ExtensionAPI) {
 					if (isError) {
 						const errorMsg =
 							result.errorMessage || result.stderr || getFinalOutput(result.messages) || "(no output)";
+						finishDispatch([result]);
 						return {
 							content: [{ type: "text", text: `Agent ${result.stopReason || "failed"}: ${errorMsg}` }],
 							details: makeDetails("single")([result]),
@@ -967,6 +1117,7 @@ export default function (pi: ExtensionAPI) {
 					if (mergeResult && !mergeResult.success) {
 						outputText += `\n\n⚠ Patch merge failed: ${mergeResult.error || "unknown error"}`;
 					}
+					finishDispatch([result]);
 					return {
 						content: [{ type: "text", text: outputText }],
 						details: makeDetails("single")([result]),
@@ -978,11 +1129,18 @@ export default function (pi: ExtensionAPI) {
 				}
 			}
 
+			finishDispatch([]);
 			const available = agents.map((a) => `${a.name} (${a.source})`).join(", ") || "none";
 			return {
 				content: [{ type: "text", text: `Invalid parameters. Available agents: ${available}` }],
 				details: makeDetails("single")([]),
 			};
+			} catch (err) {
+				if (!dispatchCompletedEmitted) finalResults = synthesizeFailureResults(err);
+				throw err;
+			} finally {
+				finishDispatch(finalResults);
+			}
 		},
 
 		renderCall(args, theme) {