@kodrunhq/opencode-autopilot 1.12.2 → 1.14.0

package/src/tools/orchestrate.ts

@@ -4,10 +4,11 @@ import { PHASE_HANDLERS } from "../orchestrator/handlers/index";
 import type { DispatchResult } from "../orchestrator/handlers/types";
 import { buildLessonContext } from "../orchestrator/lesson-injection";
 import { loadLessonMemory } from "../orchestrator/lesson-memory";
-import { completePhase, getNextPhase } from "../orchestrator/phase";
+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 } from "../orchestrator/types";
+import type { Phase, PipelineState } from "../orchestrator/types";
 import { isEnoentError } from "../utils/fs-helpers";
 import { ensureGitignore } from "../utils/gitignore";
 import { getGlobalConfigDir, getProjectArtifactDir } from "../utils/paths";
@@ -23,10 +24,10 @@ interface OrchestrateArgs {
  * Returns the updated state.
  */
 async function applyStateUpdates(
-	state: Readonly<import("../orchestrator/types").PipelineState>,
+	state: Readonly<PipelineState>,
 	handlerResult: DispatchResult,
 	artifactDir: string,
-): Promise<import("../orchestrator/types").PipelineState> {
+): Promise<PipelineState> {
 	const updates = handlerResult._stateUpdates;
 	if (updates) {
 		const updated = patchState(state, updates);
@@ -99,10 +100,18 @@ async function injectLessonContext(
  * Attempt to inject stack-filtered adaptive skill context into a dispatch prompt.
  * Best-effort: failures are silently swallowed to avoid breaking dispatch.
  */
-async function injectSkillContext(prompt: string, projectRoot?: string): Promise<string> {
+async function injectSkillContext(
+	prompt: string,
+	projectRoot?: string,
+	phase?: string,
+): Promise<string> {
 	try {
 		const baseDir = getGlobalConfigDir();
-		const ctx = await loadAdaptiveSkillContext(baseDir, projectRoot ?? process.cwd());
+		const ctx = await loadAdaptiveSkillContext(baseDir, projectRoot ?? process.cwd(), {
+			phase,
+			budget: 1500,
+			mode: "summary",
+		});
 		if (ctx) return prompt + ctx;
 	} catch (err) {
 		console.warn("[opencode-autopilot] skill injection failed:", err);
@@ -110,13 +119,63 @@ async function injectSkillContext(prompt: string, projectRoot?: string): Promise
 	return prompt;
 }
 
+/** Build a human-readable progress string for user-facing display. */
+function buildUserProgress(phase: string, label?: string, attempt?: number): string {
+	const idx = PHASE_INDEX[phase as Phase] ?? 0;
+	const desc = label ?? "dispatching";
+	const att = attempt != null ? ` (attempt ${attempt})` : "";
+	return `Phase ${idx}/${TOTAL_PHASES}: ${phase} — ${desc}${att}`;
+}
+
+/** Per-phase dispatch limits. BUILD is high because of multi-task waves. */
+const MAX_PHASE_DISPATCHES: Readonly<Record<string, number>> = Object.freeze({
+	RECON: 3,
+	CHALLENGE: 3,
+	ARCHITECT: 10,
+	EXPLORE: 3,
+	PLAN: 5,
+	BUILD: 100,
+	SHIP: 5,
+	RETROSPECTIVE: 3,
+});
+
+/**
+ * Circuit breaker: increment per-phase dispatch count and abort if limit exceeded.
+ * Returns `{ abortMsg, newCount }`. When `abortMsg` is non-null the caller must
+ * return it immediately. `newCount` is the authoritative post-increment value.
+ */
+async function checkCircuitBreaker(
+	currentState: Readonly<PipelineState>,
+	phase: string,
+	artifactDir: string,
+): Promise<{ readonly abortMsg: string | null; readonly newCount: number }> {
+	const counts = { ...(currentState.phaseDispatchCounts ?? {}) };
+	counts[phase] = (counts[phase] ?? 0) + 1;
+	const newCount = counts[phase];
+	const limit = MAX_PHASE_DISPATCHES[phase] ?? 5;
+	if (newCount > limit) {
+		const msg = `Phase ${phase} exceeded max dispatches (${newCount}/${limit}) — possible infinite loop detected. Aborting.`;
+		logOrchestrationEvent(artifactDir, {
+			timestamp: new Date().toISOString(),
+			phase,
+			action: "loop_detected",
+			attempt: newCount,
+			message: msg,
+		});
+		return { abortMsg: JSON.stringify({ action: "error", message: msg }), newCount };
+	}
+	const withCounts = patchState(currentState, { phaseDispatchCounts: counts });
+	await saveState(withCounts, artifactDir);
+	return { abortMsg: null, newCount };
+}
+
 /**
  * Process a handler's DispatchResult, handling complete/dispatch/dispatch_multi/error.
  * On complete, advances the phase and invokes the next handler.
  */
 async function processHandlerResult(
 	handlerResult: DispatchResult,
-	state: Readonly<import("../orchestrator/types").PipelineState>,
+	state: Readonly<PipelineState>,
 	artifactDir: string,
 ): Promise<string> {
 	// Apply state updates from handler if present
@@ -124,19 +183,50 @@ async function processHandlerResult(
 
 	switch (handlerResult.action) {
 		case "error":
+			logOrchestrationEvent(artifactDir, {
+				timestamp: new Date().toISOString(),
+				phase: handlerResult.phase ?? currentState.currentPhase ?? "UNKNOWN",
+				action: "error",
+				message: handlerResult.message?.slice(0, 500),
+			});
 			return JSON.stringify(handlerResult);
 
 		case "dispatch": {
+			// Circuit breaker
+			const phase = handlerResult.phase ?? currentState.currentPhase ?? "UNKNOWN";
+			const { abortMsg, newCount: attempt } = await checkCircuitBreaker(
+				currentState,
+				phase,
+				artifactDir,
+			);
+			if (abortMsg) return abortMsg;
+
+			// Log the dispatch event before any inline-review or context injection
+			const progress = buildUserProgress(phase, handlerResult.progress, attempt);
+			logOrchestrationEvent(artifactDir, {
+				timestamp: new Date().toISOString(),
+				phase,
+				action: "dispatch",
+				agent: handlerResult.agent,
+				promptLength: handlerResult.prompt?.length,
+				attempt,
+			});
+
 			// Check if this is a review dispatch that should be inlined
 			const { inlined, reviewResult } = await maybeInlineReview(handlerResult, artifactDir);
 			if (inlined && reviewResult) {
-				// Feed the review result back into the current phase handler
 				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);
 				}
+				// State unavailable or pipeline completed after inline review — return complete
+				return JSON.stringify({
+					action: "complete",
+					summary: "Inline review completed; no active phase.",
+					_userProgress: progress,
+				});
 			}
 			// Inject lesson + skill context into dispatch prompt (best-effort)
 			if (handlerResult.prompt && handlerResult.phase) {
@@ -145,34 +235,60 @@ async function processHandlerResult(
 					handlerResult.phase,
 					artifactDir,
 				);
-				const withSkills = await injectSkillContext(enrichedPrompt, join(artifactDir, ".."));
+				const withSkills = await injectSkillContext(
+					enrichedPrompt,
+					join(artifactDir, ".."),
+					handlerResult.phase,
+				);
 				if (withSkills !== handlerResult.prompt) {
-					return JSON.stringify({ ...handlerResult, prompt: withSkills });
+					return JSON.stringify({ ...handlerResult, prompt: withSkills, _userProgress: progress });
 				}
 			}
-			return JSON.stringify(handlerResult);
+			return JSON.stringify({ ...handlerResult, _userProgress: progress });
 		}
 
 		case "dispatch_multi": {
+			// Circuit breaker
+			const phase = handlerResult.phase ?? currentState.currentPhase ?? "UNKNOWN";
+			const { abortMsg, newCount: attempt } = await checkCircuitBreaker(
+				currentState,
+				phase,
+				artifactDir,
+			);
+			if (abortMsg) return abortMsg;
+
+			const progress = buildUserProgress(phase, handlerResult.progress, attempt);
+			logOrchestrationEvent(artifactDir, {
+				timestamp: new Date().toISOString(),
+				phase,
+				action: "dispatch_multi",
+				agent: `${handlerResult.agents?.length ?? 0} agents`,
+				attempt,
+			});
+
 			// 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(
+				const lessonSuffix = await injectLessonContext("", handlerResult.phase, artifactDir);
+				const skillSuffix = await injectSkillContext(
 					"",
-					handlerResult.phase as string,
-					artifactDir,
+					join(artifactDir, ".."),
+					handlerResult.phase,
 				);
-				const skillSuffix = await injectSkillContext("", join(artifactDir, ".."));
 				const combinedSuffix = lessonSuffix + (skillSuffix || "");
 				if (combinedSuffix) {
 					const enrichedAgents = handlerResult.agents.map((entry) => ({
 						...entry,
 						prompt: entry.prompt + combinedSuffix,
 					}));
-					return JSON.stringify({ ...handlerResult, agents: enrichedAgents });
+					return JSON.stringify({
+						...handlerResult,
+						agents: enrichedAgents,
+						_userProgress: progress,
+					});
 				}
 			}
-			return JSON.stringify(handlerResult);
+			return JSON.stringify({ ...handlerResult, _userProgress: progress });
 		}
 
 		case "complete": {
@@ -183,6 +299,11 @@ async function processHandlerResult(
 				});
 			}
 
+			logOrchestrationEvent(artifactDir, {
+				timestamp: new Date().toISOString(),
+				phase: currentState.currentPhase,
+				action: "complete",
+			});
 			const nextPhase = getNextPhase(currentState.currentPhase);
 			const advanced = completePhase(currentState);
 			await saveState(advanced, artifactDir);
@@ -191,9 +312,11 @@ async function processHandlerResult(
 				// Terminal phase completed
 				const finished = { ...advanced, status: "COMPLETED" as const };
 				await saveState(finished, artifactDir);
+				const idx = PHASE_INDEX[currentState.currentPhase] ?? TOTAL_PHASES;
 				return JSON.stringify({
 					action: "complete",
-					summary: `Pipeline completed all 8 phases. Idea: ${currentState.idea}`,
+					summary: `Pipeline completed all ${TOTAL_PHASES} phases. Idea: ${currentState.idea}`,
+					_userProgress: `Completed ${currentState.currentPhase} (${idx}/${TOTAL_PHASES}), pipeline finished`,
 				});
 			}
 

package/src/tools/review.ts

@@ -12,6 +12,7 @@
  */
 
 import { execFile } from "node:child_process";
+import { randomBytes } from "node:crypto";
 import { readFile, rename, unlink, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import { promisify } from "node:util";
@@ -110,7 +111,7 @@ async function saveReviewState(state: ReviewState, artifactDir: string): Promise
 	// Validate before writing (bidirectional validation, same as orchestrator state)
 	const validated = reviewStateSchema.parse(state);
 	const statePath = join(artifactDir, STATE_FILE);
-	const tmpPath = `${statePath}.tmp.${Date.now()}`;
+	const tmpPath = `${statePath}.tmp.${randomBytes(8).toString("hex")}`;
 	await writeFile(tmpPath, JSON.stringify(validated, null, 2), "utf-8");
 	await rename(tmpPath, statePath);
 }