@kodrunhq/opencode-autopilot 1.12.1 → 1.14.0

package/src/orchestrator/confidence.ts

@@ -36,8 +36,9 @@ export function summarizeConfidence(entries: readonly ConfidenceEntry[]): {
 
 	const total = entries.length;
 
-	// Tie-break: prefer higher confidence (HIGH > MEDIUM > LOW)
-	let dominant: ConfidenceLevel = "MEDIUM"; // default for empty
+	// Default: no evidence of low confidence → assume HIGH (single-proposal fast path).
+	// This prevents empty ledgers from triggering expensive multi-proposal arena (depth=2).
+	let dominant: ConfidenceLevel = "HIGH";
 	if (total > 0) {
 		let maxCount = 0;
 		for (const level of LEVEL_PRIORITY) {

package/src/orchestrator/handlers/architect.ts

@@ -27,11 +27,14 @@ export async function handleArchitect(
 	artifactDir: string,
 	_result?: string,
 ): Promise<DispatchResult> {
+	// _result is received from the orchestrator but completion is determined by
+	// artifact existence (design.md/critique.md), not by result truthiness.
+	// This preserves the three-step arena flow: proposals → critic → complete.
 	const phaseDir = getPhaseDir(artifactDir, "ARCHITECT");
 	const critiqueExists = await fileExists(join(phaseDir, "critique.md"));
 	const designExists = await fileExists(join(phaseDir, "design.md"));
 
-	// Step 3: critique or design exists -> complete
+	// Step 3: critique or design exists -> complete (idempotency on resume)
 	if (critiqueExists || designExists) {
 		return Object.freeze({
 			action: "complete" as const,
@@ -49,9 +52,9 @@ export async function handleArchitect(
 			action: "dispatch" as const,
 			agent: AGENT_NAMES.CRITIC,
 			prompt: [
-				`Review architecture proposals in phases/ARCHITECT/proposals/`,
-				`Read ${getArtifactRef("RECON", "report.md")} and ${getArtifactRef("CHALLENGE", "brief.md")} for context.`,
-				`Write comparative critique to ${getArtifactRef("ARCHITECT", "critique.md")}`,
+				`Review architecture proposals in ${proposalsDir}/`,
+				`Read ${getArtifactRef(artifactDir, "RECON", "report.md")} and ${getArtifactRef(artifactDir, "CHALLENGE", "brief.md")} for context.`,
+				`Write comparative critique to ${getArtifactRef(artifactDir, "ARCHITECT", "critique.md")}`,
 				`Include: strengths, weaknesses, recommendation, confidence (HIGH/MEDIUM/LOW).`,
 			].join("\n"),
 			phase: "ARCHITECT",
@@ -63,8 +66,8 @@ export async function handleArchitect(
 	await ensurePhaseDir(artifactDir, "ARCHITECT");
 	const reconEntries = filterByPhase(state.confidence, "RECON");
 	const depth = getMemoryTunedDepth(reconEntries, join(artifactDir, ".."));
-	const reconRef = getArtifactRef("RECON", "report.md");
-	const challengeRef = getArtifactRef("CHALLENGE", "brief.md");
+	const reconRef = getArtifactRef(artifactDir, "RECON", "report.md");
+	const challengeRef = getArtifactRef(artifactDir, "CHALLENGE", "brief.md");
 	const safeIdea = sanitizeTemplateContent(state.idea).replace(/[\r\n]+/g, " ");
 
 	if (depth === 1) {
@@ -74,7 +77,7 @@ export async function handleArchitect(
 			prompt: [
 				`Read ${reconRef} and ${challengeRef} for context.`,
 				`Design architecture for: ${safeIdea}`,
-				`Write design to ${getArtifactRef("ARCHITECT", "design.md")}`,
+				`Write design to ${getArtifactRef(artifactDir, "ARCHITECT", "design.md")}`,
 				`Include: component diagram, data flow, technology choices, confidence (HIGH/MEDIUM/LOW).`,
 			].join("\n"),
 			phase: "ARCHITECT",
@@ -90,7 +93,7 @@ export async function handleArchitect(
 				`Read ${reconRef} and ${challengeRef} for context.`,
 				`Design architecture for: ${safeIdea}`,
 				`Constraint: ${constraint}`,
-				`Write proposal to phases/ARCHITECT/proposals/proposal-${label}.md`,
+				`Write proposal to ${join(proposalsDir, `proposal-${label}.md`)}`,
 				`Include: component diagram, data flow, technology choices, confidence (HIGH/MEDIUM/LOW).`,
 			].join("\n"),
 		});

package/src/orchestrator/handlers/build.ts

@@ -2,6 +2,7 @@ import { sanitizeTemplateContent } from "../../review/sanitize";
 import { getArtifactRef } from "../artifacts";
 import { groupByWave } from "../plan";
 import type { BuildProgress, Task } from "../types";
+import { assignWaves } from "../wave-assigner";
 import type { DispatchResult, PhaseHandler } from "./types";
 import { AGENT_NAMES } from "./types";
 
@@ -54,9 +55,9 @@ function markTasksInProgress(tasks: readonly Task[], taskIds: readonly number[])
 /**
  * Build a prompt for a single task dispatch.
  */
-function buildTaskPrompt(task: Task): string {
-	const planRef = getArtifactRef("PLAN", "tasks.md");
-	const designRef = getArtifactRef("ARCHITECT", "design.md");
+function buildTaskPrompt(task: Task, artifactDir: string): string {
+	const planRef = getArtifactRef(artifactDir, "PLAN", "tasks.md");
+	const designRef = getArtifactRef(artifactDir, "ARCHITECT", "design.md");
 	return [
 		`Implement task ${task.id}: ${task.title}.`,
 		`Reference the plan at ${planRef}`,
@@ -109,7 +110,7 @@ function hasCriticalFindings(resultStr: string): boolean {
 	}
 }
 
-export const handleBuild: PhaseHandler = async (state, _artifactDir, result?) => {
+export const handleBuild: PhaseHandler = async (state, artifactDir, result?) => {
 	const { tasks, buildProgress } = state;
 
 	// Edge case: no tasks
@@ -130,6 +131,46 @@ export const handleBuild: PhaseHandler = async (state, _artifactDir, result?) =>
 		} satisfies DispatchResult);
 	}
 
+	// Auto-assign waves from depends_on declarations (D-15)
+	let effectiveTasks = tasks;
+	const hasDependencies = tasks.some((t) => t.depends_on && t.depends_on.length > 0);
+	if (hasDependencies) {
+		const waveResult = assignWaves(
+			tasks.map((t) => ({ id: t.id, depends_on: t.depends_on ?? [] })),
+		);
+		if (waveResult.cycles.length > 0) {
+			const cycleSet = new Set(waveResult.cycles);
+			effectiveTasks = tasks.map((t) => {
+				if (cycleSet.has(t.id)) return { ...t, status: "BLOCKED" as const };
+				const assigned = waveResult.assignments.get(t.id);
+				return assigned !== undefined ? { ...t, wave: assigned } : t;
+			});
+		} else {
+			effectiveTasks = tasks.map((t) => {
+				const assigned = waveResult.assignments.get(t.id);
+				return assigned !== undefined ? { ...t, wave: assigned } : t;
+			});
+		}
+	}
+
+	// Check if all remaining tasks are BLOCKED (cycles or MAX_TASKS cap)
+	const nonDoneTasks = effectiveTasks.filter((t) => t.status !== "DONE" && t.status !== "SKIPPED");
+	if (nonDoneTasks.length > 0 && nonDoneTasks.every((t) => t.status === "BLOCKED")) {
+		const blockedIds = nonDoneTasks.map((t) => t.id).join(", ");
+		return Object.freeze({
+			action: "error" as const,
+			phase: "BUILD",
+			message: `All remaining tasks are BLOCKED due to dependency cycles: [${blockedIds}]`,
+			progress: `All remaining tasks are BLOCKED due to dependency cycles: [${blockedIds}]`,
+			_stateUpdates: Object.freeze({
+				buildProgress: Object.freeze({
+					...buildProgress,
+				}),
+				tasks: effectiveTasks,
+			}),
+		});
+	}
+
 	// Case 1: Review pending + result provided -> process review outcome
 	if (buildProgress.reviewPending && result) {
 		if (hasCriticalFindings(result)) {
@@ -138,7 +179,7 @@ export const handleBuild: PhaseHandler = async (state, _artifactDir, result?) =>
 			const prompt = [
 				`CRITICAL review findings detected. Fix the following issues:`,
 				safeResult,
-				`Reference ${getArtifactRef("PLAN", "tasks.md")} for context.`,
+				`Reference ${getArtifactRef(artifactDir, "PLAN", "tasks.md")} for context.`,
 			].join(" ");
 
 			return Object.freeze({
@@ -157,7 +198,7 @@ export const handleBuild: PhaseHandler = async (state, _artifactDir, result?) =>
 		}
 
 		// No critical -> advance to next wave
-		const waveMap = groupByWave(tasks);
+		const waveMap = groupByWave(effectiveTasks);
 		const nextWave = findCurrentWave(waveMap);
 
 		if (nextWave === null) {
@@ -186,7 +227,7 @@ export const handleBuild: PhaseHandler = async (state, _artifactDir, result?) =>
 			return Object.freeze({
 				action: "dispatch",
 				agent: AGENT_NAMES.BUILD,
-				prompt: buildTaskPrompt(task),
+				prompt: buildTaskPrompt(task, artifactDir),
 				phase: "BUILD",
 				progress: `Wave ${nextWave} — task ${task.id}`,
 				_stateUpdates: {
@@ -200,12 +241,12 @@ export const handleBuild: PhaseHandler = async (state, _artifactDir, result?) =>
 			action: "dispatch_multi",
 			agents: pendingTasks.map((task) => ({
 				agent: AGENT_NAMES.BUILD,
-				prompt: buildTaskPrompt(task),
+				prompt: buildTaskPrompt(task, artifactDir),
 			})),
 			phase: "BUILD",
 			progress: `Wave ${nextWave} — ${pendingTasks.length} concurrent tasks`,
 			_stateUpdates: {
-				tasks: [...markTasksInProgress(tasks, dispatchedIds)],
+				tasks: [...markTasksInProgress(effectiveTasks, dispatchedIds)],
 				buildProgress: { ...updatedProgress, currentTask: null },
 			},
 		} satisfies DispatchResult);
@@ -214,9 +255,9 @@ export const handleBuild: PhaseHandler = async (state, _artifactDir, result?) =>
 	// Case 2: Result provided + not review pending -> mark task done
 	// For dispatch_multi, currentTask may be null — find the first IN_PROGRESS task instead
 	const taskToComplete =
-		buildProgress.currentTask ?? tasks.find((t) => t.status === "IN_PROGRESS")?.id ?? null;
+		buildProgress.currentTask ?? effectiveTasks.find((t) => t.status === "IN_PROGRESS")?.id ?? null;
 	if (result && !buildProgress.reviewPending && taskToComplete !== null) {
-		const updatedTasks = markTaskDone(tasks, taskToComplete);
+		const updatedTasks = markTaskDone(effectiveTasks, taskToComplete);
 		const waveMap = groupByWave(updatedTasks);
 		const currentWave = buildProgress.currentWave ?? 1;
 
@@ -246,7 +287,7 @@ export const handleBuild: PhaseHandler = async (state, _artifactDir, result?) =>
 			return Object.freeze({
 				action: "dispatch",
 				agent: AGENT_NAMES.BUILD,
-				prompt: buildTaskPrompt(next),
+				prompt: buildTaskPrompt(next, artifactDir),
 				phase: "BUILD",
 				progress: `Wave ${currentWave} — task ${next.id}`,
 				_stateUpdates: {
@@ -280,7 +321,7 @@ export const handleBuild: PhaseHandler = async (state, _artifactDir, result?) =>
 	}
 
 	// Case 3: No result (first call or resume) -> find first pending wave
-	const waveMap = groupByWave(tasks);
+	const waveMap = groupByWave(effectiveTasks);
 	const currentWave = findCurrentWave(waveMap);
 
 	if (currentWave === null) {
@@ -328,7 +369,7 @@ export const handleBuild: PhaseHandler = async (state, _artifactDir, result?) =>
 		return Object.freeze({
 			action: "dispatch",
 			agent: AGENT_NAMES.BUILD,
-			prompt: buildTaskPrompt(task),
+			prompt: buildTaskPrompt(task, artifactDir),
 			phase: "BUILD",
 			progress: `Wave ${currentWave} — task ${task.id}`,
 			_stateUpdates: {
@@ -347,12 +388,12 @@ export const handleBuild: PhaseHandler = async (state, _artifactDir, result?) =>
 		action: "dispatch_multi",
 		agents: pendingTasks.map((task) => ({
 			agent: AGENT_NAMES.BUILD,
-			prompt: buildTaskPrompt(task),
+			prompt: buildTaskPrompt(task, artifactDir),
 		})),
 		phase: "BUILD",
 		progress: `Wave ${currentWave} — ${pendingTasks.length} concurrent tasks`,
 		_stateUpdates: {
-			tasks: [...markTasksInProgress(tasks, dispatchedIds)],
+			tasks: [...markTasksInProgress(effectiveTasks, dispatchedIds)],
 			buildProgress: {
 				...buildProgress,
 				currentTask: null,

package/src/orchestrator/handlers/challenge.ts

@@ -1,4 +1,5 @@
 import { sanitizeTemplateContent } from "../../review/sanitize";
+import { fileExists } from "../../utils/fs-helpers";
 import { ensurePhaseDir, getArtifactRef } from "../artifacts";
 import type { PipelineState } from "../types";
 import { AGENT_NAMES, type DispatchResult } from "./types";
@@ -13,6 +14,11 @@ export async function handleChallenge(
 	result?: string,
 ): Promise<DispatchResult> {
 	if (result) {
+		// Warn if artifact wasn't written (best-effort — still complete the phase)
+		const artifactPath = getArtifactRef(artifactDir, "CHALLENGE", "brief.md");
+		if (!(await fileExists(artifactPath))) {
+			console.warn("[opencode-autopilot] CHALLENGE completed but artifact not found");
+		}
 		return Object.freeze({
 			action: "complete" as const,
 			phase: "CHALLENGE",
@@ -21,8 +27,8 @@ export async function handleChallenge(
 	}
 
 	await ensurePhaseDir(artifactDir, "CHALLENGE");
-	const reconRef = getArtifactRef("RECON", "report.md");
-	const outputRef = getArtifactRef("CHALLENGE", "brief.md");
+	const reconRef = getArtifactRef(artifactDir, "RECON", "report.md");
+	const outputPath = getArtifactRef(artifactDir, "CHALLENGE", "brief.md");
 
 	const safeIdea = sanitizeTemplateContent(state.idea).replace(/[\r\n]+/g, " ");
 
@@ -32,7 +38,7 @@ export async function handleChallenge(
 		prompt: [
 			`Read ${reconRef} for research context.`,
 			`Original idea: ${safeIdea}`,
-			`Propose up to 3 enhancements. Write ambitious brief to ${outputRef}`,
+			`Propose up to 3 enhancements. Write ambitious brief to ${outputPath}`,
 			`For each: name, user value, complexity (LOW/MEDIUM/HIGH), accept/reject rationale.`,
 		].join("\n"),
 		phase: "CHALLENGE",

package/src/orchestrator/handlers/plan.ts

@@ -2,7 +2,7 @@ import { getArtifactRef } from "../artifacts";
 import type { DispatchResult, PhaseHandler } from "./types";
 import { AGENT_NAMES } from "./types";
 
-export const handlePlan: PhaseHandler = async (_state, _artifactDir, result?) => {
+export const handlePlan: PhaseHandler = async (_state, artifactDir, result?) => {
 	if (result) {
 		return Object.freeze({
 			action: "complete",
@@ -11,8 +11,9 @@ export const handlePlan: PhaseHandler = async (_state, _artifactDir, result?) =>
 		} satisfies DispatchResult);
 	}
 
-	const architectRef = getArtifactRef("ARCHITECT", "design.md");
-	const challengeRef = getArtifactRef("CHALLENGE", "brief.md");
+	const architectRef = getArtifactRef(artifactDir, "ARCHITECT", "design.md");
+	const challengeRef = getArtifactRef(artifactDir, "CHALLENGE", "brief.md");
+	const tasksPath = getArtifactRef(artifactDir, "PLAN", "tasks.md");
 
 	const prompt = [
 		"Read the architecture design at",
@@ -20,7 +21,7 @@ export const handlePlan: PhaseHandler = async (_state, _artifactDir, result?) =>
 		"and the challenge brief at",
 		challengeRef,
 		"then produce a task plan.",
-		"Write tasks to phases/PLAN/tasks.md.",
+		`Write tasks to ${tasksPath}.`,
 		"Each task should have a 300-line diff max.",
 		"Assign wave numbers for parallel execution.",
 	].join(" ");

package/src/orchestrator/handlers/recon.ts

@@ -1,4 +1,5 @@
 import { sanitizeTemplateContent } from "../../review/sanitize";
+import { fileExists } from "../../utils/fs-helpers";
 import { ensurePhaseDir, getArtifactRef } from "../artifacts";
 import type { PipelineState } from "../types";
 import { AGENT_NAMES, type DispatchResult } from "./types";
@@ -13,6 +14,11 @@ export async function handleRecon(
 	result?: string,
 ): Promise<DispatchResult> {
 	if (result) {
+		// Warn if artifact wasn't written (best-effort — still complete the phase)
+		const artifactPath = getArtifactRef(artifactDir, "RECON", "report.md");
+		if (!(await fileExists(artifactPath))) {
+			console.warn("[opencode-autopilot] RECON completed but artifact not found");
+		}
 		return Object.freeze({
 			action: "complete" as const,
 			phase: "RECON",
@@ -20,8 +26,8 @@ export async function handleRecon(
 		});
 	}
 
-	const phaseDir = await ensurePhaseDir(artifactDir, "RECON");
-	const outputRef = getArtifactRef("RECON", "report.md");
+	await ensurePhaseDir(artifactDir, "RECON");
+	const outputPath = getArtifactRef(artifactDir, "RECON", "report.md");
 
 	const safeIdea = sanitizeTemplateContent(state.idea).replace(/[\r\n]+/g, " ");
 
@@ -29,9 +35,8 @@ export async function handleRecon(
 		action: "dispatch" as const,
 		agent: AGENT_NAMES.RECON,
 		prompt: [
-			`Research the following idea and write findings to ${outputRef}`,
+			`Research the following idea and write findings to ${outputPath}`,
 			`Idea: ${safeIdea}`,
-			`Output: ${phaseDir}/report.md`,
 			`Include: Market Analysis, Technology Options, UX Considerations, Feasibility Assessment, Confidence (HIGH/MEDIUM/LOW)`,
 		].join("\n"),
 		phase: "RECON",

package/src/orchestrator/handlers/retrospective.ts

@@ -105,7 +105,9 @@ export const handleRetrospective: PhaseHandler = async (_state, artifactDir, res
 
 	const artifactRefs = Object.entries(PHASE_ARTIFACTS)
 		.filter(([phase, files]) => files.length > 0 && phase !== "RETROSPECTIVE")
-		.flatMap(([phase, files]) => files.map((file) => getArtifactRef(phase as Phase, file)));
+		.flatMap(([phase, files]) =>
+			files.map((file) => getArtifactRef(artifactDir, phase as Phase, file)),
+		);
 
 	const prompt = [
 		"Analyze all phase artifacts:",

package/src/orchestrator/handlers/ship.ts

@@ -1,8 +1,8 @@
-import { getArtifactRef } from "../artifacts";
+import { getArtifactRef, getPhaseDir } from "../artifacts";
 import type { DispatchResult, PhaseHandler } from "./types";
 import { AGENT_NAMES } from "./types";
 
-export const handleShip: PhaseHandler = async (_state, _artifactDir, result?) => {
+export const handleShip: PhaseHandler = async (_state, artifactDir, result?) => {
 	if (result) {
 		return Object.freeze({
 			action: "complete",
@@ -11,10 +11,11 @@ export const handleShip: PhaseHandler = async (_state, _artifactDir, result?) =>
 		} satisfies DispatchResult);
 	}
 
-	const reconRef = getArtifactRef("RECON", "report.md");
-	const challengeRef = getArtifactRef("CHALLENGE", "brief.md");
-	const architectRef = getArtifactRef("ARCHITECT", "design.md");
-	const planRef = getArtifactRef("PLAN", "tasks.md");
+	const reconRef = getArtifactRef(artifactDir, "RECON", "report.md");
+	const challengeRef = getArtifactRef(artifactDir, "CHALLENGE", "brief.md");
+	const architectRef = getArtifactRef(artifactDir, "ARCHITECT", "design.md");
+	const planRef = getArtifactRef(artifactDir, "PLAN", "tasks.md");
+	const shipDir = getPhaseDir(artifactDir, "SHIP");
 
 	const prompt = [
 		"Review all prior phase artifacts:",
@@ -25,7 +26,7 @@ export const handleShip: PhaseHandler = async (_state, _artifactDir, result?) =>
 		"Produce walkthrough.md (architecture overview),",
 		"decisions.md (key decisions with rationale),",
 		"changelog.md (user-facing changes).",
-		"Write output to phases/SHIP/.",
+		`Write output to ${shipDir}/.`,
 	].join(" ");
 
 	return Object.freeze({

package/src/orchestrator/handlers/types.ts

@@ -22,6 +22,7 @@ export interface DispatchResult {
 	readonly progress?: string;
 	readonly message?: string;
 	readonly _stateUpdates?: Partial<PipelineState>;
+	readonly _userProgress?: string;
 }
 
 export type PhaseHandler = (

package/src/orchestrator/lesson-memory.ts

@@ -9,6 +9,7 @@
  * to prevent corruption.
  */
 
+import { randomBytes } from "node:crypto";
 import { readFile, rename, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import { ensureDir, isEnoentError } from "../utils/fs-helpers";
@@ -76,7 +77,7 @@ export async function saveLessonMemory(memory: LessonMemory, projectRoot: string
 	const dir = join(projectRoot, ".opencode-autopilot");
 	await ensureDir(dir);
 	const memoryPath = join(dir, LESSON_FILE);
-	const tmpPath = `${memoryPath}.tmp.${Date.now()}`;
+	const tmpPath = `${memoryPath}.tmp.${randomBytes(8).toString("hex")}`;
 	await writeFile(tmpPath, JSON.stringify(validated, null, 2), "utf-8");
 	await rename(tmpPath, memoryPath);
 }

package/src/orchestrator/orchestration-logger.ts

@@ -0,0 +1,40 @@
+import { appendFileSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+
+export interface OrchestrationEvent {
+	readonly timestamp: string;
+	readonly phase: string;
+	readonly action: "dispatch" | "dispatch_multi" | "complete" | "error" | "loop_detected";
+	readonly agent?: string;
+	readonly promptLength?: number;
+	readonly attempt?: number;
+	readonly message?: string;
+}
+
+const LOG_FILE = "orchestration.jsonl";
+
+/** Rate-limit: warn about log failures at most once per process. */
+let logWriteWarned = false;
+
+/**
+ * Append an orchestration event to the project-local JSONL log.
+ * Uses synchronous append to survive crashes. Best-effort — errors are swallowed.
+ */
+export function logOrchestrationEvent(artifactDir: string, event: OrchestrationEvent): void {
+	try {
+		mkdirSync(artifactDir, { recursive: true });
+		const logPath = join(artifactDir, LOG_FILE);
+		// Redact filesystem paths from message to avoid leaking sensitive directory info
+		const safe = event.message
+			? { ...event, message: event.message.replace(/[/\\][^\s"']+/g, "[PATH]") }
+			: event;
+		const line = `${JSON.stringify(safe)}\n`;
+		appendFileSync(logPath, line, "utf-8");
+	} catch (err) {
+		// Best-effort — never block the pipeline. Warn once so operators know logging is broken.
+		if (!logWriteWarned) {
+			logWriteWarned = true;
+			console.warn("[opencode-autopilot] orchestration log write failed:", err);
+		}
+	}
+}

package/src/orchestrator/phase.ts

@@ -1,5 +1,19 @@
 import type { Phase, PhaseStatus, PipelineState } from "./types";
 
+/** Maps each phase to its 1-based position for user-facing progress display. */
+export const PHASE_INDEX: Readonly<Record<Phase, number>> = Object.freeze({
+	RECON: 1,
+	CHALLENGE: 2,
+	ARCHITECT: 3,
+	EXPLORE: 4,
+	PLAN: 5,
+	BUILD: 6,
+	SHIP: 7,
+	RETROSPECTIVE: 8,
+} satisfies Record<Phase, number>);
+
+export const TOTAL_PHASES = 8;
+
 /**
  * Maps each phase to its valid successor. RETROSPECTIVE is terminal (null).
  */

package/src/orchestrator/schemas.ts

@@ -42,6 +42,7 @@ export const taskSchema = z.object({
 	title: z.string().max(2048),
 	status: z.enum(["PENDING", "IN_PROGRESS", "DONE", "FAILED", "SKIPPED", "BLOCKED"]),
 	wave: z.number(),
+	depends_on: z.array(z.number()).default([]),
 	attempt: z.number().default(0),
 	strike: z.number().default(0),
 });
@@ -83,4 +84,5 @@ export const pipelineStateSchema = z.object({
 		reviewPending: false,
 	}),
 	failureContext: failureContextSchema.nullable().default(null),
+	phaseDispatchCounts: z.record(z.string().max(32), z.number().int().min(0).max(1000)).default({}),
 });

package/src/orchestrator/skill-injection.ts

@@ -11,9 +11,10 @@ import { readFile } from "node:fs/promises";
 import { join } from "node:path";
 import { sanitizeTemplateContent } from "../review/sanitize";
 import {
-	buildMultiSkillContext,
+	buildAdaptiveSkillContext,
 	detectProjectStackTags,
 	filterSkillsByStack,
+	type SkillMode,
 } from "../skills/adaptive-injector";
 import { loadAllSkills } from "../skills/loader";
 import { isEnoentError } from "../utils/fs-helpers";
@@ -69,7 +70,11 @@ export function buildSkillContext(skillContent: string): string {
 export async function loadAdaptiveSkillContext(
 	baseDir: string,
 	projectRoot: string,
-	tokenBudget?: number,
+	options?: {
+		readonly phase?: string;
+		readonly budget?: number;
+		readonly mode?: SkillMode;
+	},
 ): Promise<string> {
 	try {
 		const skillsDir = join(baseDir, "skills");
@@ -81,10 +86,10 @@ export async function loadAdaptiveSkillContext(
 		if (allSkills.size === 0) return "";
 
 		const matchingSkills = filterSkillsByStack(allSkills, projectTags);
-		return buildMultiSkillContext(matchingSkills, tokenBudget);
-	} catch {
-		// Best-effort: all errors return empty string. Caller (injectSkillContext)
-		// logs the error — no need to re-throw since the call site is also best-effort.
+		return buildAdaptiveSkillContext(matchingSkills, options);
+	} catch (err) {
+		// Best-effort: all errors return empty string.
+		console.warn("[opencode-autopilot] adaptive skill load failed:", err);
 		return "";
 	}
 }

package/src/orchestrator/state.ts

@@ -1,3 +1,4 @@
+import { randomBytes } from "node:crypto";
 import { readFile, rename, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import { ensureDir, isEnoentError } from "../utils/fs-helpers";
@@ -45,7 +46,7 @@ export async function saveState(state: PipelineState, artifactDir: string): Prom
 	const validated = pipelineStateSchema.parse(state);
 	await ensureDir(artifactDir);
 	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);
 }