gsd-pi 2.78.1-dev.84a383f51 → 2.78.1-dev.8a893322c

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) {