@kodrunhq/opencode-autopilot 1.12.2 → 1.14.1

package/src/skills/adaptive-injector.ts

@@ -18,6 +18,24 @@ const DEFAULT_TOKEN_BUDGET = 8000;
 /** Rough estimate: 1 token ~ 4 chars */
 const CHARS_PER_TOKEN = 4;
 
+/**
+ * Maps pipeline phases to the skill names relevant for that phase.
+ * Skills not in the list for the current phase are excluded from injection,
+ * preventing the full 13-19KB per-skill content from bloating every dispatch.
+ */
+export const PHASE_SKILL_MAP: Readonly<Record<string, readonly string[]>> = Object.freeze({
+	RECON: ["plan-writing"],
+	CHALLENGE: ["plan-writing"],
+	ARCHITECT: ["plan-writing"],
+	PLAN: ["plan-writing", "plan-executing"],
+	BUILD: ["coding-standards", "tdd-workflow"],
+	SHIP: ["plan-executing"],
+	RETROSPECTIVE: [],
+	EXPLORE: [],
+});
+
+export type SkillMode = "summary" | "full";
+
 /**
  * Manifest files that indicate project stack.
  * Checks project root for these files to detect the stack.
@@ -121,14 +139,40 @@ export function filterSkillsByStack(
 	return filtered;
 }
 
+/**
+ * Build a compact summary for a single skill: frontmatter name + description
+ * (max 200 chars). Used in summary mode to avoid injecting full skill content.
+ */
+export function buildSkillSummary(skill: LoadedSkill): string {
+	const { name, description } = skill.frontmatter;
+	const safeName = sanitizeTemplateContent(name);
+	const safeDesc = sanitizeTemplateContent((description ?? "").slice(0, 200));
+	return `[Skill: ${safeName}]\n${safeDesc}`;
+}
+
+/**
+ * In full mode, truncate skill content at the first `## ` heading boundary
+ * that exceeds the per-skill character budget. Preserves structure instead
+ * of collapsing all newlines.
+ */
+function truncateAtSectionBoundary(content: string, maxChars: number): string {
+	if (content.length <= maxChars) return content;
+	const cutPoint = content.lastIndexOf("\n## ", maxChars);
+	if (cutPoint > 0) return content.slice(0, cutPoint);
+	return content.slice(0, maxChars);
+}
+
 /**
  * Build multi-skill context string with dependency ordering and token budget.
  * Skills are ordered by dependency (prerequisites first), then concatenated
  * until the token budget is exhausted.
+ *
+ * @param mode - "summary" emits only name + description (compact); "full" preserves structure
  */
 export function buildMultiSkillContext(
 	skills: ReadonlyMap<string, LoadedSkill>,
 	tokenBudget: number = DEFAULT_TOKEN_BUDGET,
+	mode: SkillMode = "summary",
 ): string {
 	if (skills.size === 0) return "";
 
@@ -151,17 +195,64 @@ export function buildMultiSkillContext(
 		const skill = skills.get(name);
 		if (!skill) continue;
 
-		const collapsed = skill.content.replace(/[\r\n]+/g, " ");
-		const header = `[Skill: ${name}]\n`;
+		let section: string;
+		if (mode === "summary") {
+			section = sanitizeTemplateContent(buildSkillSummary(skill));
+		} else {
+			// Full mode: preserve structure, truncate at section boundaries
+			const header = `[Skill: ${name}]\n`;
+			const perSkillBudget = Math.max(charBudget - totalChars - header.length, 0);
+			const truncated = truncateAtSectionBoundary(skill.content, perSkillBudget);
+			const sanitized = sanitizeTemplateContent(truncated);
+			section = `${header}${sanitized}`;
+		}
+
 		const separator = sections.length > 0 ? 2 : 0; // "\n\n"
-		const sectionCost = collapsed.length + header.length + separator;
+		const sectionCost = section.length + separator;
 		if (totalChars + sectionCost > charBudget) break;
 
-		const sanitized = sanitizeTemplateContent(collapsed);
-		sections.push(`${header}${sanitized}`);
+		sections.push(section);
 		totalChars += sectionCost;
 	}
 
 	if (sections.length === 0) return "";
 	return `\n\nSkills context (follow these conventions and methodologies):\n${sections.join("\n\n")}`;
 }
+
+/**
+ * Build adaptive skill context with optional phase filtering.
+ *
+ * When `phase` is provided, only skills listed in PHASE_SKILL_MAP for that
+ * phase are included (pipeline dispatch path). When omitted, all stack-filtered
+ * skills are included (direct chat injection path).
+ */
+export function buildAdaptiveSkillContext(
+	skills: ReadonlyMap<string, LoadedSkill>,
+	options?: {
+		readonly phase?: string;
+		readonly budget?: number;
+		readonly mode?: SkillMode;
+	},
+): string {
+	const phase = options?.phase;
+	const budget = options?.budget ?? DEFAULT_TOKEN_BUDGET;
+	const mode = options?.mode ?? "summary";
+
+	if (phase !== undefined) {
+		const allowedNames = PHASE_SKILL_MAP[phase] ?? [];
+		if (allowedNames.length === 0) return "";
+
+		const allowedSet = new Set(allowedNames);
+		const filtered = new Map<string, LoadedSkill>();
+		for (const [name, skill] of skills) {
+			if (allowedSet.has(name)) {
+				filtered.set(name, skill);
+			}
+		}
+
+		return buildMultiSkillContext(filtered, budget, mode);
+	}
+
+	// No phase -- include all provided skills (caller already stack-filtered)
+	return buildMultiSkillContext(skills, budget, mode);
+}

package/src/skills/loader.ts

@@ -84,5 +84,8 @@ export async function loadAllSkills(skillsDir: string): Promise<ReadonlyMap<stri
 		if (!isEnoentError(error)) throw error;
 	}
 
-	return skills;
+	// Sort alphabetically by name for deterministic ordering regardless of
+	// filesystem readdir order (which varies across OS and FS types).
+	const sorted = new Map([...skills.entries()].sort(([a], [b]) => a.localeCompare(b)));
+	return Object.freeze(sorted);
 }

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);
 }