@gajae-code/coding-agent 0.8.1 → 0.8.2

package/src/gjc-runtime/deep-interview-recorder.ts

@@ -1,6 +1,11 @@
 import { syncSkillActiveState } from "../skill-state/active-state";
 import { deriveDeepInterviewHud } from "../skill-state/workflow-hud";
 import { WORKFLOW_STATE_VERSION } from "../skill-state/workflow-state-contract";
+import {
+	clampReportedAmbiguity,
+	computeAmbiguityFloor,
+	disputeFactsFromRetractedRound,
+} from "./deep-interview-ambiguity";
 import {
 	answerHash,
 	type DeepInterviewEstablishedFact,
@@ -14,6 +19,7 @@ import {
 import { writeSessionActivityMarker } from "./session-resolution";
 import { readExistingStateForMutation, writeGuardedWorkflowEnvelopeAtomic } from "./state-writer";
 
+export * from "./deep-interview-ambiguity";
 export * from "./deep-interview-state";
 
 /**
@@ -395,30 +401,55 @@ export async function syncDeepInterviewRecorderHud(
 	await syncRecorderHud(cwd, normalizeDeepInterviewEnvelope(read.value), sessionId);
 }
 
-/** Record an `answered` shell for one round (append-or-merge by durable key). */
+/**
+ * Record an `answered` shell for one round (append-or-merge by durable key).
+ *
+ * Retraction dynamics: replacing an already-`scored` answer is a mechanical
+ * contradiction signal (the user pivoted). The facts that round established are
+ * marked disputed, which raises the deterministic ambiguity floor immediately —
+ * without waiting for the LLM scorer to self-report a trigger.
+ */
 export async function appendOrMergeDeepInterviewRound(
 	cwd: string,
 	statePath: string,
 	input: DeepInterviewAnswerInput,
 	options: { sessionId?: string } = {},
-): Promise<{ action: AppendOrMergeAction; record: DeepInterviewRoundRecord }> {
+): Promise<{ action: AppendOrMergeAction; record: DeepInterviewRoundRecord; disputedFactIds?: string[] }> {
 	const envelope = await readEnvelope(statePath);
 	const interviewId = input.interviewId ?? interviewIdOf(envelope);
 	const shell = buildAnswerShell({ ...input, interviewId });
 	const rounds = readRounds(envelope);
+	const priorRecord = rounds.find(r => r.round_key === shell.round_key);
 	const result = appendOrMergeRound(rounds, shell);
 	if (result.action === "noop") {
 		await repairRecorderHudFromPersisted(cwd, statePath, options.sessionId);
 		return { action: result.action, record: result.record };
 	}
-	(envelope.state as Record<string, unknown>).rounds = result.rounds;
+	const inner = envelope.state as Record<string, unknown>;
+	inner.rounds = result.rounds;
+	let disputedFactIds: string[] | undefined;
+	if (result.action === "replaced" && priorRecord?.lifecycle === "scored") {
+		const facts = Array.isArray(inner.established_facts) ? inner.established_facts : [];
+		const disputed = disputeFactsFromRetractedRound(facts, shell.round);
+		if (disputed.disputedIds.length > 0) {
+			inner.established_facts = disputed.facts;
+			disputedFactIds = disputed.disputedIds;
+			// Surface the rise right away: the retraction changed the evidence, so the
+			// gating score must reflect the new floor before the next scoring pass.
+			const breakdown = computeAmbiguityFloor(inner);
+			inner.ambiguity_floor = breakdown;
+			if (typeof inner.current_ambiguity === "number") {
+				inner.current_ambiguity = clampReportedAmbiguity(inner.current_ambiguity, breakdown.floor).effective;
+			}
+		}
+	}
 	await persistEnvelope(cwd, statePath, envelope, options.sessionId, "gjc deep-interview record-answer");
 	try {
 		await syncRecorderHud(cwd, envelope, options.sessionId);
 	} catch {
 		// HUD sync is best-effort cache maintenance and must not change record semantics.
 	}
-	return { action: result.action, record: result.record };
+	return { action: result.action, record: result.record, disputedFactIds };
 }
 
 /**
@@ -459,12 +490,34 @@ export async function enrichDeepInterviewRoundScoring(
 	const envelope = await readEnvelope(statePath);
 	const interviewId = input.interviewId ?? interviewIdOf(envelope);
 	const rounds = readRounds(envelope);
-	const { rounds: nextRounds, record } = enrichRoundWithScoring(rounds, { ...input, interviewId });
+	const { rounds: enrichedRounds, record: reportedRecord } = enrichRoundWithScoring(rounds, {
+		...input,
+		interviewId,
+	});
+	// Deterministic floor (Ouroboros principle): the LLM-reported ambiguity is only a
+	// lower-bound input. Evidence persisted in state — unresolved disputed facts,
+	// unscored active components, auto-answer dilution — sets a code-computed floor
+	// the reported score can never fall under, so a pivot mechanically raises the
+	// gating score even when the scorer omits triggers.
+	const inner = envelope.state as Record<string, unknown>;
+	const breakdown = computeAmbiguityFloor({ ...inner, rounds: enrichedRounds });
+	const clampResult = clampReportedAmbiguity(input.ambiguity, breakdown.floor);
+	let record = reportedRecord;
+	let nextRounds = enrichedRounds;
+	if (clampResult.clamped) {
+		record = {
+			...reportedRecord,
+			ambiguity: clampResult.effective,
+			reported_ambiguity: input.ambiguity,
+			ambiguity_floor: breakdown.floor,
+		};
+		nextRounds = enrichedRounds.map(item => (item.round_key === record.round_key ? record : item));
+	}
 	// Fail closed: a scored transition that violates the bidirectional invariant
 	// (an active trigger that improves the affected dimension or fails to raise
 	// overall ambiguity, or a disputed/unresolved trigger lacking a rationale) must
 	// never be persisted — storing it lets the interview falsely converge. Validate
-	// against the most recent prior scored round before writing any durable state.
+	// the effective (floor-clamped) record against the most recent prior scored round.
 	const prior = latestPriorScoredRound(rounds, record.round_key, record.round);
 	const validation = validateDeepInterviewScoredTransition(prior, record);
 	if (!validation.ok) {
@@ -472,8 +525,9 @@ export async function enrichDeepInterviewRoundScoring(
 			`deep-interview scored transition for round ${record.round} is invalid and was refused: ${validation.violations.join("; ")}`,
 		);
 	}
-	(envelope.state as Record<string, unknown>).rounds = nextRounds;
-	(envelope.state as Record<string, unknown>).current_ambiguity = input.ambiguity;
+	inner.rounds = nextRounds;
+	inner.current_ambiguity = clampResult.effective;
+	inner.ambiguity_floor = breakdown;
 	await persistEnvelope(cwd, statePath, envelope, options.sessionId, "gjc deep-interview score-round");
 	await syncRecorderHud(cwd, envelope, options.sessionId);
 	return { record };

package/src/gjc-runtime/deep-interview-runtime.ts

@@ -2,6 +2,7 @@ import { createHash, randomBytes } from "node:crypto";
 import * as fs from "node:fs/promises";
 import * as os from "node:os";
 import * as path from "node:path";
+import { YAML } from "bun";
 import { syncSkillActiveState } from "../skill-state/active-state";
 import { deriveDeepInterviewHud } from "../skill-state/workflow-hud";
 import { WORKFLOW_STATE_VERSION } from "../skill-state/workflow-state-contract";
@@ -19,7 +20,7 @@ export * from "./deep-interview-recorder";
  *
  * The CLI itself does not run the Socratic interview; that lives inside the `/skill:deep-interview`
  * skill executed by the agent. This handler validates the documented argument-hint surface
- * (`[--quick|--standard|--deep] <idea>`), seeds `.gjc/state/deep-interview-state.json`, and
+ * (`[--trace] [--quick|--standard|--deep] <idea>`), seeds `.gjc/state/deep-interview-state.json`, and
  * updates the shared HUD rail via `syncSkillActiveState` so the active interview is visible to
  * the TUI.
  */
@@ -40,6 +41,68 @@ const RESOLUTION_THRESHOLDS = {
 	deep: 0.35,
 } as const;
 
+const TRACE_MAX_RELEVANT_PATHS = 12;
+const TRACE_MAX_PACKAGE_HINTS = 8;
+const TRACE_MAX_DIRECTORY_VISITS = 1200;
+const TRACE_MAX_ENTRY_VISITS = 5000;
+const TRACE_MAX_PENDING_DIRECTORIES = 1200;
+const TRACE_SKIP_DIRS = new Set([
+	".git",
+	".gjc",
+	"node_modules",
+	"dist",
+	"build",
+	"coverage",
+	".next",
+	".turbo",
+	".cache",
+	"vendor",
+	"target",
+	".venv",
+	"venv",
+	"__pycache__",
+	".pytest_cache",
+	"tmp",
+	"temp",
+	"logs",
+	"out",
+]);
+const TRACE_SOURCE_EXTENSIONS = new Set([
+	".ts",
+	".tsx",
+	".js",
+	".jsx",
+	".mts",
+	".cts",
+	".py",
+	".rs",
+	".go",
+	".java",
+	".kt",
+	".swift",
+	".md",
+	".json",
+	".yml",
+	".yaml",
+]);
+
+interface DeepInterviewTraceSummary {
+	enabled: true;
+	generated_at: string;
+	bounded: true;
+	limits: {
+		max_relevant_paths: number;
+		max_package_hints: number;
+		max_directory_visits: number;
+		max_entry_visits: number;
+		max_pending_directories: number;
+	};
+	idea_terms: string[];
+	project_hints: string[];
+	relevant_paths: Array<{ path: string; reason: string }>;
+	findings: string[];
+}
+
 type DeepInterviewResolution = keyof typeof RESOLUTION_THRESHOLDS;
 
 class DeepInterviewCommandError extends Error {
@@ -107,6 +170,134 @@ async function resolveSpecContent(rawSpec: string, cwd: string): Promise<string>
 	return rawSpec;
 }
 
+function traceTerms(idea: string): string[] {
+	const terms = new Set<string>();
+	for (const match of idea.toLowerCase().matchAll(/[a-z0-9][a-z0-9_-]{2,}/g)) {
+		const value = match[0];
+		if (["the", "and", "for", "with", "that", "this", "from", "into", "should", "would"].includes(value)) continue;
+		terms.add(value);
+		if (terms.size >= 12) break;
+	}
+	return [...terms];
+}
+
+function relativePathReason(relativePath: string, terms: readonly string[]): string | undefined {
+	const normalized = relativePath.toLowerCase();
+	const matched = terms.find(term => normalized.includes(term));
+	if (matched) return `path matches idea term "${matched}"`;
+	if (/deep[-_]?interview/i.test(relativePath)) return "path matches deep-interview workflow surface";
+	if (/skill|workflow|runtime|state/i.test(relativePath)) return "path matches workflow/runtime surface";
+	return undefined;
+}
+
+async function readPackageHints(cwd: string): Promise<string[]> {
+	const packagePath = path.join(cwd, "package.json");
+	let parsed: unknown;
+	try {
+		parsed = JSON.parse(await fs.readFile(packagePath, "utf-8"));
+	} catch {
+		return [];
+	}
+	const manifest = parsed as {
+		name?: unknown;
+		workspaces?: unknown;
+		scripts?: Record<string, unknown>;
+		dependencies?: Record<string, unknown>;
+		devDependencies?: Record<string, unknown>;
+	};
+	const hints: string[] = [];
+	if (typeof manifest.name === "string") hints.push(`package: ${manifest.name}`);
+	if (manifest.workspaces) hints.push("workspace: package.json declares workspaces");
+	const scripts = Object.keys(manifest.scripts ?? {}).slice(0, TRACE_MAX_PACKAGE_HINTS);
+	if (scripts.length > 0) hints.push(`scripts: ${scripts.join(", ")}`);
+	const deps = [...Object.keys(manifest.dependencies ?? {}), ...Object.keys(manifest.devDependencies ?? {})]
+		.filter(name => /typescript|bun|react|vite|zod|winston|commander|oclif/i.test(name))
+		.slice(0, TRACE_MAX_PACKAGE_HINTS);
+	if (deps.length > 0) hints.push(`notable dependencies: ${deps.join(", ")}`);
+	return hints.slice(0, TRACE_MAX_PACKAGE_HINTS);
+}
+
+async function collectRelevantTracePaths(
+	cwd: string,
+	terms: readonly string[],
+): Promise<Array<{ path: string; reason: string }>> {
+	const results: Array<{ path: string; reason: string; score: number }> = [];
+	const pending: Array<{ absolutePath: string; depth: number }> = [{ absolutePath: cwd, depth: 0 }];
+	let visitedDirectories = 0;
+	let visitedEntries = 0;
+	while (
+		pending.length > 0 &&
+		visitedDirectories < TRACE_MAX_DIRECTORY_VISITS &&
+		visitedEntries < TRACE_MAX_ENTRY_VISITS
+	) {
+		const current = pending.shift();
+		if (!current) break;
+		visitedDirectories += 1;
+		try {
+			const directory = await fs.opendir(current.absolutePath);
+			for await (const entry of directory) {
+				visitedEntries += 1;
+				if (visitedEntries > TRACE_MAX_ENTRY_VISITS) break;
+				if (TRACE_SKIP_DIRS.has(entry.name)) continue;
+				const absolutePath = path.join(current.absolutePath, entry.name);
+				const relativePath = path.relative(cwd, absolutePath).split(path.sep).join("/");
+				if (entry.isDirectory()) {
+					if (current.depth < 6 && pending.length < TRACE_MAX_PENDING_DIRECTORIES) {
+						pending.push({ absolutePath, depth: current.depth + 1 });
+					}
+					continue;
+				}
+				if (!entry.isFile() || !TRACE_SOURCE_EXTENSIONS.has(path.extname(entry.name))) continue;
+				const reason = relativePathReason(relativePath, terms);
+				if (!reason) continue;
+				const termScore = terms.reduce(
+					(score, term) => score + (relativePath.toLowerCase().includes(term) ? 2 : 0),
+					0,
+				);
+				const surfaceScore = /deep[-_]?interview|skill|workflow|runtime|state/i.test(relativePath) ? 1 : 0;
+				results.push({ path: relativePath, reason, score: termScore + surfaceScore });
+			}
+		} catch {}
+	}
+	return results
+		.sort((a, b) => b.score - a.score || a.path.localeCompare(b.path))
+		.slice(0, TRACE_MAX_RELEVANT_PATHS)
+		.map(({ path: relativePath, reason }) => ({ path: relativePath, reason }));
+}
+
+async function buildDeepInterviewTraceSummary(cwd: string, idea: string): Promise<DeepInterviewTraceSummary> {
+	const terms = traceTerms(idea);
+	const [projectHints, relevantPaths] = await Promise.all([
+		readPackageHints(cwd),
+		collectRelevantTracePaths(cwd, terms),
+	]);
+	const findings = [
+		projectHints.length > 0
+			? "Project manifest was summarized into bounded package/script/dependency hints."
+			: "No readable package.json manifest was found at the project root.",
+		relevantPaths.length > 0
+			? `Relevant path scan captured ${relevantPaths.length} bounded path hint(s) before interview questions.`
+			: "Relevant path scan found no matching source/documentation paths before interview questions.",
+		"Trace summary intentionally stores path-level evidence only; raw files and logs are excluded.",
+	];
+	return {
+		enabled: true,
+		generated_at: new Date().toISOString(),
+		bounded: true,
+		limits: {
+			max_relevant_paths: TRACE_MAX_RELEVANT_PATHS,
+			max_package_hints: TRACE_MAX_PACKAGE_HINTS,
+			max_directory_visits: TRACE_MAX_DIRECTORY_VISITS,
+			max_entry_visits: TRACE_MAX_ENTRY_VISITS,
+			max_pending_directories: TRACE_MAX_PENDING_DIRECTORIES,
+		},
+		idea_terms: terms,
+		project_hints: projectHints,
+		relevant_paths: relevantPaths,
+		findings,
+	};
+}
+
 interface ResolvedDeepInterviewArgs {
 	resolution: DeepInterviewResolution;
 	threshold: number;
@@ -114,6 +305,7 @@ interface ResolvedDeepInterviewArgs {
 	sessionId: string;
 	idea: string;
 	language?: DeepInterviewLanguagePreference;
+	trace?: DeepInterviewTraceSummary;
 	json: boolean;
 }
 
@@ -199,7 +391,7 @@ async function readModernSettingsAmbiguityThreshold(): Promise<{ threshold: numb
 	const modernConfigPath = modernSettingsPath();
 	let parsed: unknown;
 	try {
-		parsed = (await import("bun")).YAML.parse(await fs.readFile(modernConfigPath, "utf-8"));
+		parsed = YAML.parse(await fs.readFile(modernConfigPath, "utf-8"));
 	} catch {
 		return undefined;
 	}
@@ -371,6 +563,7 @@ async function resolveDeepInterviewArgs(args: readonly string[], cwd: string): P
 			skipNext = true;
 			continue;
 		}
+		if (arg === "--trace") continue;
 		if (arg === "--quick" || arg === "--standard" || arg === "--deep" || arg === "--json") continue;
 		if (arg.startsWith("-")) {
 			throw new DeepInterviewCommandError(2, `unknown flag for gjc deep-interview: ${arg}`);
@@ -379,6 +572,7 @@ async function resolveDeepInterviewArgs(args: readonly string[], cwd: string): P
 	}
 	const idea = ideaParts.join(" ").trim();
 	const effectiveResolution: DeepInterviewResolution = resolution ?? "standard";
+	const trace = hasFlag(args, "--trace") && idea ? await buildDeepInterviewTraceSummary(cwd, idea) : undefined;
 	return {
 		resolution: effectiveResolution,
 		threshold,
@@ -386,6 +580,7 @@ async function resolveDeepInterviewArgs(args: readonly string[], cwd: string): P
 		sessionId,
 		idea,
 		language: resolveDeepInterviewLanguagePreference(idea),
+		trace,
 		json: hasFlag(args, "--json"),
 	};
 }
@@ -507,6 +702,17 @@ async function seedDeepInterviewState(cwd: string, resolved: ResolvedDeepIntervi
 		},
 		updated_at: now,
 	};
+	if (resolved.trace) {
+		payload.trace = resolved.trace;
+		(payload.state as Record<string, unknown>).trace = resolved.trace;
+		(payload.state as Record<string, unknown>).trace_summary = resolved.trace;
+		(payload.state as Record<string, unknown>).codebase_context = {
+			source: "trace",
+			summary: resolved.trace.findings,
+			relevant_paths: resolved.trace.relevant_paths,
+			project_hints: resolved.trace.project_hints,
+		};
+	}
 	if (resolved.language) {
 		payload.language = resolved.language;
 		(payload.state as Record<string, unknown>).language = resolved.language;
@@ -646,6 +852,7 @@ export async function runNativeDeepInterviewCommand(
 			threshold_source: resolved.thresholdSource,
 			idea: resolved.idea,
 			language: resolved.language,
+			trace: resolved.trace,
 			state_path: statePath,
 			handoff: "/skill:deep-interview",
 		};
@@ -654,6 +861,7 @@ export async function runNativeDeepInterviewCommand(
 			: [
 					`deep-interview seed state_path=${statePath}`,
 					`resolution=${resolved.resolution} threshold=${resolved.threshold} threshold_source=${resolved.thresholdSource}`,
+					resolved.trace ? `trace=enabled bounded_paths=${resolved.trace.relevant_paths.length}` : undefined,
 					"handoff=/skill:deep-interview",
 					"",
 				].join("\n");

package/src/gjc-runtime/deep-interview-state.ts

@@ -31,6 +31,13 @@ export interface DeepInterviewEstablishedFact {
 	dimension?: string;
 	evidence?: string;
 	disputed: boolean;
+	/**
+	 * Resolution pointer for a disputed fact: the id of the fact that replaced it
+	 * after the user confirmed a pivot. A disputed fact without `superseded_by`
+	 * keeps the deterministic ambiguity floor elevated; setting it releases the
+	 * pressure while preserving the contradicted fact for audit.
+	 */
+	superseded_by?: string;
 }
 
 export interface DeepInterviewTriggerMetadata {
@@ -66,7 +73,12 @@ export interface DeepInterviewRoundRecord {
 	answered_at: string;
 	scored_at?: string;
 	scores?: Record<string, number>;
+	/** Effective ambiguity after the deterministic floor clamp (`max(reported, floor)`). */
 	ambiguity?: number;
+	/** Original LLM-reported ambiguity, preserved for audit when the floor clamped it. */
+	reported_ambiguity?: number;
+	/** Deterministic floor in effect when this round was scored, when it clamped. */
+	ambiguity_floor?: number;
 	triggers?: DeepInterviewTriggerMetadata[];
 }
 
@@ -125,6 +137,7 @@ const TRANSCRIPT_STATE_FIELDS = [
 	"rounds",
 	"established_facts",
 	"current_ambiguity",
+	"ambiguity_floor",
 	"topology",
 	"ontology_snapshots",
 	"auto_researched_rounds",

package/src/gjc-runtime/session-state-sidecar.ts

@@ -3,6 +3,7 @@ import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import type { AssistantMessage } from "@gajae-code/ai";
 import { logger, postmortem } from "@gajae-code/utils";
+import { sessionRuntimeDir } from "./session-layout";
 
 export const GJC_COORDINATOR_SESSION_STATE_FILE_ENV = "GJC_COORDINATOR_SESSION_STATE_FILE";
 export const GJC_COORDINATOR_SESSION_ID_ENV = "GJC_COORDINATOR_SESSION_ID";
@@ -148,6 +149,12 @@ function shouldPreserveTerminalPayload(previous: RuntimeStateSidecarPayload): bo
 	return source === "agent_end" || source === "launch_error";
 }
 
+function runtimeStateFileForContext(context: RuntimeStateContext): string | null {
+	const explicit = process.env[GJC_COORDINATOR_SESSION_STATE_FILE_ENV]?.trim();
+	if (explicit) return explicit;
+	if (!context.sessionId.trim()) return null;
+	return path.join(sessionRuntimeDir(context.cwd, context.sessionId), "runtime-state.json");
+}
 function branchForContext(context: RuntimeStateContext): string | null {
 	return context.branch ?? (process.env[GJC_COORDINATOR_SESSION_BRANCH_ENV]?.trim() || null);
 }
@@ -160,10 +167,11 @@ function basePayload(input: {
 	source: string;
 	event: string;
 	reason: string | null;
+	sessionId: string;
 }): Record<string, unknown> {
 	return {
 		schema_version: 1,
-		session_id: process.env[GJC_COORDINATOR_SESSION_ID_ENV]?.trim() || input.context.sessionId,
+		session_id: input.sessionId,
 		state: input.state,
 		ready_for_input: input.state === "completed" || input.state === "ready_for_input",
 		updated_at: input.now,
@@ -193,30 +201,51 @@ function numericProcessExitCode(defaultCode: number | null): number | null {
 	return typeof process.exitCode === "number" ? process.exitCode : defaultCode;
 }
 
-function postmortemExitDetails(reason: postmortem.Reason): {
+function postmortemExitDetails(
+	reason: postmortem.Reason,
+	previous: RuntimeStateSidecarPayload,
+): {
 	state: RuntimeState;
 	reason: string;
 	exitKind: string;
 	exitCode: number | null;
 	signal: string | null;
 	error?: { code: string; message: string; recoverable: true };
+	recovery?: { action: string; reason: string };
 } {
 	if (reason === postmortem.Reason.EXIT || reason === postmortem.Reason.MANUAL) {
 		const exitCode = numericProcessExitCode(0) ?? 0;
-		const state: RuntimeState = exitCode === 0 ? "completed" : "errored";
+		const exitedBeforeTerminalState =
+			exitCode === 0 && reason === postmortem.Reason.EXIT && previous.state === "running";
+		const state: RuntimeState = exitCode === 0 && !exitedBeforeTerminalState ? "completed" : "errored";
+		const exitReason = exitedBeforeTerminalState
+			? "process_exit_before_terminal_state"
+			: reason === postmortem.Reason.EXIT
+				? "process_exit"
+				: "manual_cleanup";
 		return {
 			state,
-			reason: reason === postmortem.Reason.EXIT ? "process_exit" : "manual_cleanup",
+			reason: exitReason,
 			exitKind: reason,
 			exitCode,
 			signal: null,
 			...(state === "errored"
 				? {
 						error: {
-							code: "process_exit",
-							message: publicSafeErrorMessage(`GJC process exited with code ${exitCode}`),
+							code: exitReason,
+							message: publicSafeErrorMessage(
+								exitedBeforeTerminalState
+									? "GJC process exited before emitting terminal agent state"
+									: `GJC process exited with code ${exitCode}`,
+							),
 							recoverable: true,
 						},
+						recovery: {
+							action: "recover_or_resume_session",
+							reason: exitedBeforeTerminalState
+								? "previous runtime state was non-terminal; preserve the worktree and inspect the session before retrying"
+								: "process exited with a non-zero status",
+						},
 					}
 				: {}),
 		};
@@ -233,6 +262,7 @@ function postmortemExitDetails(reason: postmortem.Reason): {
 		exitCode: numericProcessExitCode(null),
 		signal: signalByReason[reason] ?? null,
 		error: { code: reason, message: errorMessageForPostmortem(reason), recoverable: true },
+		recovery: { action: "recover_or_resume_session", reason: "process cleanup ran before terminal agent state" },
 	};
 }
 
@@ -250,15 +280,27 @@ export async function persistCoordinatorRuntimeStateFromEvent(
 	event: RuntimeStateEvent,
 	context: RuntimeStateContext,
 ): Promise<void> {
-	const stateFile = process.env[GJC_COORDINATOR_SESSION_STATE_FILE_ENV]?.trim();
+	const stateFile = runtimeStateFileForContext(context);
 	if (!stateFile) return;
 	const state = stateForEvent(event);
 	if (!state) return;
 	const now = new Date().toISOString();
 	const previous = readPreviousPayload(stateFile);
 	const finalResponse = finalResponseForEvent(event);
+	const sessionId = process.env[GJC_COORDINATOR_SESSION_STATE_FILE_ENV]?.trim()
+		? process.env[GJC_COORDINATOR_SESSION_ID_ENV]?.trim() || context.sessionId
+		: context.sessionId;
 	const payload = {
-		...basePayload({ context, previous, state, now, source: "agent_session_event", event: event.type, reason: null }),
+		...basePayload({
+			context,
+			previous,
+			state,
+			now,
+			source: "agent_session_event",
+			event: event.type,
+			reason: null,
+			sessionId,
+		}),
 		...(state === "completed" || state === "errored" ? { ended_at: now } : {}),
 		...(finalResponse ? { final_response: finalResponse } : {}),
 		...(state === "errored"
@@ -282,12 +324,15 @@ export function persistCoordinatorRuntimeStateFromPostmortem(
 	reason: postmortem.Reason,
 	context: RuntimeStateContext,
 ): void {
-	const stateFile = process.env[GJC_COORDINATOR_SESSION_STATE_FILE_ENV]?.trim();
+	const stateFile = runtimeStateFileForContext(context);
 	if (!stateFile) return;
 	const previous = readPreviousPayload(stateFile);
 	if (shouldPreserveTerminalPayload(previous as RuntimeStateSidecarPayload)) return;
 	const now = new Date().toISOString();
-	const details = postmortemExitDetails(reason);
+	const details = postmortemExitDetails(reason, previous as RuntimeStateSidecarPayload);
+	const sessionId = process.env[GJC_COORDINATOR_SESSION_STATE_FILE_ENV]?.trim()
+		? process.env[GJC_COORDINATOR_SESSION_ID_ENV]?.trim() || context.sessionId
+		: context.sessionId;
 	const payload = {
 		...basePayload({
 			context,
@@ -297,6 +342,7 @@ export function persistCoordinatorRuntimeStateFromPostmortem(
 			source: "process_postmortem",
 			event: "process_exit",
 			reason: details.reason,
+			sessionId,
 		}),
 		ended_at: now,
 		detected_at: now,
@@ -304,6 +350,8 @@ export function persistCoordinatorRuntimeStateFromPostmortem(
 		exit_code: details.exitCode,
 		signal: details.signal,
 		...(details.error ? { error: details.error } : {}),
+		...(details.recovery ? { recovery: details.recovery } : {}),
+		previous_runtime_state: typeof previous.state === "string" ? previous.state : null,
 	};
 	try {
 		writeStateFileSync(stateFile, payload);
@@ -313,7 +361,7 @@ export function persistCoordinatorRuntimeStateFromPostmortem(
 }
 
 export function registerCoordinatorRuntimeStateFinalizer(context: RuntimeStateContext): () => void {
-	if (!process.env[GJC_COORDINATOR_SESSION_STATE_FILE_ENV]?.trim()) return () => {};
+	if (!runtimeStateFileForContext(context)) return () => {};
 	return postmortem.register("coordinator-runtime-state", reason => {
 		persistCoordinatorRuntimeStateFromPostmortem(reason, context);
 	});

package/src/gjc-runtime/state-runtime.ts

@@ -26,6 +26,7 @@ import {
 	type WorkflowStateReceipt,
 } from "../skill-state/workflow-state-contract";
 import { renderCliWriteReceipt } from "./cli-write-receipt";
+import { applyAmbiguityFloorToEnvelope } from "./deep-interview-ambiguity";
 import { mergeDeepInterviewEnvelope, normalizeDeepInterviewEnvelope } from "./deep-interview-state";
 import { activeSnapshotPath, auditPath, modeStatePath, sessionStateDir } from "./session-layout";
 import {
@@ -1158,7 +1159,12 @@ export async function reconcileWorkflowSkillState(options: {
 
 	const merged =
 		mode === "deep-interview"
-			? (mergeDeepInterviewEnvelope(existingPayload, payload) as Record<string, unknown>)
+			? // Enforce the deterministic ambiguity floor on every reconcile so a
+				// self-reported score can never undercut persisted contradiction evidence.
+				(applyAmbiguityFloorToEnvelope(mergeDeepInterviewEnvelope(existingPayload, payload)).envelope as Record<
+					string,
+					unknown
+				>)
 			: mergeWithNullDelete(existingPayload, payload);
 	merged.skill = mode;
 	merged.current_phase = trimmedPhase;
@@ -1355,7 +1361,11 @@ async function handleWrite(
 	if (mode === "deep-interview") {
 		// Deep-interview keeps interview data nested under `state` and merges rounds
 		// losslessly by durable key; never flatten or delete `state` (that drops recorder history).
-		merged = mergeDeepInterviewEnvelope(existingPayload, payload, { replace: hasFlag(args, "--replace") });
+		// The deterministic ambiguity floor is applied after the merge so a reported
+		// score written through the CLI can never undercut persisted contradiction evidence.
+		merged = applyAmbiguityFloorToEnvelope(
+			mergeDeepInterviewEnvelope(existingPayload, payload, { replace: hasFlag(args, "--replace") }),
+		).envelope;
 	} else if (hasFlag(args, "--replace")) {
 		merged = { ...payload };
 	} else {