@sayknow-cli/coding-agent 0.3.7 → 0.3.9

package/src/session/agent-storage.ts

@@ -420,6 +420,10 @@ FROM model_usage_legacy
 		this.#authStore.setCache(key, value, expiresAtSec);
 	}
 
+	deleteCachePrefix(prefix: string): void {
+		this.#authStore.deleteCachePrefix?.(prefix);
+	}
+
 	/**
 	 * Deletes expired cache entries. Call periodically for cleanup.
 	 */

package/src/session/file-mention-pruning.ts

@@ -0,0 +1,64 @@
+/**
+ * Staleness pruning for auto-read file-mention entries.
+ *
+ * A `@path` mention is superseded once a newer read or mention of the same
+ * resolved path appears later in the branch. Stale bodies are replaced with an
+ * explicit digest notice (never silently deleted) so context shrinks without
+ * losing the reference.
+ */
+import type { FileMentionMessage } from "./messages";
+import type { SessionEntry, SessionMessageEntry } from "./session-manager";
+
+export interface FileMentionPruneResult {
+	changed: SessionMessageEntry[];
+	bytesSaved: number;
+}
+
+/** Notice injected in place of a superseded file-mention body. */
+export function stalefileMentionNotice(path: string): string {
+	return `(pruned: a newer view of \`${path}\` appears later in the conversation; use the read tool to fetch it again)`;
+}
+
+export function pruneStaleFileMentions(
+	entries: readonly SessionEntry[],
+	resolveAbs: (path: string) => string,
+): FileMentionPruneResult {
+	// Latest branch index at which each absolute path was shown (read or mention).
+	const latestShownIndex = new Map<string, number>();
+	entries.forEach((entry, i) => {
+		if (entry.type !== "message") return;
+		const msg = entry.message;
+		if (msg.role === "fileMention") {
+			for (const file of msg.files) {
+				if (file.duplicate || file.pruned) continue;
+				latestShownIndex.set(resolveAbs(file.path), i);
+			}
+		} else if (msg.role === "toolResult") {
+			const resolved = (msg.details as { resolvedPath?: unknown } | undefined)?.resolvedPath;
+			if (typeof resolved === "string" && resolved) latestShownIndex.set(resolveAbs(resolved), i);
+		}
+	});
+
+	const changed: SessionMessageEntry[] = [];
+	let bytesSaved = 0;
+	entries.forEach((entry, i) => {
+		if (entry.type !== "message" || entry.message.role !== "fileMention") return;
+		const msg = entry.message as FileMentionMessage;
+		let mutated = false;
+		for (const file of msg.files) {
+			if (file.duplicate || file.pruned || !file.content) continue;
+			const latest = latestShownIndex.get(resolveAbs(file.path));
+			if (latest !== undefined && latest > i) {
+				const notice = stalefileMentionNotice(file.path);
+				bytesSaved += Math.max(0, Buffer.byteLength(file.content, "utf-8") - Buffer.byteLength(notice, "utf-8"));
+				file.content = notice;
+				file.pruned = true;
+				file.image = undefined;
+				file.lineCount = undefined;
+				mutated = true;
+			}
+		}
+		if (mutated) changed.push(entry as SessionMessageEntry);
+	});
+	return { changed, bytesSaved };
+}

package/src/session/messages.ts

@@ -192,6 +192,10 @@ export interface FileMentionMessage {
 		/** Why the file contents were omitted from auto-read. */
 		skippedReason?: "tooLarge";
 		image?: ImageContent;
+		/** Set when this mention duplicated a recently shown path (compact note, no full body). */
+		duplicate?: boolean;
+		/** Set when a stale entry was pruned to a digest notice (never silently deleted). */
+		pruned?: boolean;
 	}>;
 	timestamp: number;
 }

package/src/session/session-manager.ts

@@ -27,7 +27,9 @@ import {
 	Snowflake,
 	toError,
 } from "@sayknow-cli/utils";
+import type { TtsrInjectionRecord } from "../export/ttsr";
 import { writeTextAtomic } from "../skc-runtime/state-writer";
+
 import * as git from "../utils/git";
 import { ArtifactManager } from "./artifacts";
 import {
@@ -221,6 +223,10 @@ export interface TtsrInjectionEntry extends SessionEntryBase {
 	type: "ttsr_injection";
 	/** Names of rules that were injected */
 	injectedRules: string[];
+	/** Rich rule injection records with repeat state. */
+	injectedRuleRecords?: TtsrInjectionRecord[];
+	/** TTSR manager message count when this injection was recorded. */
+	ttsrMessageCount?: number;
 }
 
 /** Persisted MCP discovery selection state for a session branch. */
@@ -313,6 +319,11 @@ export interface SessionContext {
 	models: Record<string, string>;
 	/** Names of TTSR rules that have been injected this session */
 	injectedTtsrRules: string[];
+	/** Rich TTSR rule injection records for repeat resume. */
+	injectedTtsrRuleRecords?: TtsrInjectionRecord[];
+	/** TTSR manager message count for repeat resume. */
+	ttsrMessageCount?: number;
+
 	/** MCP tool names selected through discovery for this session branch. */
 	selectedMCPToolNames: string[];
 	/** Whether this branch contains an explicit persisted MCP selection entry. */
@@ -612,6 +623,9 @@ export function buildSessionContext(
 			serviceTier: undefined,
 			models: {},
 			injectedTtsrRules: [],
+			injectedTtsrRuleRecords: [],
+			ttsrMessageCount: 0,
+
 			selectedMCPToolNames: [],
 			hasPersistedMCPToolSelection: false,
 			mode: "none",
@@ -632,6 +646,8 @@ export function buildSessionContext(
 			serviceTier: undefined,
 			models: {},
 			injectedTtsrRules: [],
+			injectedTtsrRuleRecords: [],
+			ttsrMessageCount: 0,
 			selectedMCPToolNames: [],
 			hasPersistedMCPToolSelection: false,
 			mode: "none",
@@ -656,6 +672,9 @@ export function buildSessionContext(
 	const models: Record<string, string> = {};
 	let compaction: CompactionEntry | null = null;
 	const injectedTtsrRulesSet = new Set<string>();
+	const injectedTtsrRuleRecords = new Map<string, TtsrInjectionRecord>();
+	let ttsrMessageCount = 0;
+
 	let selectedMCPToolNames: string[] = [];
 	let hasPersistedMCPToolSelection = false;
 	let mode = "none";
@@ -695,9 +714,19 @@ export function buildSessionContext(
 		} else if (entry.type === "compaction") {
 			compaction = entry;
 		} else if (entry.type === "ttsr_injection") {
-			// Collect injected TTSR rule names
+			// Collect injected TTSR rule names and richer records when present.
 			for (const ruleName of entry.injectedRules) {
 				injectedTtsrRulesSet.add(ruleName);
+				if (!injectedTtsrRuleRecords.has(ruleName)) {
+					injectedTtsrRuleRecords.set(ruleName, { name: ruleName, lastInjectedAt: 0 });
+				}
+			}
+			for (const record of entry.injectedRuleRecords ?? []) {
+				injectedTtsrRulesSet.add(record.name);
+				injectedTtsrRuleRecords.set(record.name, record);
+			}
+			if (typeof entry.ttsrMessageCount === "number" && Number.isFinite(entry.ttsrMessageCount)) {
+				ttsrMessageCount = entry.ttsrMessageCount;
 			}
 		} else if (entry.type === "mcp_tool_selection") {
 			selectedMCPToolNames = [...entry.selectedToolNames];
@@ -709,6 +738,7 @@ export function buildSessionContext(
 	}
 
 	const injectedTtsrRules = Array.from(injectedTtsrRulesSet);
+	const injectedTtsrRuleRecordsArray = Array.from(injectedTtsrRuleRecords.values());
 
 	// Build messages and collect corresponding entries
 	// When there's a compaction, we need to:
@@ -797,6 +827,9 @@ export function buildSessionContext(
 		serviceTier,
 		models,
 		injectedTtsrRules,
+		injectedTtsrRuleRecords: injectedTtsrRuleRecordsArray,
+		ttsrMessageCount,
+
 		selectedMCPToolNames,
 		hasPersistedMCPToolSelection,
 		mode,
@@ -810,6 +843,9 @@ function cloneSessionContext(context: SessionContext): SessionContext {
 		messages: cloneJsonSemantic(context.messages),
 		models: { ...context.models },
 		injectedTtsrRules: [...context.injectedTtsrRules],
+		injectedTtsrRuleRecords: context.injectedTtsrRuleRecords?.map(record => ({ ...record })),
+		ttsrMessageCount: context.ttsrMessageCount,
+
 		selectedMCPToolNames: [...context.selectedMCPToolNames],
 		modeData: cloneJsonSemantic(context.modeData),
 	};
@@ -1308,6 +1344,45 @@ function isImageBlock(value: unknown): value is { type: "image"; data: string; m
 	);
 }
 
+function stripUndefinedPlainObjectFields(value: unknown, path = "entry"): unknown {
+	if (value === undefined) return undefined;
+	if (value === null || typeof value !== "object") return value;
+	if (Array.isArray(value)) {
+		let changed = false;
+		const result: unknown[] = new Array(value.length);
+		for (let index = 0; index < value.length; index++) {
+			const item = value[index];
+			if (item === undefined) {
+				throw new Error(`Session entry contains undefined array item at ${path}[${index}]`);
+			}
+			const next = stripUndefinedPlainObjectFields(item, `${path}[${index}]`);
+			if (next !== item) changed = true;
+			result[index] = next;
+		}
+		return changed ? result : value;
+	}
+
+	const prototype = Object.getPrototypeOf(value);
+	if (prototype !== Object.prototype && prototype !== null) return value;
+
+	let changed = false;
+	const entries: Array<readonly [string, unknown]> = [];
+	for (const [key, item] of Object.entries(value)) {
+		if (item === undefined) {
+			changed = true;
+			continue;
+		}
+		const next = stripUndefinedPlainObjectFields(item, `${path}.${key}`);
+		if (next !== item) changed = true;
+		entries.push([key, next]);
+	}
+	return changed ? Object.fromEntries(entries) : value;
+}
+
+function normalizeSessionEntryForStorage(entry: SessionEntry): SessionEntry {
+	return stripUndefinedPlainObjectFields(entry) as SessionEntry;
+}
+
 const RESIDENT_EXTERNALIZE_STRING_EXCLUDED_KEYS = new Set([
 	"id",
 	"type",
@@ -2254,10 +2329,12 @@ class NdjsonFileWriter {
 	}
 }
 
+const DEFAULT_WELCOME_RECENT_SESSION_LIMIT = 20;
+
 /** Get recent sessions for display in welcome screen */
 export async function getRecentSessions(
 	sessionDir: string,
-	limit = 3,
+	limit = DEFAULT_WELCOME_RECENT_SESSION_LIMIT,
 	storage: SessionStorage = new FileSessionStorage(),
 ): Promise<RecentSessionInfo[]> {
 	const sessions = await getSortedSessions(sessionDir, storage);
@@ -3734,7 +3811,8 @@ export class SessionManager {
 	}
 
 	#appendEntry(entry: SessionEntry): void {
-		const residentEntry = prepareEntryForResidentSync(entry, this.#residentBlobStores()) as SessionEntry;
+		const normalizedEntry = normalizeSessionEntryForStorage(entry);
+		const residentEntry = prepareEntryForResidentSync(normalizedEntry, this.#residentBlobStores()) as SessionEntry;
 		this.#fileEntries.push(residentEntry);
 		this.#byId.set(residentEntry.id, residentEntry);
 		this.#leafId = residentEntry.id;
@@ -3915,6 +3993,25 @@ export class SessionManager {
 		return entry.id;
 	}
 
+	/**
+	 * Append a root marker that starts a fresh active branch without changing the
+	 * session id or deleting earlier durable entries. Subsequent messages descend
+	 * from this marker, so provider context is clear while history remains
+	 * available for diagnostics/export.
+	 */
+	appendContextClearEntry(data?: Record<string, unknown>): string {
+		const entry: CustomEntry = {
+			type: "custom",
+			customType: "context_clear",
+			data,
+			id: generateId(this.#byId),
+			parentId: null,
+			timestamp: new Date().toISOString(),
+		};
+		this.#appendEntry(entry);
+		return entry.id;
+	}
+
 	/**
 	 * Write mutated message entries back into the canonical entry store by id.
 	 *
@@ -4006,13 +4103,15 @@ export class SessionManager {
 	 * @param ruleNames Names of rules that were injected
 	 * @returns Entry id
 	 */
-	appendTtsrInjection(ruleNames: string[]): string {
+	appendTtsrInjection(ruleNames: string[], records?: TtsrInjectionRecord[], ttsrMessageCount?: number): string {
 		const entry: TtsrInjectionEntry = {
 			type: "ttsr_injection",
 			id: generateId(this.#byId),
 			parentId: this.#leafId,
 			timestamp: new Date().toISOString(),
 			injectedRules: ruleNames,
+			injectedRuleRecords: records,
+			ttsrMessageCount,
 		};
 		this.#appendEntry(entry);
 		return entry.id;

package/src/skc-runtime/deep-interview-ambiguity.ts

@@ -0,0 +1,206 @@
+import {
+	type DeepInterviewEstablishedFact,
+	type DeepInterviewRoundRecord,
+	type DeepInterviewStateEnvelope,
+	normalizeDeepInterviewEnvelope,
+} from "./deep-interview-state";
+
+/**
+ * Deterministic ambiguity floor for deep-interview.
+ *
+ * The interview's ambiguity score is reported by an LLM scorer, which anchors on
+ * prior scores and under-reports rises when the user pivots or contradicts earlier
+ * answers. Following the Ouroboros `max(llm_score, deterministic_floor(ledger))`
+ * principle, this pure leaf module computes a code-level lower bound from evidence
+ * already persisted in deep-interview state, so the reported score can never fall
+ * below what code can objectively measure:
+ *
+ * - `0.10` per established fact marked disputed with no `superseded_by` resolution
+ *   (contradiction pressure — a pivot keeps ambiguity elevated until resolved);
+ * - `0.05` per active topology component whose goal/constraints/criteria clarity
+ *   is still unscored (gap pressure — a sibling component cannot hide);
+ * - `0.05 × (auto-answered rounds / scored rounds)` (assumption dilution).
+ *
+ * Like `deep-interview-state`, this module MUST stay pure and dependency-free
+ * (no filesystem, no state-writer, no CLI runtime) so every writer can apply it.
+ */
+
+// =============================================================================
+// Weights (mirrors the Ouroboros deterministic_floor coefficients)
+// =============================================================================
+
+const DISPUTED_FACT_WEIGHT = 0.1;
+const UNSCORED_COMPONENT_WEIGHT = 0.05;
+const AUTO_ANSWER_DILUTION_WEIGHT = 0.05;
+
+const CORE_CLARITY_DIMENSIONS = ["goal", "constraints", "criteria"] as const;
+
+export interface AmbiguityFloorBreakdown {
+	floor: number;
+	disputed_fact_count: number;
+	unscored_active_component_count: number;
+	auto_answer_ratio: number;
+}
+
+export interface AmbiguityClampResult {
+	effective: number;
+	clamped: boolean;
+}
+
+// =============================================================================
+// Pure helpers
+// =============================================================================
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+function asArray(value: unknown): unknown[] {
+	return Array.isArray(value) ? value : [];
+}
+
+function round2(value: number): number {
+	return Math.round(value * 100) / 100;
+}
+
+/** A disputed fact contributes pressure until it is resolved via `superseded_by` or re-confirmation. */
+function isUnresolvedDisputedFact(value: unknown): boolean {
+	if (!isPlainObject(value)) return false;
+	const fact = value as Partial<DeepInterviewEstablishedFact>;
+	if (fact.disputed !== true) return false;
+	return typeof fact.superseded_by !== "string" || fact.superseded_by.trim() === "";
+}
+
+/**
+ * An active component is unscored while any core clarity dimension lacks a finite
+ * numeric score. Deferred components are excluded (they are outside ambiguity math),
+ * and the gate only arms once the topology was explicitly confirmed in Round 0.
+ */
+function countUnscoredActiveComponents(topology: unknown): number {
+	if (!isPlainObject(topology) || topology.status !== "confirmed") return 0;
+	let unscored = 0;
+	for (const component of asArray(topology.components)) {
+		if (!isPlainObject(component) || component.status === "deferred") continue;
+		const clarity = isPlainObject(component.clarity_scores) ? component.clarity_scores : {};
+		const incomplete = CORE_CLARITY_DIMENSIONS.some(dimension => {
+			const score = clarity[dimension];
+			return typeof score !== "number" || !Number.isFinite(score);
+		});
+		if (incomplete) unscored += 1;
+	}
+	return unscored;
+}
+
+function autoAnswerRatio(inner: Record<string, unknown>): number {
+	const autoAnswered = asArray(inner.auto_answered_rounds).length;
+	if (autoAnswered === 0) return 0;
+	const scored = asArray(inner.rounds).filter(round => isPlainObject(round) && round.lifecycle === "scored").length;
+	return Math.min(1, autoAnswered / Math.max(scored, 1));
+}
+
+// =============================================================================
+// Floor computation + clamping
+// =============================================================================
+
+/** Compute the deterministic floor from the inner deep-interview `state` object. */
+export function computeAmbiguityFloor(inner: unknown): AmbiguityFloorBreakdown {
+	const state = isPlainObject(inner) ? inner : {};
+	const disputedFactCount = asArray(state.established_facts).filter(isUnresolvedDisputedFact).length;
+	const unscoredActiveComponentCount = countUnscoredActiveComponents(state.topology);
+	const ratio = autoAnswerRatio(state);
+	const floor =
+		DISPUTED_FACT_WEIGHT * disputedFactCount +
+		UNSCORED_COMPONENT_WEIGHT * unscoredActiveComponentCount +
+		AUTO_ANSWER_DILUTION_WEIGHT * ratio;
+	return {
+		floor: round2(Math.min(1, Math.max(0, floor))),
+		disputed_fact_count: disputedFactCount,
+		unscored_active_component_count: unscoredActiveComponentCount,
+		auto_answer_ratio: round2(ratio),
+	};
+}
+
+/** Clamp an LLM-reported ambiguity to the deterministic floor: `max(reported, floor)`. */
+export function clampReportedAmbiguity(reported: number, floor: number): AmbiguityClampResult {
+	const bounded = Math.min(1, Math.max(0, reported));
+	if (floor > bounded) return { effective: Math.min(1, floor), clamped: true };
+	return { effective: bounded, clamped: false };
+}
+
+/**
+ * Mark every established fact recorded in `retractedRound` as disputed. This is the
+ * mechanical contradiction signal for answer retraction: when the user replaces an
+ * already-scored answer (A -> B pivot), the facts that answer established can no
+ * longer be trusted, so they raise the floor until re-confirmed or superseded.
+ * Returns new arrays/objects; never mutates the input.
+ */
+export function disputeFactsFromRetractedRound(
+	facts: readonly unknown[],
+	retractedRound: number,
+): { facts: Record<string, unknown>[]; disputedIds: string[] } {
+	const disputedIds: string[] = [];
+	const next = facts.filter(isPlainObject).map(fact => {
+		const record = fact as Record<string, unknown>;
+		if (record.round !== retractedRound || record.disputed === true) return { ...record };
+		if (typeof record.superseded_by === "string" && record.superseded_by.trim() !== "") return { ...record };
+		if (typeof record.id === "string") disputedIds.push(record.id);
+		return { ...record, disputed: true };
+	});
+	return { facts: next, disputedIds };
+}
+
+export interface AppliedAmbiguityFloor {
+	envelope: DeepInterviewStateEnvelope;
+	breakdown: AmbiguityFloorBreakdown;
+	clamped: boolean;
+}
+
+/**
+ * Enforce the floor invariant on a full deep-interview envelope: recompute the floor
+ * from persisted evidence, clamp `state.current_ambiguity`, and clamp the latest
+ * scored round (preserving the original value as `reported_ambiguity` for audit).
+ * Historical rounds are never rewritten. Idempotent and non-mutating; every writer
+ * (state CLI write/reconcile, recorder) applies this immediately before persisting.
+ */
+export function applyAmbiguityFloorToEnvelope(value: unknown): AppliedAmbiguityFloor {
+	const envelope = normalizeDeepInterviewEnvelope(value);
+	const inner = { ...(envelope.state as Record<string, unknown>) };
+	const breakdown = computeAmbiguityFloor(inner);
+	let clamped = false;
+
+	const rounds = asArray(inner.rounds).filter(isPlainObject) as unknown as DeepInterviewRoundRecord[];
+	let latestScoredIndex = -1;
+	for (let index = 0; index < rounds.length; index += 1) {
+		const candidate = rounds[index];
+		if (candidate.lifecycle !== "scored" || !Number.isFinite(candidate.round)) continue;
+		if (latestScoredIndex < 0 || candidate.round >= rounds[latestScoredIndex].round) latestScoredIndex = index;
+	}
+	if (latestScoredIndex >= 0) {
+		const latest = rounds[latestScoredIndex];
+		if (typeof latest.ambiguity === "number") {
+			const clampedRound = clampReportedAmbiguity(latest.ambiguity, breakdown.floor);
+			if (clampedRound.clamped) {
+				const nextRounds = [...rounds];
+				nextRounds[latestScoredIndex] = {
+					...latest,
+					reported_ambiguity: latest.reported_ambiguity ?? latest.ambiguity,
+					ambiguity: clampedRound.effective,
+					ambiguity_floor: breakdown.floor,
+				};
+				inner.rounds = nextRounds;
+				clamped = true;
+			}
+		}
+	}
+
+	if (typeof inner.current_ambiguity === "number") {
+		const clampedCurrent = clampReportedAmbiguity(inner.current_ambiguity, breakdown.floor);
+		if (clampedCurrent.clamped) {
+			inner.current_ambiguity = clampedCurrent.effective;
+			clamped = true;
+		}
+	}
+
+	inner.ambiguity_floor = breakdown;
+	return { envelope: { ...envelope, state: inner }, breakdown, clamped };
+}

package/src/skc-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, "skc 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, "skc deep-interview score-round");
 	await syncRecorderHud(cwd, envelope, options.sessionId);
 	return { record };