@gajae-code/coding-agent 0.11.8 → 0.11.10

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

@@ -25,14 +25,6 @@ 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 {
@@ -59,64 +51,57 @@ 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. */
+/** A disputed fact contributes pressure until it is resolved or superseded. */
 function isUnresolvedDisputedFact(value: unknown): boolean {
 	if (!isPlainObject(value)) return false;
-	const fact = value as Partial<DeepInterviewEstablishedFact>;
-	if (fact.disputed !== true) return false;
+	const fact = value as Partial<DeepInterviewEstablishedFact> & { status?: unknown };
+	if (fact.disputed !== true && fact.status !== "disputed") 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.
+ * numeric score. Deferred and inactive components are outside ambiguity math.
  */
 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;
+		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;
+		}
 	}
 	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. */
+/** Compute the deterministic floor from integer units of persisted evidence. */
 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;
+	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),
+	);
 	return {
-		floor: round2(Math.min(1, Math.max(0, floor))),
+		floor: floorUnits / 10_000,
 		disputed_fact_count: disputedFactCount,
 		unscored_active_component_count: unscoredActiveComponentCount,
-		auto_answer_ratio: round2(ratio),
+		auto_answer_ratio: ratioUnits / 10_000,
 	};
 }
 
@@ -128,10 +113,8 @@ export function clampReportedAmbiguity(reported: number, floor: number): Ambigui
 }
 
 /**
- * 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.
+ * Legacy pure utility for migrations and explicit repair flows. The recorder does
+ * not dispute facts when an answer is retracted: scored evidence is immutable.
  * Returns new arrays/objects; never mutates the input.
  */
 export function disputeFactsFromRetractedRound(
@@ -204,3 +187,41 @@ 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]");
+	const units = score * 10_000;
+	if (!Number.isSafeInteger(units)) throw new RangeError("score must be expressed in integral 1e-4 units");
+	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);
+}