@kodrunhq/opencode-autopilot 1.16.0 → 1.18.0

package/src/tools/orchestrate.ts

@@ -1,14 +1,16 @@
 import { randomBytes } from "node:crypto";
-import { join } from "node:path";
 import { tool } from "@opencode-ai/plugin";
+import { getLogger } from "../logging/domains";
 import { parseTypedResultEnvelope } from "../orchestrator/contracts/legacy-result-adapter";
 import type { PendingDispatch, ResultEnvelope } from "../orchestrator/contracts/result-envelope";
+import { enrichErrorMessage } from "../orchestrator/error-context";
 import { PHASE_HANDLERS } from "../orchestrator/handlers/index";
 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 { getPhaseProgressString } from "../orchestrator/progress";
 import { loadAdaptiveSkillContext } from "../orchestrator/skill-injection";
 import {
 	createInitialState,
@@ -311,17 +313,16 @@ async function injectSkillContext(
 		});
 		if (ctx) return prompt + ctx;
 	} catch (err) {
-		console.warn("[opencode-autopilot] skill injection failed:", err);
+		getLogger("tool", "orchestrate").warn("skill injection failed", { err });
 	}
 	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";
+function buildUserProgress(state: PipelineState, label?: string, attempt?: number): string {
+	const baseProgress = getPhaseProgressString(state);
 	const att = attempt != null ? ` (attempt ${attempt})` : "";
-	return `Phase ${idx}/${TOTAL_PHASES}: ${phase} — ${desc}${att}`;
+	return `${baseProgress}${label ? ` — ${label}` : ""}${att}`;
 }
 
 /** Per-phase dispatch limits. BUILD is high because of multi-task waves. */
@@ -429,7 +430,7 @@ async function processHandlerResult(
 			};
 
 			// Log the dispatch event before any inline-review or context injection
-			const progress = buildUserProgress(phase, normalizedResult.progress, attempt);
+			const progress = buildUserProgress(currentState, normalizedResult.progress, attempt);
 			logOrchestrationEvent(artifactDir, {
 				timestamp: new Date().toISOString(),
 				phase,
@@ -544,7 +545,7 @@ async function processHandlerResult(
 					taskId: entry.taskId ?? null,
 				})) ?? [];
 
-			const progress = buildUserProgress(phase, normalizedResult.progress, attempt);
+			const progress = buildUserProgress(currentState, normalizedResult.progress, attempt);
 			logOrchestrationEvent(artifactDir, {
 				timestamp: new Date().toISOString(),
 				phase,
@@ -759,12 +760,13 @@ export async function orchestrateCore(args: OrchestrateArgs, artifactDir: string
 	} 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);
+		let safeMessage = message.replace(/[/\\][^\s"']+/g, "[PATH]").slice(0, 4096);
 
 		// Persist failure metadata for forensics (best-effort)
 		try {
 			const currentState = await loadState(artifactDir);
 			if (currentState?.currentPhase) {
+				safeMessage = enrichErrorMessage(safeMessage, currentState);
 				const lastDone = currentState.phases.filter((p) => p.status === "DONE").pop();
 				const failureContext = {
 					failedPhase: currentState.currentPhase,

package/src/tools/replay.ts

@@ -0,0 +1,42 @@
+import { tool } from "@opencode-ai/plugin";
+import type { ReviewState } from "../review/types";
+
+export const ocReplay = tool({
+	description:
+		"Verify determinism by replaying a known sequence of inputs to the review pipeline and ensuring identical state output.",
+	args: {
+		runId: tool.schema.string().describe("The pipeline runId to use as the random seed for replay"),
+		inputs: tool.schema
+			.array(tool.schema.string())
+			.describe("Array of raw JSON findings inputs to feed sequentially into the pipeline"),
+	},
+	async execute(args) {
+		const { advancePipeline } = await import("../review/pipeline");
+
+		let currentState: ReviewState = {
+			stage: 1,
+			scope: "replay-scope",
+			selectedAgentNames: ["logic-auditor", "security-auditor"],
+			accumulatedFindings: [],
+			startedAt: "2026-04-05T00:00:00.000Z",
+		};
+
+		for (const input of args.inputs) {
+			const res = advancePipeline(input, currentState, undefined, args.runId, args.runId);
+			if (res.state) {
+				currentState = res.state;
+			}
+		}
+
+		return JSON.stringify(
+			{
+				success: true,
+				message: `Replayed ${args.inputs.length} inputs deterministically.`,
+				replayedRunId: args.runId,
+				finalState: currentState,
+			},
+			null,
+			2,
+		);
+	},
+});

package/src/tools/review.ts

@@ -22,6 +22,8 @@ import {
 	loadActiveReviewStateFromKernel,
 	saveActiveReviewStateToKernel,
 } from "../kernel/repository";
+import { getLogger } from "../logging/domains";
+import { loadState as loadPipelineState } from "../orchestrator/state";
 import { REVIEW_AGENTS, SPECIALIZED_AGENTS } from "../review/agents/index";
 import {
 	createEmptyMemory,
@@ -133,7 +135,7 @@ async function syncLegacyReviewStateMirror(state: ReviewState, artifactDir: stri
 	} catch (error: unknown) {
 		if (!legacyReviewStateMirrorWarned) {
 			legacyReviewStateMirrorWarned = true;
-			console.warn("[opencode-autopilot] current-review.json mirror write failed:", error);
+			getLogger("tool", "review").warn("current-review.json mirror write failed", { error });
 		}
 	}
 }
@@ -190,7 +192,11 @@ async function startNewReview(
 
 	// Select agents from all candidates (universal + specialized)
 	const allCandidates = [...REVIEW_AGENTS, ...SPECIALIZED_AGENTS];
-	const selection = selectAgents(detectedStacks, diffAnalysis, allCandidates);
+	const artifactDir = getProjectArtifactDir(projectRoot);
+	const pipelineState = await loadPipelineState(artifactDir);
+	const seed = pipelineState ? `${pipelineState.runId}-review-1` : undefined;
+
+	const selection = selectAgents(detectedStacks, diffAnalysis, allCandidates, { seed });
 
 	const selectedNames = selection.selected.map((a) => a.name);
 

package/src/tools/summary.ts

@@ -0,0 +1,43 @@
+import { tool } from "@opencode-ai/plugin";
+import { z } from "zod";
+import { readLatestSessionLog, readSessionLog } from "../observability/log-reader";
+import { generateSessionSummary } from "../observability/summary-generator";
+
+export async function summaryCore(sessionID?: string, logsDir?: string): Promise<string> {
+	const logsRoot = logsDir ?? process.cwd();
+	const log = sessionID
+		? await readSessionLog(sessionID, logsRoot)
+		: await readLatestSessionLog(logsRoot);
+
+	if (!log) {
+		const target = sessionID ? `Session "${sessionID}" not found.` : "No session logs found.";
+		return JSON.stringify({
+			action: "error",
+			message: target,
+		});
+	}
+
+	const summary = generateSessionSummary(log);
+
+	return JSON.stringify({
+		action: "session_summary",
+		sessionId: log.sessionId,
+		summary,
+		displayText: summary,
+	});
+}
+
+export const ocSummary = tool({
+	description:
+		"Generate a markdown summary for the latest session or a specific session ID. Use this to review session outcomes, decisions, and errors.",
+	args: {
+		sessionID: z
+			.string()
+			.regex(/^[a-zA-Z0-9_-]{1,256}$/)
+			.optional()
+			.describe("Session ID to summarize (uses latest if omitted)"),
+	},
+	async execute({ sessionID }) {
+		return summaryCore(sessionID);
+	},
+});

package/src/types/background.ts

@@ -0,0 +1,51 @@
+import { z } from "zod";
+
+export const TaskStatusSchema = z.enum(["pending", "running", "completed", "failed", "cancelled"]);
+export type TaskStatus = z.infer<typeof TaskStatusSchema>;
+
+export const TaskResultSchema = z.object({
+	taskId: z.string().min(1),
+	status: TaskStatusSchema,
+	output: z.string().optional(),
+	error: z.string().optional(),
+	startedAt: z.number().optional(),
+	completedAt: z.number().optional(),
+	durationMs: z.number().optional(),
+});
+export type TaskResult = z.infer<typeof TaskResultSchema>;
+
+export const BackgroundTaskSchema = z.object({
+	id: z.string().min(1),
+	name: z.string().min(1),
+	status: TaskStatusSchema,
+	agentId: z.string().optional(),
+	priority: z.number().int().min(0).max(100).default(50),
+	createdAt: z.number(),
+	result: TaskResultSchema.optional(),
+	metadata: z.record(z.string(), z.unknown()).default({}),
+});
+export type BackgroundTask = z.infer<typeof BackgroundTaskSchema>;
+
+export const AgentSlotSchema = z.object({
+	slotId: z.string().min(1),
+	agentId: z.string().min(1),
+	capacity: z.number().int().min(1).max(100).default(1),
+	activeTaskCount: z.number().int().min(0).default(0),
+	reserved: z.boolean().default(false),
+});
+export type AgentSlot = z.infer<typeof AgentSlotSchema>;
+
+export const ConcurrencyLimitsSchema = z.object({
+	global: z.number().int().min(1).max(50).default(5),
+	perAgent: z.number().int().min(1).max(10).default(2),
+	perCategory: z.record(z.string(), z.number().int().min(1).max(20)).default({}),
+});
+export type ConcurrencyLimits = z.infer<typeof ConcurrencyLimitsSchema>;
+
+export const backgroundConfigSchema = z.object({
+	enabled: z.boolean().default(false),
+	maxConcurrent: z.number().int().min(1).max(50).default(5),
+	persistence: z.boolean().default(true),
+});
+export type BackgroundConfig = z.infer<typeof backgroundConfigSchema>;
+export const backgroundDefaults = backgroundConfigSchema.parse({});

package/src/types/mcp.ts

@@ -0,0 +1,27 @@
+import { z } from "zod";
+
+export const McpSkillSchema = z.object({
+	name: z.string().min(1),
+	description: z.string().optional(),
+	enabled: z.boolean().default(true),
+	version: z.string().optional(),
+	config: z.record(z.string(), z.unknown()).default({}),
+});
+export type McpSkill = z.infer<typeof McpSkillSchema>;
+
+export const McpServerSchema = z.object({
+	id: z.string().min(1),
+	url: z.string().url().optional(),
+	transport: z.enum(["stdio", "http", "sse"]).default("stdio"),
+	enabled: z.boolean().default(true),
+	skills: z.array(z.string()).default([]),
+	metadata: z.record(z.string(), z.unknown()).default({}),
+});
+export type McpServer = z.infer<typeof McpServerSchema>;
+
+export const mcpConfigSchema = z.object({
+	enabled: z.boolean().default(false),
+	skills: z.record(z.string(), z.unknown()).default({}),
+});
+export type McpConfig = z.infer<typeof mcpConfigSchema>;
+export const mcpDefaults = mcpConfigSchema.parse({});

package/src/types/recovery.ts

@@ -0,0 +1,39 @@
+import { z } from "zod";
+
+export const ErrorCategorySchema = z.enum([
+	"rate_limit",
+	"auth_failure",
+	"quota_exceeded",
+	"service_unavailable",
+	"timeout",
+	"network",
+	"validation",
+	"unknown",
+]);
+export type ErrorCategory = z.infer<typeof ErrorCategorySchema>;
+
+export const RecoveryStrategySchema = z.enum([
+	"retry",
+	"fallback_model",
+	"skip",
+	"abort",
+	"user_prompt",
+]);
+export type RecoveryStrategy = z.infer<typeof RecoveryStrategySchema>;
+
+export const RecoveryActionSchema = z.object({
+	strategy: RecoveryStrategySchema,
+	errorCategory: ErrorCategorySchema,
+	maxAttempts: z.number().int().min(1).max(10).default(3),
+	backoffMs: z.number().int().min(0).default(1000),
+	fallbackAgentId: z.string().optional(),
+	metadata: z.record(z.string(), z.unknown()).default({}),
+});
+export type RecoveryAction = z.infer<typeof RecoveryActionSchema>;
+
+export const recoveryConfigSchema = z.object({
+	enabled: z.boolean().default(true),
+	maxRetries: z.number().int().min(0).max(10).default(3),
+});
+export type RecoveryConfig = z.infer<typeof recoveryConfigSchema>;
+export const recoveryDefaults = recoveryConfigSchema.parse({});

package/src/types/routing.ts

@@ -0,0 +1,39 @@
+import { z } from "zod";
+
+export const CategorySchema = z.enum([
+	"quick",
+	"visual-engineering",
+	"ultrabrain",
+	"artistry",
+	"writing",
+	"unspecified-high",
+	"unspecified-low",
+]);
+export type Category = z.infer<typeof CategorySchema>;
+
+export const CategoryConfigSchema = z.object({
+	enabled: z.boolean().default(true),
+	agentId: z.string().optional(),
+	modelGroup: z.string().optional(),
+	maxTokenBudget: z.number().int().min(1000).optional(),
+	timeoutSeconds: z.number().int().min(1).max(3600).optional(),
+	skills: z.array(z.string()).default([]),
+	metadata: z.record(z.string(), z.unknown()).default({}),
+});
+export type CategoryConfig = z.infer<typeof CategoryConfigSchema>;
+
+export const RoutingDecisionSchema = z.object({
+	category: CategorySchema,
+	confidence: z.number().min(0).max(1),
+	agentId: z.string().optional(),
+	reasoning: z.string().optional(),
+	appliedConfig: CategoryConfigSchema.optional(),
+});
+export type RoutingDecision = z.infer<typeof RoutingDecisionSchema>;
+
+export const routingConfigSchema = z.object({
+	enabled: z.boolean().default(false),
+	categories: z.record(z.string(), CategoryConfigSchema).default({}),
+});
+export type RoutingConfig = z.infer<typeof routingConfigSchema>;
+export const routingDefaults = routingConfigSchema.parse({});

package/src/utils/random.ts

@@ -0,0 +1,33 @@
+/**
+ * A simple seeded random number generator.
+ * Uses the Mulberry32 algorithm which provides decent quality and is very fast.
+ */
+export function createSeededRandom(seedString: string) {
+	// Simple hash function (djb2) to convert string to 32-bit integer seed
+	let seed = 5381;
+	for (let i = 0; i < seedString.length; i++) {
+		seed = (seed * 33) ^ seedString.charCodeAt(i);
+	}
+	// Add an arbitrary constant to avoid passing 0 to mulberry32
+	let a = seed + 1831565813;
+
+	// Mulberry32 generator
+	return function random(): number {
+		a += 0x6d2b79f5;
+		let t = a;
+		t = Math.imul(t ^ (t >>> 15), t | 1);
+		t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+		return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+	};
+}
+
+/**
+ * Shuffles an array in-place deterministically using the provided seeded RNG.
+ */
+export function deterministicShuffle<T>(array: T[], rng: () => number): T[] {
+	for (let i = array.length - 1; i > 0; i--) {
+		const j = Math.floor(rng() * (i + 1));
+		[array[i], array[j]] = [array[j], array[i]];
+	}
+	return array;
+}

package/src/ux/session-summary.ts

@@ -0,0 +1,56 @@
+import type { SessionEvents } from "../observability/event-store";
+import type { PipelineState } from "../orchestrator/types";
+
+export function generateSessionSummary(
+	sessionData: SessionEvents | undefined,
+	pipelineState: PipelineState | null,
+): string {
+	const sections: string[] = ["## Session Summary"];
+
+	if (pipelineState) {
+		const phaseInfo = pipelineState.currentPhase
+			? ` (Current Phase: ${pipelineState.currentPhase})`
+			: "";
+		sections.push(`**Pipeline Status**: ${pipelineState.status}${phaseInfo}`);
+
+		const done = pipelineState.phases.filter((p) => p.status === "DONE").map((p) => p.name);
+
+		sections.push(`**Phases Completed**: ${done.length > 0 ? done.join(", ") : "None"}`);
+	} else {
+		sections.push("**Pipeline Status**: Unknown");
+	}
+
+	if (sessionData?.tokens) {
+		const { inputTokens, outputTokens, reasoningTokens } = sessionData.tokens;
+		sections.push(
+			"\n**Context Used**:",
+			`- Input: ${inputTokens.toLocaleString()} tokens`,
+			`- Output: ${outputTokens.toLocaleString()} tokens`,
+			...(reasoningTokens > 0 ? [`- Reasoning: ${reasoningTokens.toLocaleString()} tokens`] : []),
+		);
+	}
+
+	const errors = (sessionData?.events ?? []).filter((e) => e.type === "error");
+	if (errors.length > 0) {
+		sections.push("\n**Errors Encountered**:");
+		for (const e of errors) {
+			if (e.type === "error") {
+				sections.push(`- ${e.errorType.toUpperCase()}: ${e.message}`);
+			}
+		}
+	}
+
+	if (sessionData) {
+		const endEvent = sessionData.events.find((e) => e.type === "session_end");
+		if (endEvent && endEvent.type === "session_end") {
+			const seconds = (endEvent.durationMs / 1000).toFixed(1);
+			sections.push(`\n**Duration**: ${seconds}s`);
+		} else {
+			const start = new Date(sessionData.startedAt).getTime();
+			const seconds = ((Date.now() - start) / 1000).toFixed(1);
+			sections.push(`\n**Duration (active)**: ${seconds}s`);
+		}
+	}
+
+	return sections.join("\n").trim();
+}