@kodrunhq/opencode-autopilot 1.18.0 → 1.19.0

package/src/kernel/transaction.ts

@@ -6,6 +6,29 @@ export interface TransactionOptions {
 	useImmediate?: boolean;
 }
 
+const transactionDepthByDatabase = new WeakMap<Database, number>();
+
+function getTransactionDepth(db: Database): number {
+	return transactionDepthByDatabase.get(db) ?? 0;
+}
+
+function enterTransaction(db: Database): void {
+	const currentDepth = getTransactionDepth(db);
+	if (currentDepth > 0) {
+		throw new Error("Nested transactions are not supported for this database instance");
+	}
+	transactionDepthByDatabase.set(db, currentDepth + 1);
+}
+
+function exitTransaction(db: Database): void {
+	const currentDepth = getTransactionDepth(db);
+	if (currentDepth <= 1) {
+		transactionDepthByDatabase.delete(db);
+		return;
+	}
+	transactionDepthByDatabase.set(db, currentDepth - 1);
+}
+
 export function withTransaction<T>(db: Database, fn: () => T, options: TransactionOptions = {}): T {
 	const maxRetries = options.maxRetries ?? 5;
 	const backoffMs = options.backoffMs ?? 100;
@@ -14,20 +37,25 @@ export function withTransaction<T>(db: Database, fn: () => T, options: Transacti
 	let attempts = 0;
 	while (true) {
 		try {
-			if (useImmediate) {
-				db.run("BEGIN IMMEDIATE");
-				try {
-					const result = fn();
-					db.run("COMMIT");
-					return result;
-				} catch (innerError) {
-					db.run("ROLLBACK");
-					throw innerError;
+			enterTransaction(db);
+			try {
+				if (useImmediate) {
+					db.run("BEGIN IMMEDIATE");
+					try {
+						const result = fn();
+						db.run("COMMIT");
+						return result;
+					} catch (innerError) {
+						db.run("ROLLBACK");
+						throw innerError;
+					}
 				}
-			}
 
-			const transaction = db.transaction(fn);
-			return transaction();
+				const transaction = db.transaction(fn);
+				return transaction();
+			} finally {
+				exitTransaction(db);
+			}
 		} catch (error: unknown) {
 			const e = error as Error;
 			const isBusyError =

package/src/logging/forensic-writer.ts

@@ -5,6 +5,10 @@ import {
 import type { ForensicEventDomain, ForensicEventType } from "../observability/forensic-types";
 import type { LogEntry, LogSink } from "./types";
 
+function normalizeTaskId(taskId: unknown): number | null {
+	return typeof taskId === "number" && Number.isInteger(taskId) && taskId > 0 ? taskId : null;
+}
+
 export function createForensicSinkForArtifactDir(artifactDir: string): LogSink {
 	return {
 		write(entry: LogEntry): void {
@@ -63,7 +67,7 @@ export function createForensicSinkForArtifactDir(artifactDir: string): LogSink {
 				parentSessionId: (parentSessionId as string) ?? null,
 				phase: (phase as string) ?? null,
 				dispatchId: (dispatchId as string) ?? null,
-				taskId: (taskId as number) ?? null,
+				taskId: normalizeTaskId(taskId),
 				agent: (agent as string) ?? null,
 				type: forensicType,
 				code: (code as string) ?? null,
@@ -136,7 +140,7 @@ export function createForensicSink(projectRoot: string): LogSink {
 				parentSessionId: (parentSessionId as string) ?? null,
 				phase: (phase as string) ?? null,
 				dispatchId: (dispatchId as string) ?? null,
-				taskId: (taskId as number) ?? null,
+				taskId: normalizeTaskId(taskId),
 				agent: (agent as string) ?? null,
 				type: forensicType,
 				code: (code as string) ?? null,

package/src/logging/index.ts

@@ -1,4 +1,6 @@
 export * from "./domains";
 export * from "./forensic-writer";
 export * from "./logger";
+export * from "./performance";
+export * from "./rotation";
 export * from "./types";

package/src/mcp/index.ts

@@ -0,0 +1,34 @@
+export { McpLifecycleManager } from "./manager";
+export type { McpToolAction, ScopeViolation } from "./scope-filter";
+export { filterByScope, isActionAllowed } from "./scope-filter";
+export type {
+	ManagedMcpServer,
+	McpHealthResult,
+	McpScope,
+	McpServerState,
+	McpTransport,
+	SkillMcpConfig,
+} from "./types";
+export {
+	mcpScopeSchema,
+	mcpTransportSchema,
+	skillMcpConfigSchema,
+} from "./types";
+
+let globalMcpManager: InstanceType<typeof import("./manager").McpLifecycleManager> | null = null;
+
+export function setGlobalMcpManager(
+	manager: InstanceType<typeof import("./manager").McpLifecycleManager>,
+): void {
+	globalMcpManager = manager;
+}
+
+export function getGlobalMcpManager(): InstanceType<
+	typeof import("./manager").McpLifecycleManager
+> | null {
+	return globalMcpManager;
+}
+
+export function resetGlobalMcpManager(): void {
+	globalMcpManager = null;
+}

package/src/mcp/manager.ts

@@ -0,0 +1,206 @@
+import type { ManagedMcpServer, McpHealthResult, McpServerState, SkillMcpConfig } from "./types";
+import { skillMcpConfigSchema } from "./types";
+
+const DEFAULT_HEALTH_CHECK_TIMEOUT_MS = 5000;
+
+const VALID_STATE_TRANSITIONS = Object.freeze({
+	stopped: Object.freeze(["starting"] as const),
+	starting: Object.freeze(["healthy", "unhealthy", "stopping"] as const),
+	healthy: Object.freeze(["healthy", "unhealthy", "stopping"] as const),
+	unhealthy: Object.freeze(["starting", "healthy", "unhealthy", "stopping"] as const),
+	stopping: Object.freeze(["stopped"] as const),
+}) satisfies Readonly<Record<McpServerState, readonly McpServerState[]>>;
+
+interface InternalManagedMcpServer {
+	config: SkillMcpConfig;
+	skillName: string;
+	state: McpServerState;
+	startedAt: string | null;
+	lastHealthCheck: string | null;
+	connectionCount: number;
+	referencingSkills: Set<string>;
+}
+
+function cloneServerSnapshot(server: InternalManagedMcpServer): ManagedMcpServer {
+	return Object.freeze({
+		config: {
+			...server.config,
+			args: [...server.config.args],
+			env: { ...server.config.env },
+			scope: [...server.config.scope],
+		},
+		skillName: server.skillName,
+		state: server.state,
+		startedAt: server.startedAt,
+		lastHealthCheck: server.lastHealthCheck,
+		connectionCount: server.connectionCount,
+	});
+}
+
+function cloneHealthResult(result: McpHealthResult): McpHealthResult {
+	return Object.freeze({ ...result });
+}
+
+function getValidationErrorMessage(config: SkillMcpConfig): string | null {
+	if (config.transport === "stdio" && !config.command) {
+		return "stdio transport requires a command";
+	}
+
+	if ((config.transport === "sse" || config.transport === "http") && !config.url) {
+		return `${config.transport} transport requires a url`;
+	}
+
+	return null;
+}
+
+function createInternalServer(skillName: string, config: SkillMcpConfig): InternalManagedMcpServer {
+	return {
+		config,
+		skillName,
+		state: "stopped",
+		startedAt: null,
+		lastHealthCheck: null,
+		connectionCount: 0,
+		referencingSkills: new Set<string>(),
+	};
+}
+
+export class McpLifecycleManager {
+	private readonly healthCheckTimeoutMs: number;
+
+	private readonly servers = new Map<string, InternalManagedMcpServer>();
+
+	public constructor(options?: { healthCheckTimeoutMs?: number }) {
+		this.healthCheckTimeoutMs = options?.healthCheckTimeoutMs ?? DEFAULT_HEALTH_CHECK_TIMEOUT_MS;
+	}
+
+	public async startServer(skillName: string, config: SkillMcpConfig): Promise<ManagedMcpServer> {
+		const parsedConfig = skillMcpConfigSchema.parse({
+			...config,
+			healthCheckTimeoutMs: config.healthCheckTimeoutMs ?? this.healthCheckTimeoutMs,
+		});
+		const existingServer = this.servers.get(parsedConfig.serverName);
+
+		if (existingServer) {
+			this.ensureCompatibleConfig(existingServer.config, parsedConfig);
+			existingServer.referencingSkills.add(skillName);
+			existingServer.connectionCount = existingServer.referencingSkills.size;
+
+			if (existingServer.state === "unhealthy") {
+				this.transitionState(existingServer, "starting");
+				await this.healthCheck(parsedConfig.serverName);
+			}
+
+			return cloneServerSnapshot(existingServer);
+		}
+
+		const server = createInternalServer(skillName, parsedConfig);
+		server.referencingSkills.add(skillName);
+		server.connectionCount = 1;
+		server.startedAt = new Date().toISOString();
+		this.transitionState(server, "starting");
+		this.servers.set(parsedConfig.serverName, server);
+
+		await this.healthCheck(parsedConfig.serverName);
+		return cloneServerSnapshot(server);
+	}
+
+	public async stopServer(serverName: string): Promise<void> {
+		const server = this.servers.get(serverName);
+		if (!server) return;
+
+		if (server.connectionCount > 1) {
+			const [firstSkillName] = server.referencingSkills;
+			if (firstSkillName) {
+				server.referencingSkills.delete(firstSkillName);
+			}
+			server.connectionCount = server.referencingSkills.size;
+			return;
+		}
+
+		this.transitionState(server, "stopping");
+		server.connectionCount = 0;
+		server.referencingSkills.clear();
+		server.startedAt = null;
+		this.transitionState(server, "stopped");
+		this.servers.delete(serverName);
+	}
+
+	public async stopAll(): Promise<void> {
+		await Promise.all([...this.servers.keys()].map((serverName) => this.stopServer(serverName)));
+	}
+
+	public getServer(serverName: string): ManagedMcpServer | undefined {
+		const server = this.servers.get(serverName);
+		return server ? cloneServerSnapshot(server) : undefined;
+	}
+
+	public listServers(): readonly ManagedMcpServer[] {
+		return Object.freeze(
+			[...this.servers.values()]
+				.sort((left, right) => left.config.serverName.localeCompare(right.config.serverName))
+				.map((server) => cloneServerSnapshot(server)),
+		);
+	}
+
+	public async healthCheck(serverName: string): Promise<McpHealthResult> {
+		const server = this.servers.get(serverName);
+		if (!server) {
+			return cloneHealthResult({
+				serverName,
+				skillName: "",
+				state: "stopped",
+				latencyMs: null,
+				error: "Server not found",
+			});
+		}
+
+		const startedAt = Date.now();
+		const validationMessage = getValidationErrorMessage(server.config);
+		const latencyMs = Math.min(Date.now() - startedAt, server.config.healthCheckTimeoutMs);
+		server.lastHealthCheck = new Date().toISOString();
+
+		if (validationMessage !== null) {
+			this.transitionState(server, "unhealthy");
+			return cloneHealthResult({
+				serverName: server.config.serverName,
+				skillName: server.skillName,
+				state: server.state,
+				latencyMs,
+				error: validationMessage,
+			});
+		}
+
+		this.transitionState(server, "healthy");
+		return cloneHealthResult({
+			serverName: server.config.serverName,
+			skillName: server.skillName,
+			state: server.state,
+			latencyMs,
+			error: null,
+		});
+	}
+
+	public async healthCheckAll(): Promise<readonly McpHealthResult[]> {
+		const healthResults = await Promise.all(
+			[...this.servers.keys()].map((serverName) => this.healthCheck(serverName)),
+		);
+		return Object.freeze(healthResults);
+	}
+
+	private ensureCompatibleConfig(current: SkillMcpConfig, next: SkillMcpConfig): void {
+		const currentConfig = JSON.stringify(current);
+		const nextConfig = JSON.stringify(next);
+		if (currentConfig !== nextConfig) {
+			throw new Error(`Conflicting MCP configuration for server '${current.serverName}'`);
+		}
+	}
+
+	private transitionState(server: InternalManagedMcpServer, nextState: McpServerState): void {
+		const allowedTransitions = VALID_STATE_TRANSITIONS[server.state] as readonly McpServerState[];
+		if (!allowedTransitions.includes(nextState)) {
+			throw new Error(`Invalid MCP state transition: ${server.state} -> ${nextState}`);
+		}
+		server.state = nextState;
+	}
+}

package/src/mcp/scope-filter.ts

@@ -0,0 +1,44 @@
+import type { McpScope } from "./types";
+
+export type McpToolAction = "read" | "write" | "execute";
+
+export interface ScopeViolation {
+	readonly serverName: string;
+	readonly skillName: string;
+	readonly requestedAction: McpToolAction;
+	readonly allowedScopes: readonly McpScope[];
+	readonly toolName: string;
+}
+
+export function isActionAllowed(
+	action: McpToolAction,
+	allowedScopes: readonly McpScope[],
+): boolean {
+	return allowedScopes.includes(action);
+}
+
+export function filterByScope(
+	toolName: string,
+	action: McpToolAction,
+	serverName: string,
+	skillName: string,
+	allowedScopes: readonly McpScope[],
+): { allowed: boolean; violation: ScopeViolation | null } {
+	if (isActionAllowed(action, allowedScopes)) {
+		return Object.freeze({
+			allowed: true,
+			violation: null,
+		});
+	}
+
+	return Object.freeze({
+		allowed: false,
+		violation: Object.freeze({
+			serverName,
+			skillName,
+			requestedAction: action,
+			allowedScopes: Object.freeze([...allowedScopes]),
+			toolName,
+		}),
+	});
+}

package/src/mcp/types.ts

@@ -0,0 +1,38 @@
+import { z } from "zod";
+
+export const mcpTransportSchema = z.enum(["stdio", "sse", "http"]);
+export type McpTransport = z.infer<typeof mcpTransportSchema>;
+
+export const mcpScopeSchema = z.enum(["read", "write", "execute"]);
+export type McpScope = z.infer<typeof mcpScopeSchema>;
+
+export const skillMcpConfigSchema = z.object({
+	serverName: z.string().min(1),
+	transport: mcpTransportSchema.default("stdio"),
+	command: z.string().min(1).optional(),
+	args: z.array(z.string()).default([]),
+	url: z.string().url().optional(),
+	env: z.record(z.string(), z.string()).default({}),
+	scope: z.array(mcpScopeSchema).default(["read"]),
+	healthCheckTimeoutMs: z.number().int().positive().default(5000),
+});
+export type SkillMcpConfig = z.infer<typeof skillMcpConfigSchema>;
+
+export type McpServerState = "stopped" | "starting" | "healthy" | "unhealthy" | "stopping";
+
+export interface ManagedMcpServer {
+	readonly config: SkillMcpConfig;
+	readonly skillName: string;
+	readonly state: McpServerState;
+	readonly startedAt: string | null;
+	readonly lastHealthCheck: string | null;
+	readonly connectionCount: number;
+}
+
+export interface McpHealthResult {
+	readonly serverName: string;
+	readonly skillName: string;
+	readonly state: McpServerState;
+	readonly latencyMs: number | null;
+	readonly error: string | null;
+}

package/src/orchestrator/arena.ts

@@ -1,4 +1,5 @@
 import type { Database } from "bun:sqlite";
+import { getLogger } from "../logging/domains";
 import { getObservationsByProject, getProjectByPath } from "../memory/repository";
 import { summarizeConfidence } from "./confidence";
 import type { ConfidenceEntry } from "./types";
@@ -16,6 +17,7 @@ const LEVEL_ORDER: Readonly<Record<ConfidenceLevel, number>> = Object.freeze({
 	MEDIUM: 2,
 	LOW: 1,
 });
+const logger = getLogger("orchestrator", "arena");
 
 /**
  * Determines arena debate depth based on aggregate confidence.
@@ -66,7 +68,11 @@ export function getMemoryTunedDepth(
 			return Math.min(baseDepth + 1, 3);
 		}
 	} catch (err) {
-		console.warn("[opencode-autopilot] memory-tuned depth failed, using base:", err);
+		logger.warn("memory-tuned depth failed, using base depth", {
+			operation: "memory_tuned_depth",
+			projectPath,
+			error: err instanceof Error ? err.message : String(err),
+		});
 	}
 	return baseDepth;
 }

package/src/orchestrator/fallback/event-handler.ts

@@ -1,8 +1,11 @@
+import { getLogger } from "../../logging/domains";
 import type { FallbackConfig } from "./fallback-config";
 import type { FallbackManager } from "./fallback-manager";
 import { replayWithDegradation } from "./message-replay";
 import type { MessagePart } from "./types";
 
+const logger = getLogger("orchestrator", "fallback-event-handler");
+
 /**
  * SDK operations interface for dependency injection.
  * Enables testing without the OpenCode runtime.
@@ -272,8 +275,16 @@ async function handleFallbackError(
 
 		// Release lock after dispatch (or skip if model unparseable)
 		manager.releaseRetryLock(sessionID);
-	} catch {
+	} catch (error: unknown) {
 		// On failure, release the lock to allow future retries
+		logger.warn("fallback replay failed", {
+			operation: "fallback",
+			sessionId: sessionID,
+			failedModel: plan.failedModel,
+			nextModel: plan.newModel,
+			reason: plan.reason,
+			error: error instanceof Error ? error.message : String(error),
+		});
 		manager.releaseRetryLock(sessionID);
 	}
 }

package/src/orchestrator/handlers/challenge.ts

@@ -1,9 +1,12 @@
+import { getLogger } from "../../logging/domains";
 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, type PhaseHandlerContext } from "./types";
 
+const logger = getLogger("orchestrator", "challenge");
+
 /**
  * CHALLENGE phase handler — dispatches oc-challenger with RECON artifact references.
  * References files by path (not content injection) per D-11.
@@ -18,7 +21,11 @@ export async function handleChallenge(
 		// 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");
+			logger.warn("CHALLENGE completed but artifact not found", {
+				operation: "phase_transition",
+				phase: "CHALLENGE",
+				artifactPath,
+			});
 		}
 		return Object.freeze({
 			action: "complete" as const,

package/src/orchestrator/handlers/plan.ts

@@ -1,4 +1,5 @@
 import { readFile, writeFile } from "node:fs/promises";
+import { getLogger } from "../../logging/domains";
 import { isEnoentError } from "../../utils/fs-helpers";
 import { getArtifactRef } from "../artifacts";
 import { normalizePlanTasks, planTasksArtifactSchema } from "../contracts/phase-artifacts";
@@ -12,6 +13,7 @@ import { AGENT_NAMES } from "./types";
 const EXPECTED_COLUMN_COUNT = 6;
 const taskIdPattern = /^W(\d+)-T(\d+)$/i;
 const separatorCellPattern = /^:?-{3,}:?$/;
+const logger = getLogger("orchestrator", "plan");
 
 function parseTableColumns(line: string): readonly string[] | null {
 	const trimmed = line.trim();
@@ -146,7 +148,12 @@ export const handlePlan: PhaseHandler = async (_state, artifactDir, result?) =>
 			if (usedLegacyMarkdown) {
 				const msg =
 					"PLAN fallback: parsed legacy tasks.md (tasks.json missing). Migrate planner output to tasks.json.";
-				console.warn(`[opencode-autopilot] ${msg}`);
+				logger.warn(msg, {
+					operation: "phase_transition",
+					phase: "PLAN",
+					tasksJsonPath,
+					tasksPath,
+				});
 				logOrchestrationEvent(artifactDir, {
 					timestamp: new Date().toISOString(),
 					phase: "PLAN",

package/src/orchestrator/handlers/recon.ts

@@ -1,9 +1,12 @@
+import { getLogger } from "../../logging/domains";
 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, type PhaseHandlerContext } from "./types";
 
+const logger = getLogger("orchestrator", "recon");
+
 /**
  * RECON phase handler — dispatches oc-researcher with idea and artifact path.
  * Uses file references (not content injection) per D-11.
@@ -18,7 +21,11 @@ export async function handleRecon(
 		// 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");
+			logger.warn("RECON completed but artifact not found", {
+				operation: "phase_transition",
+				phase: "RECON",
+				artifactPath,
+			});
 		}
 		return Object.freeze({
 			action: "complete" as const,

package/src/orchestrator/handlers/types.ts

@@ -6,12 +6,12 @@ export const AGENT_NAMES = Object.freeze({
 	CHALLENGE: "oc-challenger",
 	ARCHITECT: "oc-architect",
 	CRITIC: "oc-critic",
-	EXPLORE: "oc-explorer",
+	EXPLORE: "oc-researcher",
 	PLAN: "oc-planner",
 	BUILD: "oc-implementer",
 	REVIEW: "oc-reviewer",
 	SHIP: "oc-shipper",
-	RETROSPECTIVE: "oc-retrospector",
+	RETROSPECTIVE: "oc-shipper",
 } as const);
 
 export interface DispatchResult {

package/src/orchestrator/lesson-memory.ts

@@ -14,6 +14,7 @@ import { randomBytes } from "node:crypto";
 import { readFile, rename, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import { loadLessonMemoryFromKernel, saveLessonMemoryToKernel } from "../kernel/repository";
+import { getLogger } from "../logging/domains";
 import { ensureDir, isEnoentError } from "../utils/fs-helpers";
 import { getProjectArtifactDir } from "../utils/paths";
 import { lessonMemorySchema } from "./lesson-schemas";
@@ -25,6 +26,7 @@ const LESSON_FILE = "lesson-memory.json";
 const MAX_LESSONS = 50;
 const NINETY_DAYS_MS = 90 * 24 * 60 * 60 * 1000;
 let legacyLessonMemoryMirrorWarned = false;
+const logger = getLogger("orchestrator", "lesson-memory");
 
 /**
  * Create a valid empty lesson memory object.
@@ -97,7 +99,10 @@ export async function saveLessonMemory(memory: LessonMemory, projectRoot: string
 	} catch (error: unknown) {
 		if (!legacyLessonMemoryMirrorWarned) {
 			legacyLessonMemoryMirrorWarned = true;
-			console.warn("[opencode-autopilot] lesson-memory.json mirror write failed:", error);
+			logger.warn("lesson-memory.json mirror write failed", {
+				operation: "legacy_lesson_memory_mirror",
+				error: error instanceof Error ? error.message : String(error),
+			});
 		}
 	}
 }

package/src/orchestrator/orchestration-logger.ts

@@ -2,6 +2,8 @@ import { getLogger } from "../logging/domains";
 import { createForensicSinkForArtifactDir } from "../logging/forensic-writer";
 import type { LogLevel } from "../logging/types";
 
+const logger = getLogger("orchestrator", "orchestration-logger");
+
 export interface OrchestrationEvent {
 	readonly timestamp: string;
 	readonly phase: string;
@@ -36,10 +38,12 @@ export function logOrchestrationEvent(artifactDir: string, event: OrchestrationE
 
 		const metadata = {
 			domain,
+			subsystem: event.phase.toLowerCase(),
 			operation,
 			runId: event.runId ?? null,
 			sessionId: event.sessionId ?? null,
 			phase: event.phase,
+			timestamp: event.timestamp,
 			dispatchId: event.dispatchId ?? null,
 			taskId: event.taskId ?? null,
 			agent: event.agent ?? null,
@@ -61,9 +65,17 @@ export function logOrchestrationEvent(artifactDir: string, event: OrchestrationE
 
 		const globalLogger = getLogger(domain);
 		if (event.action === "error") {
-			globalLogger.error(event.message ?? event.action, { operation, phase: event.phase });
+			globalLogger.error(event.message ?? event.action, metadata);
 		} else {
-			globalLogger.info(event.message ?? event.action, { operation, phase: event.phase });
+			globalLogger.info(event.message ?? event.action, metadata);
 		}
-	} catch {}
+	} catch (error: unknown) {
+		logger.warn("failed to log orchestration event", {
+			operation: "error",
+			error: error instanceof Error ? error.message : String(error),
+			phase: event.phase,
+			action: event.action,
+			timestamp: event.timestamp,
+		});
+	}
 }