@kodrunhq/opencode-autopilot 1.15.2 → 1.17.0

package/src/observability/log-writer.ts

@@ -1,93 +1,51 @@
-/**
- * Session log persistence layer.
- *
- * Writes complete session logs as JSON files with atomic write pattern
- * (temp file + rename) to prevent corruption. Logs are stored in
- * ~/.config/opencode/logs/ (user-scoped, not project-scoped per D-08, D-09).
- */
+import { getProjectArtifactDir, getProjectRootFromArtifactDir } from "../utils/paths";
+import { appendForensicEvent } from "./forensic-log";
+import type { ForensicEvent } from "./forensic-types";
 
-import { randomBytes } from "node:crypto";
-import { rename, writeFile } from "node:fs/promises";
-import { join } from "node:path";
-import { ensureDir } from "../utils/fs-helpers";
-import { getGlobalConfigDir } from "../utils/paths";
-import { sessionLogSchema } from "./schemas";
-import type { SessionEvent, SessionLog } from "./types";
-
-/**
- * Returns the global logs directory path.
- * Logs are user-scoped, not project-scoped (D-08, D-09).
- */
-export function getLogsDir(): string {
-	return join(getGlobalConfigDir(), "logs");
+export interface WriteSessionInput {
+	readonly projectRoot: string;
+	readonly sessionId: string;
+	readonly startedAt: string;
+	readonly endedAt?: string | null;
+	readonly events: readonly ForensicEvent[];
 }
 
-/**
- * Input shape for writeSessionLog -- the in-memory data to persist.
- */
-interface WriteSessionInput {
+interface LegacyWriteSessionInput {
 	readonly sessionId: string;
 	readonly startedAt: string;
-	readonly events: readonly SessionEvent[];
+	readonly endedAt?: string | null;
+	readonly events: readonly ForensicEvent[];
 }
 
-/**
- * Converts in-memory session events to the persisted SessionLog format.
- *
- * Extracts decisions from decision-type events.
- * Builds errorSummary by counting error events by errorType.
- */
-export function convertToSessionLog(input: WriteSessionInput): SessionLog {
-	const decisions = input.events
-		.filter((e): e is SessionEvent & { type: "decision" } => e.type === "decision")
-		.map((e) => ({
-			timestamp: e.timestamp,
-			phase: e.phase,
-			agent: e.agent,
-			decision: e.decision,
-			rationale: e.rationale,
-		}));
-
-	const errorSummary: Record<string, number> = {};
-	for (const e of input.events) {
-		if (e.type === "error") {
-			errorSummary[e.errorType] = (errorSummary[e.errorType] ?? 0) + 1;
-		}
-	}
-
-	return {
-		schemaVersion: 1 as const,
-		sessionId: input.sessionId,
-		startedAt: input.startedAt,
-		endedAt: new Date().toISOString(),
-		events: [...input.events],
-		decisions,
-		errorSummary,
-	};
+export function getLogsDir(projectRoot: string): string {
+	return getProjectArtifactDir(projectRoot);
 }
 
-/**
- * Persists a session log to disk as a JSON file.
- *
- * Uses atomic write pattern: write to temp file, then rename.
- * Validates through sessionLogSchema before writing (defensive).
- * Creates the logs directory if it does not exist.
- *
- * @param input - Session data to persist
- * @param logsDir - Optional override for logs directory (for testing)
- */
-export async function writeSessionLog(input: WriteSessionInput, logsDir?: string): Promise<void> {
-	const raw = convertToSessionLog(input);
-
-	// Validate and sanitize — use parsed result (strips unknown keys, applies defaults)
-	const log = sessionLogSchema.parse(raw);
-
-	const dir = logsDir ?? getLogsDir();
-	await ensureDir(dir);
-
-	const finalPath = join(dir, `${log.sessionId}.json`);
-	const tmpPath = `${finalPath}.tmp.${randomBytes(8).toString("hex")}`;
-
-	await writeFile(tmpPath, JSON.stringify(log, null, 2), "utf-8");
-	await rename(tmpPath, finalPath);
+export async function writeSessionLog(
+	input: WriteSessionInput | LegacyWriteSessionInput,
+	projectRootOrArtifactDir?: string,
+): Promise<void> {
+	const projectRoot =
+		"projectRoot" in input
+			? input.projectRoot
+			: getProjectRootFromArtifactDir(projectRootOrArtifactDir ?? process.cwd());
+
+	for (const event of input.events) {
+		appendForensicEvent(projectRoot, {
+			timestamp: event.timestamp,
+			projectRoot,
+			domain: event.domain,
+			runId: event.runId,
+			sessionId: event.sessionId,
+			parentSessionId: event.parentSessionId,
+			phase: event.phase,
+			dispatchId: event.dispatchId,
+			taskId: event.taskId,
+			agent: event.agent,
+			type: event.type,
+			code: event.code,
+			message: event.message,
+			payload: event.payload,
+		});
+	}
 }

package/src/observability/retention.ts

@@ -1,7 +1,7 @@
 import { readdir, stat, unlink } from "node:fs/promises";
 import { join } from "node:path";
 import { isEnoentError } from "../utils/fs-helpers";
-import { getLogsDir } from "./session-logger";
+import { getGlobalConfigDir } from "../utils/paths";
 
 const DEFAULT_RETENTION_DAYS = 30;
 
@@ -25,7 +25,7 @@ interface PruneResult {
  * @returns Count of pruned files
  */
 export async function pruneOldLogs(options?: PruneOptions): Promise<PruneResult> {
-	const logsDir = options?.logsDir ?? getLogsDir();
+	const logsDir = options?.logsDir ?? join(getGlobalConfigDir(), "projects");
 	const retentionDays = options?.retentionDays ?? DEFAULT_RETENTION_DAYS;
 	const threshold = Date.now() - retentionDays * 24 * 60 * 60 * 1000;
 

package/src/observability/session-logger.ts

@@ -1,63 +1,42 @@
-import { appendFile, readFile } from "node:fs/promises";
-import { join } from "node:path";
-import { ensureDir, isEnoentError } from "../utils/fs-helpers";
-import { getGlobalConfigDir } from "../utils/paths";
-import { sessionEventSchema } from "./schemas";
-import type { SessionEvent } from "./types";
+import { getProjectRootFromArtifactDir } from "../utils/paths";
+import { appendForensicEvent, readForensicEvents } from "./forensic-log";
+import type { ForensicEvent } from "./forensic-types";
 
-/**
- * Returns the global logs directory path.
- * Logs are user-scoped, not project-scoped (D-08, D-09).
- */
-export function getLogsDir(): string {
-	return join(getGlobalConfigDir(), "logs");
+export function getLogsDir(projectRoot: string): string {
+	return projectRoot;
 }
 
-/**
- * Returns the JSONL log file path for a given session ID.
- */
-function getSessionLogPath(sessionId: string, logsDir?: string): string {
-	return join(logsDir ?? getLogsDir(), `${sessionId}.jsonl`);
+export async function logEvent(
+	event: ForensicEvent,
+	artifactDirOrProjectRoot?: string,
+): Promise<void> {
+	const projectRoot = artifactDirOrProjectRoot
+		? getProjectRootFromArtifactDir(artifactDirOrProjectRoot)
+		: event.projectRoot;
+
+	appendForensicEvent(projectRoot, {
+		timestamp: event.timestamp,
+		projectRoot,
+		domain: event.domain,
+		runId: event.runId,
+		sessionId: event.sessionId,
+		parentSessionId: event.parentSessionId,
+		phase: event.phase,
+		dispatchId: event.dispatchId,
+		taskId: event.taskId,
+		agent: event.agent,
+		type: event.type,
+		code: event.code,
+		message: event.message,
+		payload: event.payload,
+	});
 }
 
-/**
- * Logs a structured event to the session's JSONL log file.
- * Validates the event against the Zod schema before writing.
- * Creates the logs directory if it does not exist.
- *
- * @param event - The session event to log (D-02, D-04-D-07)
- * @param logsDir - Optional override for the logs directory (for testing)
- */
-export async function logEvent(event: SessionEvent, logsDir?: string): Promise<void> {
-	// Validate against schema -- throws on invalid events
-	const validated = sessionEventSchema.parse(event);
-
-	const dir = logsDir ?? getLogsDir();
-	await ensureDir(dir);
-
-	const logPath = getSessionLogPath(validated.sessionId, dir);
-	const line = `${JSON.stringify(validated)}\n`;
-
-	await appendFile(logPath, line, "utf-8");
-}
-
-/**
- * Reads and parses all events from a session's JSONL log file.
- * Returns an empty array if the session log does not exist.
- *
- * @param sessionId - The session ID to read logs for
- * @param logsDir - Optional override for the logs directory (for testing)
- */
-export async function getSessionLog(sessionId: string, logsDir?: string): Promise<SessionEvent[]> {
-	const logPath = getSessionLogPath(sessionId, logsDir);
-
-	try {
-		const content = await readFile(logPath, "utf-8");
-		const lines = content.trim().split("\n").filter(Boolean);
-
-		return lines.map((line) => sessionEventSchema.parse(JSON.parse(line)));
-	} catch (error: unknown) {
-		if (isEnoentError(error)) return [];
-		throw error;
-	}
+export async function getSessionLog(
+	sessionId: string,
+	artifactDirOrProjectRoot: string,
+): Promise<readonly ForensicEvent[]> {
+	const projectRoot = getProjectRootFromArtifactDir(artifactDirOrProjectRoot);
+	const events = await readForensicEvents(projectRoot);
+	return Object.freeze(events.filter((event) => event.sessionId === sessionId));
 }

package/src/observability/summary-generator.ts

@@ -1,14 +1,8 @@
 /**
- * Session summary generator.
- *
- * Transforms structured SessionLog data into human-readable markdown summaries
- * for post-session analysis. All functions are pure (no I/O, no side effects).
- *
- * Summaries include: metadata, decisions, errors, fallbacks, model switches,
- * and a strategic one-paragraph analysis (D-03, D-11, D-42, D-43).
+ * Session summary generator over the unified forensic event stream.
  */
 
-import type { SessionEvent, SessionLog } from "./types";
+import type { ForensicEvent, SessionLog } from "./types";
 
 /**
  * Computes session duration in milliseconds from startedAt/endedAt.
@@ -61,7 +55,7 @@ export function generateSessionSummary(log: SessionLog): string {
 
 	// Errors section (conditional)
 	const errorEvents = log.events.filter(
-		(e): e is SessionEvent & { type: "error" } => e.type === "error",
+		(e): e is ForensicEvent & { type: "error" } => e.type === "error",
 	);
 	if (errorEvents.length > 0) {
 		sections.push(renderErrors(errorEvents, log.errorSummary));
@@ -69,7 +63,7 @@ export function generateSessionSummary(log: SessionLog): string {
 
 	// Fallbacks section (conditional)
 	const fallbackEvents = log.events.filter(
-		(e): e is SessionEvent & { type: "fallback" } => e.type === "fallback",
+		(e): e is ForensicEvent & { type: "fallback" } => e.type === "fallback",
 	);
 	if (fallbackEvents.length > 0) {
 		sections.push(renderFallbacks(fallbackEvents));
@@ -77,7 +71,7 @@ export function generateSessionSummary(log: SessionLog): string {
 
 	// Model switches section (conditional)
 	const switchEvents = log.events.filter(
-		(e): e is SessionEvent & { type: "model_switch" } => e.type === "model_switch",
+		(e): e is ForensicEvent & { type: "model_switch" } => e.type === "model_switch",
 	);
 	if (switchEvents.length > 0) {
 		sections.push(renderModelSwitches(switchEvents));
@@ -121,7 +115,7 @@ function renderDecisions(log: SessionLog): string {
 }
 
 function renderErrors(
-	events: readonly (SessionEvent & { type: "error" })[],
+	events: readonly (ForensicEvent & { type: "error" })[],
 	errorSummary: Record<string, number>,
 ): string {
 	const lines = [
@@ -133,8 +127,13 @@ function renderErrors(
 
 	for (const e of events) {
 		const safeMsg = (e.message ?? "").replace(/\|/g, "\\|").replace(/\n/g, " ");
-		const safeModel = (e.model ?? "").replace(/\|/g, "\\|");
-		lines.push(`| ${e.timestamp} | ${e.errorType} | ${safeModel} | ${safeMsg} |`);
+		const safeModel = (typeof e.payload.model === "string" ? e.payload.model : "").replace(
+			/\|/g,
+			"\\|",
+		);
+		const errorCode =
+			e.code ?? (typeof e.payload.errorType === "string" ? e.payload.errorType : "unknown");
+		lines.push(`| ${e.timestamp} | ${errorCode} | ${safeModel} | ${safeMsg} |`);
 	}
 
 	// Error summary counts
@@ -150,7 +149,7 @@ function renderErrors(
 	return lines.join("\n");
 }
 
-function renderFallbacks(events: readonly (SessionEvent & { type: "fallback" })[]): string {
+function renderFallbacks(events: readonly (ForensicEvent & { type: "fallback" })[]): string {
 	const lines = [
 		"## Fallbacks",
 		"",
@@ -159,15 +158,23 @@ function renderFallbacks(events: readonly (SessionEvent & { type: "fallback" })[
 	];
 
 	for (const e of events) {
+		const failedModel =
+			typeof e.payload.failedModel === "string" ? e.payload.failedModel : "unknown";
+		const nextModel = typeof e.payload.nextModel === "string" ? e.payload.nextModel : "unknown";
+		const reason =
+			typeof e.payload.reason === "string" ? e.payload.reason : (e.message ?? "unknown");
+		const success = e.payload.success === true;
 		lines.push(
-			`| ${e.timestamp} | ${e.failedModel} | ${e.nextModel} | ${e.reason} | ${e.success ? "Yes" : "No"} |`,
+			`| ${e.timestamp} | ${failedModel} | ${nextModel} | ${reason} | ${success ? "Yes" : "No"} |`,
 		);
 	}
 
 	return lines.join("\n");
 }
 
-function renderModelSwitches(events: readonly (SessionEvent & { type: "model_switch" })[]): string {
+function renderModelSwitches(
+	events: readonly (ForensicEvent & { type: "model_switch" })[],
+): string {
 	const lines = [
 		"## Model Switches",
 		"",
@@ -176,7 +183,10 @@ function renderModelSwitches(events: readonly (SessionEvent & { type: "model_swi
 	];
 
 	for (const e of events) {
-		lines.push(`| ${e.timestamp} | ${e.fromModel} | ${e.toModel} | ${e.trigger} |`);
+		const fromModel = typeof e.payload.fromModel === "string" ? e.payload.fromModel : "unknown";
+		const toModel = typeof e.payload.toModel === "string" ? e.payload.toModel : "unknown";
+		const trigger = typeof e.payload.trigger === "string" ? e.payload.trigger : "unknown";
+		lines.push(`| ${e.timestamp} | ${fromModel} | ${toModel} | ${trigger} |`);
 	}
 
 	return lines.join("\n");
@@ -194,7 +204,9 @@ function renderStrategicSummary(log: SessionLog): string {
 	);
 
 	if (errorCount > 0) {
-		const successfulFallbacks = log.events.filter((e) => e.type === "fallback" && e.success).length;
+		const successfulFallbacks = log.events.filter(
+			(e) => e.type === "fallback" && e.payload.success === true,
+		).length;
 		parts.push(
 			`Encountered ${errorCount} errors; ${fallbackCount} fallback attempts (${successfulFallbacks} successful).`,
 		);

package/src/observability/types.ts

@@ -1,24 +1,12 @@
-import type { z } from "zod";
-import type {
-	baseEventSchema,
-	decisionEventSchema,
-	errorEventSchema,
-	fallbackEventSchema,
-	loggingConfigSchema,
-	modelSwitchEventSchema,
-	sessionDecisionSchema,
-	sessionEventSchema,
-	sessionLogSchema,
-} from "./schemas";
-
-export type SessionEventType = "fallback" | "error" | "decision" | "model_switch";
-
-export type BaseEvent = z.infer<typeof baseEventSchema>;
-export type FallbackEvent = z.infer<typeof fallbackEventSchema>;
-export type ErrorEvent = z.infer<typeof errorEventSchema>;
-export type DecisionEvent = z.infer<typeof decisionEventSchema>;
-export type ModelSwitchEvent = z.infer<typeof modelSwitchEventSchema>;
-export type SessionEvent = z.infer<typeof sessionEventSchema>;
-export type LoggingConfig = z.infer<typeof loggingConfigSchema>;
-export type SessionDecision = z.infer<typeof sessionDecisionSchema>;
-export type SessionLog = z.infer<typeof sessionLogSchema>;
+export type {
+	ForensicEvent,
+	ForensicEvent as SessionEvent,
+	ForensicEventDomain,
+	ForensicEventType,
+} from "./forensic-types";
+export type {
+	EventSearchFilters,
+	SessionDecision,
+	SessionLog,
+	SessionLogEntry,
+} from "./log-reader";

package/src/orchestrator/contracts/invariants.ts

@@ -33,6 +33,13 @@ function collectPendingDispatchKeys(state: Readonly<PipelineState>): readonly st
 	return state.pendingDispatches.map((entry) => `${entry.dispatchId}|${entry.phase}`);
 }
 
+function hasPendingDispatchOutsideCurrentPhase(state: Readonly<PipelineState>): boolean {
+	if (state.currentPhase === null) {
+		return state.pendingDispatches.length > 0;
+	}
+	return state.pendingDispatches.some((entry) => entry.phase !== state.currentPhase);
+}
+
 export function validateStateInvariants(
 	state: Readonly<PipelineState>,
 ): readonly InvariantViolation[] {
@@ -93,6 +100,13 @@ export function validateStateInvariants(
 		});
 	}
 
+	if (hasPendingDispatchOutsideCurrentPhase(state)) {
+		violations.push({
+			code: "E_INVARIANT_PENDING_PHASE",
+			message: "pendingDispatches must belong to the current active phase only",
+		});
+	}
+
 	const processedIds = state.processedResultIds;
 	if (new Set(processedIds).size !== processedIds.length) {
 		violations.push({

package/src/orchestrator/contracts/legacy-result-adapter.ts

@@ -2,20 +2,19 @@ import { z } from "zod";
 import type { Phase } from "../types";
 import { type ResultEnvelope, resultEnvelopeSchema } from "./result-envelope";
 
-export interface ParseResultEnvelopeResult {
+export interface ParseTypedResultEnvelopeResult {
 	readonly envelope: ResultEnvelope;
-	readonly legacy: boolean;
 }
 
-export function parseResultEnvelope(
+export function parseTypedResultEnvelope(
 	raw: string,
-	ctx: {
+	_ctx: {
 		readonly runId: string;
 		readonly phase: Phase;
 		readonly fallbackDispatchId: string;
 		readonly fallbackAgent?: string | null;
 	},
-): ParseResultEnvelopeResult {
+): ParseTypedResultEnvelopeResult {
 	const trimmed = raw.trim();
 	if (trimmed.length === 0) {
 		throw new Error("E_INVALID_RESULT: empty result payload");
@@ -24,24 +23,13 @@ export function parseResultEnvelope(
 	try {
 		const parsed = JSON.parse(trimmed);
 		const envelope = resultEnvelopeSchema.parse(parsed);
-		return { envelope, legacy: false };
+		return { envelope };
 	} catch (error: unknown) {
 		if (error instanceof z.ZodError) {
 			throw new Error(`E_INVALID_RESULT: ${error.issues[0]?.message ?? "invalid envelope"}`);
 		}
-		const legacyEnvelope = resultEnvelopeSchema.parse({
-			schemaVersion: 1,
-			resultId: `legacy-${ctx.fallbackDispatchId}`,
-			runId: ctx.runId,
-			phase: ctx.phase,
-			dispatchId: ctx.fallbackDispatchId,
-			agent: ctx.fallbackAgent ?? null,
-			kind: "phase_output",
-			taskId: null,
-			payload: {
-				text: raw,
-			},
-		});
-		return { envelope: legacyEnvelope, legacy: true };
+		throw new Error(
+			"E_INVALID_RESULT: Result payload must be a typed result envelope JSON object.",
+		);
 	}
 }

package/src/orchestrator/error-context.ts

@@ -0,0 +1,24 @@
+import type { PipelineState } from "./types";
+
+export function enrichErrorMessage(error: string, state: PipelineState): string {
+	const phase = state.currentPhase ?? "UNKNOWN";
+	const details: string[] = [];
+
+	if (
+		state.currentPhase === "BUILD" &&
+		state.buildProgress?.currentWave !== null &&
+		state.buildProgress?.currentWave !== undefined
+	) {
+		details.push(`wave ${state.buildProgress.currentWave}`);
+	}
+
+	if (state.buildProgress?.currentTask !== null && state.buildProgress?.currentTask !== undefined) {
+		const task = state.tasks.find((entry) => entry.id === state.buildProgress.currentTask);
+		details.push(
+			task ? `task ${task.id}: ${task.title}` : `task ${state.buildProgress.currentTask}`,
+		);
+	}
+
+	const context = details.length > 0 ? ` (${details.join(", ")})` : "";
+	return `Error in phase ${phase}${context}: ${error}`;
+}

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

@@ -26,6 +26,17 @@ export interface EventHandlerDeps {
 	readonly manager: FallbackManager;
 	readonly sdk: SdkOperations;
 	readonly config: FallbackConfig;
+	readonly onFallbackEvent?: (event: {
+		readonly type: "fallback" | "model_switch";
+		readonly sessionId: string;
+		readonly failedModel?: string;
+		readonly nextModel?: string;
+		readonly reason?: string;
+		readonly success?: boolean;
+		readonly fromModel?: string;
+		readonly toModel?: string;
+		readonly trigger?: "fallback" | "config" | "user";
+	}) => void;
 }
 
 /**
@@ -64,7 +75,7 @@ function extractSessionID(properties: Record<string, unknown>): string | undefin
  * The returned handler routes OpenCode events to the FallbackManager.
  */
 export function createEventHandler(deps: EventHandlerDeps) {
-	const { manager, sdk, config } = deps;
+	const { manager, sdk, config, onFallbackEvent } = deps;
 
 	return async (input: {
 		readonly event: { readonly type: string; readonly [key: string]: unknown };
@@ -133,7 +144,15 @@ export function createEventHandler(deps: EventHandlerDeps) {
 				const error = properties.error;
 				const modelStr = typeof properties.model === "string" ? properties.model : undefined;
 
-				await handleFallbackError(manager, sdk, config, sessionID, error, modelStr);
+				await handleFallbackError(
+					manager,
+					sdk,
+					config,
+					sessionID,
+					error,
+					modelStr,
+					onFallbackEvent,
+				);
 				return;
 			}
 
@@ -144,7 +163,15 @@ export function createEventHandler(deps: EventHandlerDeps) {
 				if (!info?.sessionID || !info.error) return;
 
 				const modelStr = typeof info.model === "string" ? info.model : undefined;
-				await handleFallbackError(manager, sdk, config, info.sessionID, info.error, modelStr);
+				await handleFallbackError(
+					manager,
+					sdk,
+					config,
+					info.sessionID,
+					info.error,
+					modelStr,
+					onFallbackEvent,
+				);
 				return;
 			}
 
@@ -165,6 +192,7 @@ async function handleFallbackError(
 	sessionID: string,
 	error: unknown,
 	modelStr?: string,
+	onFallbackEvent?: EventHandlerDeps["onFallbackEvent"],
 ): Promise<void> {
 	// All guards (self-abort, stale, retryable, lock) are inside manager.handleError
 	const plan = manager.handleError(sessionID, error, modelStr);
@@ -220,6 +248,22 @@ async function handleFallbackError(
 					});
 			}
 
+			onFallbackEvent?.({
+				type: "fallback",
+				sessionId: sessionID,
+				failedModel: plan.failedModel,
+				nextModel: plan.newModel,
+				reason: plan.reason,
+				success: true,
+			});
+			onFallbackEvent?.({
+				type: "model_switch",
+				sessionId: sessionID,
+				fromModel: plan.failedModel,
+				toModel: plan.newModel,
+				trigger: "fallback",
+			});
+
 			// Dispatch replay with fallback model
 			await sdk.promptAsync(sessionID, parsedModel, replayedParts);
 			// Mark awaiting result inside dispatch block — only when prompt was sent

package/src/orchestrator/handlers/architect.ts

@@ -2,6 +2,7 @@ import { readdir } from "node:fs/promises";
 import { join } from "node:path";
 import { sanitizeTemplateContent } from "../../review/sanitize";
 import { fileExists } from "../../utils/fs-helpers";
+import { getProjectRootFromArtifactDir } from "../../utils/paths";
 import { getMemoryTunedDepth } from "../arena";
 import { ensurePhaseDir, getArtifactRef, getPhaseDir } from "../artifacts";
 import { filterByPhase } from "../confidence";
@@ -67,7 +68,7 @@ export async function handleArchitect(
 	// Step 1: Dispatch architect(s) based on confidence depth
 	await ensurePhaseDir(artifactDir, "ARCHITECT");
 	const reconEntries = filterByPhase(state.confidence, "RECON");
-	const depth = getMemoryTunedDepth(reconEntries, join(artifactDir, ".."));
+	const depth = getMemoryTunedDepth(reconEntries, getProjectRootFromArtifactDir(artifactDir));
 	const reconRef = getArtifactRef(artifactDir, "RECON", "report.md");
 	const challengeRef = getArtifactRef(artifactDir, "CHALLENGE", "brief.md");
 	const safeIdea = sanitizeTemplateContent(state.idea).replace(/[\r\n]+/g, " ");