@gajae-code/coding-agent 0.11.11 → 0.12.1

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

@@ -25,6 +25,14 @@ import {
  * (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 {
@@ -51,57 +59,64 @@ function asArray(value: unknown): unknown[] {
 	return Array.isArray(value) ? value : [];
 }
 
-/** A disputed fact contributes pressure until it is resolved or superseded. */
+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> & { status?: unknown };
-	if (fact.disputed !== true && fact.status !== "disputed") 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 and inactive components are outside ambiguity math.
+ * 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" || component.active === false) continue;
-		const scores = isPlainObject(component.scores)
-			? component.scores
-			: isPlainObject(component.clarity_scores)
-				? component.clarity_scores
-				: {};
-		if (
-			CORE_CLARITY_DIMENSIONS.some(dimension => {
-				const score = scores[dimension];
-				return typeof score !== "number" || !Number.isFinite(score);
-			})
-		) {
-			unscored += 1;
-		}
+		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;
 }
 
-/** Compute the deterministic floor from integer units of persisted evidence. */
+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 scored = asArray(state.rounds).filter(round => isPlainObject(round) && round.lifecycle === "scored").length;
-	const autoAnswered = new Set(asArray(state.auto_answered_rounds).map(value => JSON.stringify(value))).size;
-	const ratioUnits = scored === 0 ? 0 : Math.min(10_000, Math.floor((autoAnswered * 10_000) / scored));
-	const floorUnits = Math.min(
-		10_000,
-		disputedFactCount * 1_000 + unscoredActiveComponentCount * 500 + Math.floor(ratioUnits / 20),
-	);
+	const ratio = autoAnswerRatio(state);
+	const floor =
+		DISPUTED_FACT_WEIGHT * disputedFactCount +
+		UNSCORED_COMPONENT_WEIGHT * unscoredActiveComponentCount +
+		AUTO_ANSWER_DILUTION_WEIGHT * ratio;
 	return {
-		floor: floorUnits / 10_000,
+		floor: round2(Math.min(1, Math.max(0, floor))),
 		disputed_fact_count: disputedFactCount,
 		unscored_active_component_count: unscoredActiveComponentCount,
-		auto_answer_ratio: ratioUnits / 10_000,
+		auto_answer_ratio: round2(ratio),
 	};
 }
 
@@ -113,8 +128,10 @@ export function clampReportedAmbiguity(reported: number, floor: number): Ambigui
 }
 
 /**
- * Legacy pure utility for migrations and explicit repair flows. The recorder does
- * not dispute facts when an answer is retracted: scored evidence is immutable.
+ * 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(
@@ -187,55 +204,3 @@ export function applyAmbiguityFloorToEnvelope(value: unknown): AppliedAmbiguityF
 	inner.ambiguity_floor = breakdown;
 	return { envelope: { ...envelope, state: inner }, breakdown, clamped };
 }
-export type DeepInterviewAmbiguityMilestone = "initial" | "progress" | "refined" | "ready";
-
-export function deriveAmbiguityMilestone(
-	effectiveUnits: number,
-	thresholdUnits: number,
-): DeepInterviewAmbiguityMilestone {
-	if (!Number.isSafeInteger(effectiveUnits) || effectiveUnits < 0 || effectiveUnits > 10_000) {
-		throw new RangeError("effective ambiguity units must be an integer from 0 to 10000");
-	}
-	if (!Number.isSafeInteger(thresholdUnits) || thresholdUnits < 1 || thresholdUnits > 10_000) {
-		throw new RangeError("threshold units must be an integer from 1 to 10000");
-	}
-	if (effectiveUnits <= thresholdUnits) return "ready";
-	if (effectiveUnits > 6_000) return "initial";
-	if (effectiveUnits > 3_000) return "progress";
-	return "refined";
-}
-
-export function scoreToUnits(score: number): number {
-	if (!Number.isFinite(score) || score < 0 || score > 1) throw new RangeError("score must be finite in [0, 1]");
-	/**
-	 * Scores carry at most four decimal places, but `score * 10_000` misses the
-	 * integer grid for ordinary values: `0.69 * 10_000` is `6900.000000000001` and
-	 * `0.07 * 10_000` is `700.0000000000001`. Ambiguity is fed straight back in as
-	 * `units / 10_000`, so testing the float product rejected most real scores.
-	 *
-	 * Decide from the shortest round-trip decimal instead. That is exact: every
-	 * genuine 1e-4 value has at most four fraction digits, while off-grid
-	 * precision keeps its digits (`0.00005`, `0.05000000000000001`) and is
-	 * rejected. An epsilon on the product cannot separate those two cases -- both
-	 * residuals are ~1e-13. The `[0, 1]` guard plus the four-digit cap already
-	 * bound the result to an integer in `[0, 10_000]`.
-	 */
-	const decimal = /^(\d+)(?:\.(\d{1,4}))?$/.exec(String(score));
-	if (!decimal) throw new RangeError("score must be expressed in integral 1e-4 units");
-	const units = Number(decimal[1]) * 10_000 + Number((decimal[2] ?? "").padEnd(4, "0"));
-	return units;
-}
-
-export function weightedAmbiguityUnits(
-	scores: { goal: number; constraints: number; criteria: number; context?: number },
-	type: "greenfield" | "brownfield",
-): number {
-	const goal = scoreToUnits(scores.goal);
-	const constraints = scoreToUnits(scores.constraints);
-	const criteria = scoreToUnits(scores.criteria);
-	const numerator =
-		type === "brownfield"
-			? 35 * goal + 25 * constraints + 25 * criteria + 15 * scoreToUnits(scores.context ?? Number.NaN)
-			: 40 * goal + 30 * constraints + 30 * criteria;
-	return 10_000 - Math.floor(numerator / 100 + 0.5);
-}