@kodrunhq/opencode-autopilot 1.14.1 → 1.15.0

package/src/tools/orchestrate.ts

@@ -1,14 +1,17 @@
+import { randomBytes } from "node:crypto";
 import { join } from "node:path";
 import { tool } from "@opencode-ai/plugin";
+import { parseResultEnvelope } from "../orchestrator/contracts/legacy-result-adapter";
+import type { ResultEnvelope } from "../orchestrator/contracts/result-envelope";
 import { PHASE_HANDLERS } from "../orchestrator/handlers/index";
-import type { DispatchResult } from "../orchestrator/handlers/types";
+import type { DispatchResult, PhaseHandlerContext } from "../orchestrator/handlers/types";
 import { buildLessonContext } from "../orchestrator/lesson-injection";
 import { loadLessonMemory } from "../orchestrator/lesson-memory";
 import { logOrchestrationEvent } from "../orchestrator/orchestration-logger";
 import { completePhase, getNextPhase, PHASE_INDEX, TOTAL_PHASES } from "../orchestrator/phase";
 import { loadAdaptiveSkillContext } from "../orchestrator/skill-injection";
 import { createInitialState, loadState, patchState, saveState } from "../orchestrator/state";
-import type { Phase, PipelineState } from "../orchestrator/types";
+import type { PendingDispatch, Phase, PipelineState } from "../orchestrator/types";
 import { isEnoentError } from "../utils/fs-helpers";
 import { ensureGitignore } from "../utils/gitignore";
 import { getGlobalConfigDir, getProjectArtifactDir } from "../utils/paths";
@@ -19,6 +22,180 @@ interface OrchestrateArgs {
 	readonly result?: string;
 }
 
+const ORCHESTRATE_ERROR_CODES = Object.freeze({
+	INVALID_RESULT: "E_INVALID_RESULT",
+	STALE_RESULT: "E_STALE_RESULT",
+	PHASE_MISMATCH: "E_PHASE_MISMATCH",
+	UNKNOWN_DISPATCH: "E_UNKNOWN_DISPATCH",
+	DUPLICATE_RESULT: "E_DUPLICATE_RESULT",
+});
+
+function createDispatchId(): string {
+	return `dispatch_${randomBytes(6).toString("hex")}`;
+}
+
+function findPendingDispatch(
+	state: Readonly<PipelineState>,
+	dispatchId: string,
+): PendingDispatch | null {
+	return state.pendingDispatches.find((entry) => entry.dispatchId === dispatchId) ?? null;
+}
+
+function withPendingDispatch(
+	state: Readonly<PipelineState>,
+	entry: PendingDispatch,
+): PipelineState {
+	return patchState(state, {
+		pendingDispatches: [...state.pendingDispatches, entry],
+	});
+}
+
+function removePendingDispatch(state: Readonly<PipelineState>, dispatchId: string): PipelineState {
+	return patchState(state, {
+		pendingDispatches: state.pendingDispatches.filter((entry) => entry.dispatchId !== dispatchId),
+	});
+}
+
+function markResultProcessed(
+	state: Readonly<PipelineState>,
+	envelope: ResultEnvelope,
+): PipelineState {
+	if (state.processedResultIds.includes(envelope.resultId)) {
+		return state;
+	}
+	const capped = [...state.processedResultIds, envelope.resultId];
+	const nextIds = capped.length > 5000 ? capped.slice(capped.length - 5000) : capped;
+	return patchState(state, {
+		processedResultIds: nextIds,
+	});
+}
+
+function asErrorJson(code: string, message: string): string {
+	return JSON.stringify({ action: "error", code, message });
+}
+
+function logDeterministicError(
+	artifactDir: string,
+	phase: string,
+	code: string,
+	message: string,
+): void {
+	logOrchestrationEvent(artifactDir, {
+		timestamp: new Date().toISOString(),
+		phase,
+		action: "error",
+		message: `${code}: ${message}`.slice(0, 500),
+	});
+}
+
+function inferExpectedResultKindForAgent(
+	agent?: string,
+): "phase_output" | "task_completion" | "review_findings" {
+	if (agent === "oc-reviewer") {
+		return "review_findings";
+	}
+	if (agent === "oc-implementer") {
+		return "task_completion";
+	}
+	return "phase_output";
+}
+
+function ensureDispatchIdentity(
+	handlerResult: DispatchResult,
+	state: Readonly<PipelineState>,
+): DispatchResult {
+	if (handlerResult.action === "dispatch") {
+		const dispatchId = handlerResult.dispatchId ?? createDispatchId();
+		return {
+			...handlerResult,
+			dispatchId,
+			runId: state.runId,
+			expectedResultKind:
+				handlerResult.expectedResultKind ??
+				handlerResult.resultKind ??
+				inferExpectedResultKindForAgent(handlerResult.agent),
+		};
+	}
+
+	if (handlerResult.action === "dispatch_multi") {
+		return {
+			...handlerResult,
+			runId: state.runId,
+			agents: handlerResult.agents?.map((entry) => ({
+				...entry,
+				dispatchId: entry.dispatchId ?? createDispatchId(),
+				resultKind: entry.resultKind ?? inferExpectedResultKindForAgent(entry.agent),
+			})),
+		};
+	}
+
+	return handlerResult;
+}
+
+function detectPhaseFromPending(state: Readonly<PipelineState>): Phase | null {
+	const last = state.pendingDispatches.at(-1);
+	return (last?.phase as Phase | undefined) ?? state.currentPhase;
+}
+
+function detectAgentFromPending(state: Readonly<PipelineState>): string | null {
+	const last = state.pendingDispatches.at(-1);
+	return last?.agent ?? null;
+}
+
+function detectDispatchFromPending(state: Readonly<PipelineState>): string {
+	const last = state.pendingDispatches.at(-1);
+	return last?.dispatchId ?? "legacy-dispatch";
+}
+
+function applyResultEnvelope(
+	state: Readonly<PipelineState>,
+	envelope: ResultEnvelope,
+	options?: { readonly allowMissingPending?: boolean },
+): PipelineState {
+	if (state.processedResultIds.includes(envelope.resultId)) {
+		throw new Error(
+			`${ORCHESTRATE_ERROR_CODES.DUPLICATE_RESULT}: duplicate resultId ${envelope.resultId}`,
+		);
+	}
+
+	const pending = findPendingDispatch(state, envelope.dispatchId);
+	if (pending === null) {
+		if (options?.allowMissingPending) {
+			return markResultProcessed(state, envelope);
+		}
+		throw new Error(
+			`${ORCHESTRATE_ERROR_CODES.UNKNOWN_DISPATCH}: unknown dispatchId ${envelope.dispatchId}`,
+		);
+	}
+	if (pending.phase !== envelope.phase) {
+		throw new Error(
+			`${ORCHESTRATE_ERROR_CODES.PHASE_MISMATCH}: result phase ${envelope.phase} != pending ${pending.phase}`,
+		);
+	}
+	if (pending.taskId !== null && envelope.taskId !== pending.taskId) {
+		throw new Error(
+			`${ORCHESTRATE_ERROR_CODES.PHASE_MISMATCH}: taskId ${String(envelope.taskId)} != pending ${pending.taskId}`,
+		);
+	}
+
+	const withoutPending = removePendingDispatch(state, envelope.dispatchId);
+	return markResultProcessed(withoutPending, envelope);
+}
+
+function parseErrorCode(error: unknown): { readonly code: string; readonly message: string } {
+	const message = error instanceof Error ? error.message : String(error);
+	const idx = message.indexOf(":");
+	if (idx <= 0) {
+		return { code: ORCHESTRATE_ERROR_CODES.INVALID_RESULT, message };
+	}
+	const maybeCode = message.slice(0, idx);
+	const rest = message.slice(idx + 1).trim();
+	if (!maybeCode.startsWith("E_")) {
+		return { code: ORCHESTRATE_ERROR_CODES.INVALID_RESULT, message };
+	}
+	return { code: maybeCode, message: rest.length > 0 ? rest : message };
+}
+
 /**
  * Apply state updates from a DispatchResult if present, then save.
  * Returns the updated state.
@@ -148,7 +325,11 @@ async function checkCircuitBreaker(
 	currentState: Readonly<PipelineState>,
 	phase: string,
 	artifactDir: string,
-): Promise<{ readonly abortMsg: string | null; readonly newCount: number }> {
+): Promise<{
+	readonly abortMsg: string | null;
+	readonly newCount: number;
+	readonly nextState: PipelineState;
+}> {
 	const counts = { ...(currentState.phaseDispatchCounts ?? {}) };
 	counts[phase] = (counts[phase] ?? 0) + 1;
 	const newCount = counts[phase];
@@ -162,11 +343,15 @@ async function checkCircuitBreaker(
 			attempt: newCount,
 			message: msg,
 		});
-		return { abortMsg: JSON.stringify({ action: "error", message: msg }), newCount };
+		return {
+			abortMsg: JSON.stringify({ action: "error", message: msg }),
+			newCount,
+			nextState: currentState,
+		};
 	}
 	const withCounts = patchState(currentState, { phaseDispatchCounts: counts });
 	await saveState(withCounts, artifactDir);
-	return { abortMsg: null, newCount };
+	return { abortMsg: null, newCount, nextState: withCounts };
 }
 
 /**
@@ -178,48 +363,95 @@ async function processHandlerResult(
 	state: Readonly<PipelineState>,
 	artifactDir: string,
 ): Promise<string> {
+	const normalizedResult = ensureDispatchIdentity(handlerResult, state);
+
 	// Apply state updates from handler if present
-	const currentState = await applyStateUpdates(state, handlerResult, artifactDir);
+	let currentState = await applyStateUpdates(state, normalizedResult, artifactDir);
 
-	switch (handlerResult.action) {
-		case "error":
+	switch (normalizedResult.action) {
+		case "error": {
+			const codePrefix = normalizedResult.code ? `${normalizedResult.code}: ` : "";
+			const messageBody = normalizedResult.message ?? "Handler returned error";
 			logOrchestrationEvent(artifactDir, {
 				timestamp: new Date().toISOString(),
-				phase: handlerResult.phase ?? currentState.currentPhase ?? "UNKNOWN",
+				phase: normalizedResult.phase ?? currentState.currentPhase ?? "UNKNOWN",
 				action: "error",
-				message: handlerResult.message?.slice(0, 500),
+				message: `${codePrefix}${messageBody}`.slice(0, 500),
 			});
-			return JSON.stringify(handlerResult);
+			return JSON.stringify(normalizedResult);
+		}
 
 		case "dispatch": {
 			// Circuit breaker
-			const phase = handlerResult.phase ?? currentState.currentPhase ?? "UNKNOWN";
-			const { abortMsg, newCount: attempt } = await checkCircuitBreaker(
-				currentState,
-				phase,
-				artifactDir,
-			);
+			const phase = normalizedResult.phase ?? currentState.currentPhase ?? "UNKNOWN";
+			const {
+				abortMsg,
+				newCount: attempt,
+				nextState,
+			} = await checkCircuitBreaker(currentState, phase, artifactDir);
 			if (abortMsg) return abortMsg;
+			currentState = nextState;
+
+			const pendingEntry: PendingDispatch = {
+				dispatchId: normalizedResult.dispatchId ?? createDispatchId(),
+				phase: phase as Phase,
+				agent: normalizedResult.agent ?? "unknown",
+				issuedAt: new Date().toISOString(),
+				resultKind: normalizedResult.expectedResultKind ?? "phase_output",
+				taskId: normalizedResult.taskId ?? null,
+			};
+			const baseRevision = currentState.stateRevision;
+			const withPendingState = withPendingDispatch(currentState, pendingEntry);
 
 			// Log the dispatch event before any inline-review or context injection
-			const progress = buildUserProgress(phase, handlerResult.progress, attempt);
+			const progress = buildUserProgress(phase, normalizedResult.progress, attempt);
 			logOrchestrationEvent(artifactDir, {
 				timestamp: new Date().toISOString(),
 				phase,
 				action: "dispatch",
-				agent: handlerResult.agent,
-				promptLength: handlerResult.prompt?.length,
+				agent: normalizedResult.agent,
+				promptLength: normalizedResult.prompt?.length,
 				attempt,
 			});
 
 			// Check if this is a review dispatch that should be inlined
-			const { inlined, reviewResult } = await maybeInlineReview(handlerResult, artifactDir);
+			const { inlined, reviewResult } = await maybeInlineReview(normalizedResult, artifactDir);
 			if (inlined && reviewResult) {
-				const reloadedState = await loadState(artifactDir);
-				if (reloadedState?.currentPhase) {
-					const handler = PHASE_HANDLERS[reloadedState.currentPhase];
-					const nextResult = await handler(reloadedState, artifactDir, reviewResult);
-					return processHandlerResult(nextResult, reloadedState, artifactDir);
+				if (withPendingState.currentPhase) {
+					let reviewPayloadText = reviewResult;
+					try {
+						const parsedReview = JSON.parse(reviewResult) as {
+							findingsEnvelope?: unknown;
+						};
+						if (parsedReview.findingsEnvelope) {
+							reviewPayloadText = JSON.stringify(parsedReview.findingsEnvelope);
+						}
+					} catch {
+						// keep raw review payload for legacy parser
+					}
+
+					const inlinedEnvelope: ResultEnvelope = {
+						schemaVersion: 1,
+						resultId: `inline-${createDispatchId()}`,
+						runId: withPendingState.runId,
+						phase: withPendingState.currentPhase,
+						dispatchId: pendingEntry.dispatchId,
+						agent: normalizedResult.agent ?? null,
+						kind: "review_findings",
+						taskId: normalizedResult.taskId ?? null,
+						payload: {
+							text: reviewPayloadText,
+						},
+					};
+					const withInlineResult = applyResultEnvelope(withPendingState, inlinedEnvelope);
+					await saveState(withInlineResult, artifactDir, baseRevision);
+
+					const handler = PHASE_HANDLERS[withPendingState.currentPhase];
+					const nextResult = await handler(withInlineResult, artifactDir, reviewPayloadText, {
+						envelope: inlinedEnvelope,
+						legacy: false,
+					});
+					return processHandlerResult(nextResult, withInlineResult, artifactDir);
 				}
 				// State unavailable or pipeline completed after inline review — return complete
 				return JSON.stringify({
@@ -228,67 +460,105 @@ async function processHandlerResult(
 					_userProgress: progress,
 				});
 			}
+
+			await saveState(withPendingState, artifactDir, baseRevision);
+			currentState = withPendingState;
+
 			// Inject lesson + skill context into dispatch prompt (best-effort)
-			if (handlerResult.prompt && handlerResult.phase) {
+			if (normalizedResult.prompt && normalizedResult.phase) {
 				const enrichedPrompt = await injectLessonContext(
-					handlerResult.prompt,
-					handlerResult.phase,
+					normalizedResult.prompt,
+					normalizedResult.phase,
 					artifactDir,
 				);
 				const withSkills = await injectSkillContext(
 					enrichedPrompt,
 					join(artifactDir, ".."),
-					handlerResult.phase,
+					normalizedResult.phase,
 				);
-				if (withSkills !== handlerResult.prompt) {
-					return JSON.stringify({ ...handlerResult, prompt: withSkills, _userProgress: progress });
+				if (withSkills !== normalizedResult.prompt) {
+					return JSON.stringify({
+						...normalizedResult,
+						prompt: withSkills,
+						dispatchId: pendingEntry.dispatchId,
+						runId: currentState.runId,
+						_userProgress: progress,
+					});
 				}
 			}
-			return JSON.stringify({ ...handlerResult, _userProgress: progress });
+			return JSON.stringify({
+				...normalizedResult,
+				dispatchId: pendingEntry.dispatchId,
+				runId: currentState.runId,
+				_userProgress: progress,
+			});
 		}
 
 		case "dispatch_multi": {
 			// Circuit breaker
-			const phase = handlerResult.phase ?? currentState.currentPhase ?? "UNKNOWN";
-			const { abortMsg, newCount: attempt } = await checkCircuitBreaker(
-				currentState,
-				phase,
-				artifactDir,
-			);
+			const phase = normalizedResult.phase ?? currentState.currentPhase ?? "UNKNOWN";
+			const {
+				abortMsg,
+				newCount: attempt,
+				nextState,
+			} = await checkCircuitBreaker(currentState, phase, artifactDir);
 			if (abortMsg) return abortMsg;
+			currentState = nextState;
+
+			const pendingEntries: readonly PendingDispatch[] =
+				normalizedResult.agents?.map((entry) => ({
+					dispatchId: entry.dispatchId ?? createDispatchId(),
+					phase: phase as Phase,
+					agent: entry.agent,
+					issuedAt: new Date().toISOString(),
+					resultKind: entry.resultKind ?? inferExpectedResultKindForAgent(entry.agent),
+					taskId: entry.taskId ?? null,
+				})) ?? [];
+			const baseRevision = currentState.stateRevision;
+			let withPendingState = currentState;
+			for (const entry of pendingEntries) {
+				withPendingState = withPendingDispatch(withPendingState, entry);
+			}
 
-			const progress = buildUserProgress(phase, handlerResult.progress, attempt);
+			const progress = buildUserProgress(phase, normalizedResult.progress, attempt);
 			logOrchestrationEvent(artifactDir, {
 				timestamp: new Date().toISOString(),
 				phase,
 				action: "dispatch_multi",
-				agent: `${handlerResult.agents?.length ?? 0} agents`,
+				agent: `${normalizedResult.agents?.length ?? 0} agents`,
 				attempt,
 			});
+			await saveState(withPendingState, artifactDir, baseRevision);
+			currentState = withPendingState;
 
 			// Inject lesson + skill context into each agent's prompt (best-effort)
 			// Load lesson and skill context once and reuse for all agents in the batch
-			if (handlerResult.agents && handlerResult.phase) {
-				const lessonSuffix = await injectLessonContext("", handlerResult.phase, artifactDir);
+			if (normalizedResult.agents && normalizedResult.phase) {
+				const lessonSuffix = await injectLessonContext("", normalizedResult.phase, artifactDir);
 				const skillSuffix = await injectSkillContext(
 					"",
 					join(artifactDir, ".."),
-					handlerResult.phase,
+					normalizedResult.phase,
 				);
 				const combinedSuffix = lessonSuffix + (skillSuffix || "");
 				if (combinedSuffix) {
-					const enrichedAgents = handlerResult.agents.map((entry) => ({
+					const enrichedAgents = normalizedResult.agents.map((entry) => ({
 						...entry,
 						prompt: entry.prompt + combinedSuffix,
 					}));
 					return JSON.stringify({
-						...handlerResult,
+						...normalizedResult,
 						agents: enrichedAgents,
+						runId: currentState.runId,
 						_userProgress: progress,
 					});
 				}
 			}
-			return JSON.stringify({ ...handlerResult, _userProgress: progress });
+			return JSON.stringify({
+				...normalizedResult,
+				runId: currentState.runId,
+				_userProgress: progress,
+			});
 		}
 
 		case "complete": {
@@ -306,7 +576,6 @@ async function processHandlerResult(
 			});
 			const nextPhase = getNextPhase(currentState.currentPhase);
 			const advanced = completePhase(currentState);
-			await saveState(advanced, artifactDir);
 
 			if (nextPhase === null) {
 				// Terminal phase completed
@@ -320,9 +589,11 @@ async function processHandlerResult(
 				});
 			}
 
+			await saveState(advanced, artifactDir);
+
 			// Invoke the next phase handler immediately
 			const nextHandler = PHASE_HANDLERS[nextPhase];
-			const nextResult = await nextHandler(advanced, artifactDir);
+			const nextResult = await nextHandler(advanced, artifactDir, undefined, undefined);
 			return processHandlerResult(nextResult, advanced, artifactDir);
 		}
 
@@ -336,7 +607,7 @@ async function processHandlerResult(
 
 export async function orchestrateCore(args: OrchestrateArgs, artifactDir: string): Promise<string> {
 	try {
-		const state = await loadState(artifactDir);
+		let state = await loadState(artifactDir);
 
 		// No state and no idea -> error
 		if (state === null && !args.idea) {
@@ -360,13 +631,15 @@ export async function orchestrateCore(args: OrchestrateArgs, artifactDir: string
 			}
 
 			const handler = PHASE_HANDLERS[newState.currentPhase as Phase];
-			const handlerResult = await handler(newState, artifactDir);
+			const handlerResult = await handler(newState, artifactDir, undefined, undefined);
 			return processHandlerResult(handlerResult, newState, artifactDir);
 		}
 
 		// State exists
 		if (state !== null) {
-			// Pipeline already completed
+			let phaseHandlerContext: PhaseHandlerContext | undefined;
+			let handlerInputResult = args.result;
+
 			if (state.currentPhase === null) {
 				return JSON.stringify({
 					action: "complete",
@@ -374,15 +647,106 @@ export async function orchestrateCore(args: OrchestrateArgs, artifactDir: string
 				});
 			}
 
+			if (typeof args.result === "string") {
+				const phaseHint = detectPhaseFromPending(state);
+				if (phaseHint === null) {
+					const msg = "Received result but no pending dispatch exists.";
+					logDeterministicError(
+						artifactDir,
+						state.currentPhase ?? "UNKNOWN",
+						ORCHESTRATE_ERROR_CODES.STALE_RESULT,
+						msg,
+					);
+					return asErrorJson(ORCHESTRATE_ERROR_CODES.STALE_RESULT, msg);
+				}
+
+				try {
+					const parsed = parseResultEnvelope(args.result, {
+						runId: state.runId,
+						phase: phaseHint,
+						fallbackDispatchId: detectDispatchFromPending(state),
+						fallbackAgent: detectAgentFromPending(state),
+					});
+
+					if (parsed.envelope.runId !== state.runId) {
+						const msg = `Result runId ${parsed.envelope.runId} does not match active run ${state.runId}.`;
+						logDeterministicError(
+							artifactDir,
+							state.currentPhase ?? phaseHint,
+							ORCHESTRATE_ERROR_CODES.STALE_RESULT,
+							msg,
+						);
+						return asErrorJson(ORCHESTRATE_ERROR_CODES.STALE_RESULT, msg);
+					}
+
+					if (parsed.legacy && state.pendingDispatches.length > 1) {
+						const msg =
+							"Legacy result payload cannot be attributed with multiple pending dispatches. Provide typed envelope with dispatchId/taskId.";
+						logDeterministicError(
+							artifactDir,
+							state.currentPhase ?? phaseHint,
+							ORCHESTRATE_ERROR_CODES.INVALID_RESULT,
+							msg,
+						);
+						return asErrorJson(ORCHESTRATE_ERROR_CODES.INVALID_RESULT, msg);
+					}
+
+					const allowMissingPending = parsed.legacy && state.pendingDispatches.length === 0;
+					const nextState = applyResultEnvelope(state, parsed.envelope, {
+						allowMissingPending,
+					});
+					await saveState(nextState, artifactDir);
+					state = nextState;
+					if (!allowMissingPending && parsed.legacy) {
+						const legacyMsg =
+							"Legacy result parser path used. Submit typed envelopes for deterministic replay guarantees.";
+						logOrchestrationEvent(artifactDir, {
+							timestamp: new Date().toISOString(),
+							phase: state.currentPhase ?? phaseHint,
+							action: "error",
+							message: legacyMsg,
+						});
+						console.warn(`[opencode-autopilot] ${legacyMsg}`);
+					}
+
+					phaseHandlerContext = {
+						envelope: parsed.envelope,
+						legacy: parsed.legacy,
+					};
+					handlerInputResult = parsed.envelope.payload.text;
+				} catch (error: unknown) {
+					const parsedErr = parseErrorCode(error);
+					logOrchestrationEvent(artifactDir, {
+						timestamp: new Date().toISOString(),
+						phase: state.currentPhase ?? "UNKNOWN",
+						action: "error",
+						message: `${parsedErr.code}: ${parsedErr.message}`,
+					});
+					return asErrorJson(parsedErr.code, parsedErr.message);
+				}
+			}
+
 			// Delegate to current phase handler
+			if (state.currentPhase === null) {
+				return JSON.stringify({
+					action: "complete",
+					summary: `Pipeline already completed. Idea: ${state.idea}`,
+				});
+			}
 			const handler = PHASE_HANDLERS[state.currentPhase];
-			const handlerResult = await handler(state, artifactDir, args.result);
+			const handlerResult = await handler(
+				state,
+				artifactDir,
+				handlerInputResult,
+				phaseHandlerContext,
+			);
 			return processHandlerResult(handlerResult, state, artifactDir);
 		}
 
 		return JSON.stringify({ action: "error", message: "Unexpected state" });
 	} catch (error: unknown) {
 		const message = error instanceof Error ? error.message : String(error);
+		const parsedErr = parseErrorCode(error);
 		const safeMessage = message.replace(/[/\\][^\s"']+/g, "[PATH]").slice(0, 4096);
 
 		// Persist failure metadata for forensics (best-effort)
@@ -407,7 +771,7 @@ export async function orchestrateCore(args: OrchestrateArgs, artifactDir: string
 			// Swallow save errors -- original error takes priority
 		}
 
-		return JSON.stringify({ action: "error", message: safeMessage });
+		return JSON.stringify({ action: "error", code: parsedErr.code, message: safeMessage });
 	}
 }
 

package/src/tools/quick.ts

@@ -49,6 +49,8 @@ export async function quickCore(args: QuickArgs, artifactDir: string): Promise<s
 	const quickState = pipelineStateSchema.parse({
 		schemaVersion: 2,
 		status: "IN_PROGRESS",
+		runId: `quick-${Date.now()}`,
+		stateRevision: 0,
 		idea: args.idea,
 		currentPhase: "PLAN",
 		startedAt: now,
@@ -71,6 +73,8 @@ export async function quickCore(args: QuickArgs, artifactDir: string): Promise<s
 		tasks: [],
 		arenaConfidence: null,
 		exploreTriggered: false,
+		pendingDispatches: [],
+		processedResultIds: [],
 	});
 
 	// 4. Persist quick state to disk