@iworkforces/tracelattice 2.0.3

package/dist/core/evaluator/PatternDetector.js

@@ -0,0 +1,192 @@
+class PatternDetector {
+    computePatternSignals(history, branches) {
+        if (0 === history.length) return [];
+        const signals = [];
+        signals.push(...this._detectConsecutiveWithoutVerification(history));
+        signals.push(...this._detectUnverifiedHypothesis(history));
+        signals.push(...this._detectNoAlternativesExplored(history, branches));
+        signals.push(...this._detectMonotonicType(history));
+        signals.push(...this._detectConfidenceDrift(history));
+        signals.push(...this._detectHealthyVerification(history));
+        return signals;
+    }
+    _detectConsecutiveWithoutVerification(history) {
+        const signals = [];
+        let runStart = 0;
+        for(let i = 0; i < history.length; i++){
+            const type = history[i].thought_type ?? 'regular';
+            if ('verification' === type) {
+                runStart = i + 1;
+                continue;
+            }
+            if (i - runStart + 1 >= 3) {
+                const start = history[runStart].thought_number ?? runStart + 1;
+                const end = history[i].thought_number ?? i + 1;
+                signals.push({
+                    pattern: 'consecutive_without_verification',
+                    severity: 'warning',
+                    message: `3+ consecutive thoughts (${start}-${end}) without verification`,
+                    thought_range: [
+                        start,
+                        end
+                    ]
+                });
+                runStart = i + 1;
+            }
+        }
+        return signals;
+    }
+    _detectUnverifiedHypothesis(history) {
+        const signals = [];
+        for(let i = 0; i < history.length; i++){
+            if ('hypothesis' !== history[i].thought_type) continue;
+            const remaining = history.length - i - 1;
+            if (remaining < 3) continue;
+            const lookahead = history.slice(i + 1, i + 4);
+            const hasVerification = lookahead.some((t)=>'verification' === t.thought_type);
+            if (!hasVerification) {
+                const n = history[i].thought_number ?? i + 1;
+                signals.push({
+                    pattern: 'unverified_hypothesis',
+                    severity: 'warning',
+                    message: `Hypothesis at thought ${n} has not been verified within 3 thoughts`,
+                    thought_range: [
+                        n,
+                        n
+                    ]
+                });
+            }
+        }
+        return signals;
+    }
+    _detectNoAlternativesExplored(history, branches) {
+        if (history.length < 5) return [];
+        if (history.some((t)=>'critique' === t.thought_type)) return [];
+        if (Object.keys(branches).length > 0) return [];
+        const start = history[0].thought_number ?? 1;
+        const end = history[history.length - 1].thought_number ?? history.length;
+        return [
+            {
+                pattern: 'no_alternatives_explored',
+                severity: 'warning',
+                message: '5+ thoughts with no critique or branching — consider exploring alternatives',
+                thought_range: [
+                    start,
+                    end
+                ]
+            }
+        ];
+    }
+    _detectMonotonicType(history) {
+        if (history.length < 5) return [];
+        const hasExplicitType = history.some((t)=>void 0 !== t.thought_type);
+        if (!hasExplicitType) return [];
+        const signals = [];
+        let runType = history[0].thought_type ?? 'regular';
+        let runStart = 0;
+        let runLength = 1;
+        for(let i = 1; i < history.length; i++){
+            const type = history[i].thought_type ?? 'regular';
+            if (type === runType) runLength++;
+            else {
+                this._flushMonotonicRun(history, runStart, runLength, runType, signals);
+                runType = type;
+                runStart = i;
+                runLength = 1;
+            }
+        }
+        this._flushMonotonicRun(history, runStart, runLength, runType, signals);
+        return signals;
+    }
+    _flushMonotonicRun(history, runStart, runLength, runType, signals) {
+        if (runLength < 4) return;
+        const start = history[runStart].thought_number ?? runStart + 1;
+        const end = history[runStart + runLength - 1].thought_number ?? runStart + runLength;
+        signals.push({
+            pattern: 'monotonic_type',
+            severity: 'warning',
+            message: `4+ consecutive '${runType}' thoughts (${start}-${end}) — consider varying approach`,
+            thought_range: [
+                start,
+                end
+            ]
+        });
+    }
+    _detectConfidenceDrift(history) {
+        const signals = [];
+        let runStart = -1;
+        let runLength = 0;
+        let prevConf = -1;
+        for(let i = 0; i < history.length; i++){
+            const conf = history[i].confidence;
+            if (void 0 === conf) {
+                this._flushDriftRun(history, runStart, runLength, signals);
+                runStart = -1;
+                runLength = 0;
+                prevConf = -1;
+                continue;
+            }
+            if (0 === runLength) {
+                runStart = i;
+                runLength = 1;
+                prevConf = conf;
+            } else if (conf < prevConf) {
+                runLength++;
+                prevConf = conf;
+            } else {
+                this._flushDriftRun(history, runStart, runLength, signals);
+                runStart = i;
+                runLength = 1;
+                prevConf = conf;
+            }
+        }
+        this._flushDriftRun(history, runStart, runLength, signals);
+        return signals;
+    }
+    _flushDriftRun(history, runStart, runLength, signals) {
+        if (runLength < 3) return;
+        const first = history[runStart];
+        const last = history[runStart + runLength - 1];
+        if (!first || !last) return;
+        if (void 0 === first.confidence || void 0 === last.confidence) return;
+        const start = first.thought_number ?? runStart + 1;
+        const end = last.thought_number ?? runStart + runLength;
+        const firstConf = first.confidence;
+        const lastConf = last.confidence;
+        signals.push({
+            pattern: 'confidence_drift',
+            severity: 'warning',
+            message: `Confidence decreasing across thoughts ${start}-${end} (${firstConf} → ${lastConf})`,
+            thought_range: [
+                start,
+                end
+            ]
+        });
+    }
+    _detectHealthyVerification(history) {
+        const signals = [];
+        for(let i = 0; i < history.length; i++){
+            if ('hypothesis' !== history[i].thought_type) continue;
+            const hypId = history[i].hypothesis_id;
+            const lookahead = history.slice(i + 1, i + 4);
+            const verifier = lookahead.find((t)=>'verification' === t.thought_type && (t.hypothesis_id === hypId || t.verification_target === (history[i].thought_number ?? i + 1)));
+            if (verifier) {
+                const n = history[i].thought_number ?? i + 1;
+                const m = verifier.thought_number ?? history.indexOf(verifier) + 1;
+                signals.push({
+                    pattern: 'healthy_verification',
+                    severity: 'info',
+                    message: `Hypothesis at thought ${n} verified at thought ${m} — good practice`,
+                    thought_range: [
+                        n,
+                        m
+                    ]
+                });
+            }
+        }
+        return signals;
+    }
+}
+export { PatternDetector };
+
+//# sourceMappingURL=PatternDetector.js.map

package/dist/core/evaluator/PatternDetector.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"core/evaluator/PatternDetector.js","sources":["../../../src/core/evaluator/PatternDetector.ts"],"sourcesContent":["/**\n * Pattern detection for sequential thinking reasoning analytics.\n *\n * Provides the {@link PatternDetector} class — a stateless service that detects\n * reasoning patterns (anti-patterns and positive signals) from thought history.\n * Extracted from {@link ThoughtEvaluator} to keep concerns isolated and reduce\n * cyclomatic complexity per function.\n *\n * Detected patterns:\n * - `consecutive_without_verification` (warning) — 3+ consecutive regular thoughts\n *   without a verification step\n * - `unverified_hypothesis` (warning) — hypothesis not verified within 3 subsequent\n *   thoughts\n * - `no_alternatives_explored` (info) — 5+ thoughts with no critique and no branches\n * - `monotonic_type` (info) — 4+ consecutive thoughts with the same thought_type\n *   (requires ≥1 explicit type and ≥5 thoughts)\n * - `confidence_drift` (warning) — 3+ consecutive thoughts with strictly decreasing\n *   confidence\n * - `healthy_verification` (info) — hypothesis verified within 3 subsequent thoughts\n *\n * @module core/evaluator/PatternDetector\n */\n\nimport type { PatternSignal } from '../reasoning.js';\nimport type { ThoughtData } from '../thought.js';\n\n/**\n * Stateless service that detects reasoning patterns from thought history.\n *\n * @remarks\n * All methods are pure computations — no side effects, no I/O, no internal state.\n * Designed to be registered as transient in the DI container or composed directly\n * into {@link ThoughtEvaluator}.\n *\n * @example\n * ```typescript\n * const detector = new PatternDetector();\n * const signals = detector.computePatternSignals(history, branches);\n * const warnings = signals.filter((s) => s.severity === 'warning');\n * ```\n */\nexport class PatternDetector {\n\t/**\n\t * Detect all reasoning patterns from history and branches.\n\t *\n\t * @param history - All thoughts in the current session\n\t * @param branches - Map of branch IDs to their thought arrays\n\t * @returns Array of detected pattern signals (possibly empty)\n\t */\n\tpublic computePatternSignals(\n\t\thistory: ThoughtData[],\n\t\tbranches: Record<string, ThoughtData[]>\n\t): PatternSignal[] {\n\t\tif (history.length === 0) return [];\n\n\t\tconst signals: PatternSignal[] = [];\n\t\tsignals.push(...this._detectConsecutiveWithoutVerification(history));\n\t\tsignals.push(...this._detectUnverifiedHypothesis(history));\n\t\tsignals.push(...this._detectNoAlternativesExplored(history, branches));\n\t\tsignals.push(...this._detectMonotonicType(history));\n\t\tsignals.push(...this._detectConfidenceDrift(history));\n\t\tsignals.push(...this._detectHealthyVerification(history));\n\t\treturn signals;\n\t}\n\n\t/** Detect runs of 3+ consecutive thoughts without verification. */\n\tprivate _detectConsecutiveWithoutVerification(history: ThoughtData[]): PatternSignal[] {\n\t\tconst signals: PatternSignal[] = [];\n\t\tlet runStart = 0;\n\t\tfor (let i = 0; i < history.length; i++) {\n\t\t\tconst type = history[i]!.thought_type ?? 'regular';\n\t\t\tif (type === 'verification') {\n\t\t\t\trunStart = i + 1;\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tif (i - runStart + 1 >= 3) {\n\t\t\t\tconst start = history[runStart]!.thought_number ?? runStart + 1;\n\t\t\t\tconst end = history[i]!.thought_number ?? i + 1;\n\t\t\t\tsignals.push({\n\t\t\t\t\tpattern: 'consecutive_without_verification',\n\t\t\t\t\tseverity: 'warning',\n\t\t\t\t\tmessage: `3+ consecutive thoughts (${start}-${end}) without verification`,\n\t\t\t\t\tthought_range: [start, end],\n\t\t\t\t});\n\t\t\t\trunStart = i + 1;\n\t\t\t}\n\t\t}\n\t\treturn signals;\n\t}\n\n\t/** Detect hypothesis thoughts not verified within 3 subsequent thoughts. */\n\tprivate _detectUnverifiedHypothesis(history: ThoughtData[]): PatternSignal[] {\n\t\tconst signals: PatternSignal[] = [];\n\t\tfor (let i = 0; i < history.length; i++) {\n\t\t\tif (history[i]!.thought_type !== 'hypothesis') continue;\n\t\t\tconst remaining = history.length - i - 1;\n\t\t\tif (remaining < 3) continue;\n\t\t\tconst lookahead = history.slice(i + 1, i + 4);\n\t\t\tconst hasVerification = lookahead.some((t) => t.thought_type === 'verification');\n\t\t\tif (!hasVerification) {\n\t\t\t\tconst n = history[i]!.thought_number ?? i + 1;\n\t\t\t\tsignals.push({\n\t\t\t\t\tpattern: 'unverified_hypothesis',\n\t\t\t\t\tseverity: 'warning',\n\t\t\t\t\tmessage: `Hypothesis at thought ${n} has not been verified within 3 thoughts`,\n\t\t\t\t\tthought_range: [n, n],\n\t\t\t\t});\n\t\t\t}\n\t\t}\n\t\treturn signals;\n\t}\n\n\t/** Detect 5+ thoughts with no critique and no branches. */\n\tprivate _detectNoAlternativesExplored(\n\t\thistory: ThoughtData[],\n\t\tbranches: Record<string, ThoughtData[]>\n\t): PatternSignal[] {\n\t\tif (history.length < 5) return [];\n\t\tif (history.some((t) => t.thought_type === 'critique')) return [];\n\t\tif (Object.keys(branches).length > 0) return [];\n\t\tconst start = history[0]!.thought_number ?? 1;\n\t\tconst end = history[history.length - 1]!.thought_number ?? history.length;\n\t\treturn [\n\t\t\t{\n\t\t\t\tpattern: 'no_alternatives_explored',\n\t\t\t\tseverity: 'warning',\n\t\t\t\tmessage: '5+ thoughts with no critique or branching — consider exploring alternatives',\n\t\t\t\tthought_range: [start, end],\n\t\t\t},\n\t\t];\n\t}\n\n\t/**\n\t * Detect runs of 4+ consecutive thoughts with the same thought_type.\n\t * Only fires when history has ≥5 thoughts and at least one explicitly set thought_type.\n\t */\n\tprivate _detectMonotonicType(history: ThoughtData[]): PatternSignal[] {\n\t\tif (history.length < 5) return [];\n\t\tconst hasExplicitType = history.some((t) => t.thought_type !== undefined);\n\t\tif (!hasExplicitType) return [];\n\n\t\tconst signals: PatternSignal[] = [];\n\t\tlet runType = history[0]!.thought_type ?? 'regular';\n\t\tlet runStart = 0;\n\t\tlet runLength = 1;\n\n\t\tfor (let i = 1; i < history.length; i++) {\n\t\t\tconst type = history[i]!.thought_type ?? 'regular';\n\t\t\tif (type === runType) {\n\t\t\t\trunLength++;\n\t\t\t} else {\n\t\t\t\tthis._flushMonotonicRun(history, runStart, runLength, runType, signals);\n\t\t\t\trunType = type;\n\t\t\t\trunStart = i;\n\t\t\t\trunLength = 1;\n\t\t\t}\n\t\t}\n\t\tthis._flushMonotonicRun(history, runStart, runLength, runType, signals);\n\t\treturn signals;\n\t}\n\n\t/** Emit a monotonic_type signal if the run length qualifies. */\n\tprivate _flushMonotonicRun(\n\t\thistory: ThoughtData[],\n\t\trunStart: number,\n\t\trunLength: number,\n\t\trunType: string,\n\t\tsignals: PatternSignal[]\n\t): void {\n\t\tif (runLength < 4) return;\n\t\tconst start = history[runStart]!.thought_number ?? runStart + 1;\n\t\tconst end = history[runStart + runLength - 1]!.thought_number ?? runStart + runLength;\n\t\tsignals.push({\n\t\t\tpattern: 'monotonic_type',\n\t\t\tseverity: 'warning',\n\t\t\tmessage: `4+ consecutive '${runType}' thoughts (${start}-${end}) — consider varying approach`,\n\t\t\tthought_range: [start, end],\n\t\t});\n\t}\n\n\t/** Detect runs of 3+ consecutive thoughts with strictly decreasing confidence. */\n\tprivate _detectConfidenceDrift(history: ThoughtData[]): PatternSignal[] {\n\t\tconst signals: PatternSignal[] = [];\n\t\tlet runStart = -1;\n\t\tlet runLength = 0;\n\t\tlet prevConf = -1;\n\n\t\tfor (let i = 0; i < history.length; i++) {\n\t\t\tconst conf = history[i]!.confidence;\n\t\t\tif (conf === undefined) {\n\t\t\t\tthis._flushDriftRun(history, runStart, runLength, signals);\n\t\t\t\trunStart = -1;\n\t\t\t\trunLength = 0;\n\t\t\t\tprevConf = -1;\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tif (runLength === 0) {\n\t\t\t\trunStart = i;\n\t\t\t\trunLength = 1;\n\t\t\t\tprevConf = conf;\n\t\t\t} else if (conf < prevConf) {\n\t\t\t\trunLength++;\n\t\t\t\tprevConf = conf;\n\t\t\t} else {\n\t\t\t\tthis._flushDriftRun(history, runStart, runLength, signals);\n\t\t\t\trunStart = i;\n\t\t\t\trunLength = 1;\n\t\t\t\tprevConf = conf;\n\t\t\t}\n\t\t}\n\t\tthis._flushDriftRun(history, runStart, runLength, signals);\n\t\treturn signals;\n\t}\n\n\t/** Emit a confidence_drift signal if the run length qualifies. */\n\tprivate _flushDriftRun(\n\t\thistory: ThoughtData[],\n\t\trunStart: number,\n\t\trunLength: number,\n\t\tsignals: PatternSignal[]\n\t): void {\n\t\tif (runLength < 3) return;\n\t\tconst first = history[runStart];\n\t\tconst last = history[runStart + runLength - 1];\n\t\tif (!first || !last) return;\n\t\tif (first.confidence === undefined || last.confidence === undefined) return;\n\t\tconst start = first.thought_number ?? runStart + 1;\n\t\tconst end = last.thought_number ?? runStart + runLength;\n\t\tconst firstConf = first.confidence;\n\t\tconst lastConf = last.confidence;\n\t\tsignals.push({\n\t\t\tpattern: 'confidence_drift',\n\t\t\tseverity: 'warning',\n\t\t\tmessage: `Confidence decreasing across thoughts ${start}-${end} (${firstConf} → ${lastConf})`,\n\t\t\tthought_range: [start, end],\n\t\t});\n\t}\n\n\t/** Detect hypothesis verified within 3 subsequent thoughts — positive signal. */\n\tprivate _detectHealthyVerification(history: ThoughtData[]): PatternSignal[] {\n\t\tconst signals: PatternSignal[] = [];\n\t\tfor (let i = 0; i < history.length; i++) {\n\t\t\tif (history[i]!.thought_type !== 'hypothesis') continue;\n\t\t\tconst hypId = history[i]!.hypothesis_id;\n\t\t\tconst lookahead = history.slice(i + 1, i + 4);\n\t\t\tconst verifier = lookahead.find(\n\t\t\t\t(t) =>\n\t\t\t\t\tt.thought_type === 'verification' &&\n\t\t\t\t\t(t.hypothesis_id === hypId ||\n\t\t\t\t\t\tt.verification_target === (history[i]!.thought_number ?? i + 1))\n\t\t\t);\n\t\t\tif (verifier) {\n\t\t\t\tconst n = history[i]!.thought_number ?? i + 1;\n\t\t\t\tconst m = verifier.thought_number ?? history.indexOf(verifier) + 1;\n\t\t\t\tsignals.push({\n\t\t\t\t\tpattern: 'healthy_verification',\n\t\t\t\t\tseverity: 'info',\n\t\t\t\t\tmessage: `Hypothesis at thought ${n} verified at thought ${m} — good practice`,\n\t\t\t\t\tthought_range: [n, m],\n\t\t\t\t});\n\t\t\t}\n\t\t}\n\t\treturn signals;\n\t}\n}\n"],"names":["PatternDetector","history","branches","signals","runStart","i","type","start","end","remaining","lookahead","hasVerification","t","n","Object","hasExplicitType","undefined","runType","runLength","prevConf","conf","first","last","firstConf","lastConf","hypId","verifier","m"],"mappings":"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"}

package/dist/core/evaluator/SignalComputer.d.ts

@@ -0,0 +1,116 @@
+/**
+ * Confidence signal computation for sequential thinking.
+ *
+ * Provides {@link SignalComputer} — a pure stateless service that computes
+ * {@link ConfidenceSignals} (including the composite `structural_quality`
+ * score and its components) from thought history and branch data.
+ *
+ * Extracted from `ThoughtEvaluator` as part of the evaluator decomposition.
+ * All methods are pure: no side effects, no I/O, no internal state.
+ *
+ * @module core/evaluator/SignalComputer
+ */
+import type { ConfidenceSignals, ThoughtType } from '../reasoning.js';
+import type { ThoughtData } from '../thought.js';
+/** Result of {@link SignalComputer.computeStructuralQuality}. */
+interface StructuralQualityResult {
+    score: number;
+    components: {
+        type_diversity: number;
+        verification_coverage: number;
+        depth_efficiency: number;
+        confidence_stability: number | null;
+    };
+    raw_components: {
+        type_diversity: number;
+        verification_coverage: number;
+        depth_efficiency: number;
+        confidence_stability: number | null;
+    };
+}
+/**
+ * Stateless service that computes {@link ConfidenceSignals} from thought history.
+ *
+ * @remarks
+ * Pure computation — no side effects, no I/O, no internal state.
+ * Safe to register as singleton or transient in DI.
+ */
+export declare class SignalComputer {
+    /**
+     * Structural quality weight configuration.
+     *
+     * Weights reflect the relative importance of each quality dimension:
+     * - type_diversity (0.3): Shannon entropy of thought types — rewards reasoning that uses
+     *   multiple cognitive modes (hypothesis, verification, critique, synthesis) rather than
+     *   monotonic sequences. Based on information theory: higher entropy = more information.
+     *
+     * - verification_coverage (0.3): Ratio of verified to total hypotheses — rewards scientific
+     *   rigor. Hypotheses without verification are speculation; verification grounds reasoning.
+     *   Equal weight with diversity because unverified reasoning is a common failure mode.
+     *
+     * - depth_efficiency (0.2): Ratio of structural depth to total thoughts — rewards efficient
+     *   reasoning. Deep chains (many revisions/branches) are good; but only if proportionally
+     *   dense. Padding with low-value thoughts penalizes this metric.
+     *
+     * - confidence_stability (0.2): Low variance in self-assessed confidence — rewards calibrated
+     *   reasoning. Wildly fluctuating confidence suggests uncertainty about the approach.
+     *   Lower weight because confidence values are LLM self-reports (inherently noisy).
+     *
+     * Design rationale:
+     * - Diversity + Verification (0.6) > Depth + Stability (0.4): Structural properties of the
+     *   reasoning DAG are more important than behavioral signals.
+     * - All weights are positive (no dimension is penalizing).
+     * - Weights sum to 1.0 for normalized scoring.
+     * - When confidence_stability is unavailable (n<2), remaining weights redistribute
+     *   proportionally: td→0.375, vc→0.375, de→0.25 (preserving relative ratios).
+     */
+    private static readonly QUALITY_WEIGHTS;
+    /**
+     * Redistributed weights when confidence_stability is excluded (n<2).
+     * Preserves relative ratios of remaining components (sum = 1.0).
+     */
+    private static readonly QUALITY_WEIGHTS_NO_CS;
+    /**
+     * Compute confidence signals from history context.
+     *
+     * @param history - All thoughts in the current session
+     * @param branches - Map of branch IDs to their thought arrays
+     * @returns Computed confidence signals reflecting reasoning quality
+     */
+    computeConfidenceSignals(history: ThoughtData[], branches: Record<string, ThoughtData[]>): ConfidenceSignals;
+    /**
+     * Compute the composite structural quality score and its components.
+     *
+     * Algorithm (all components floored at {@link FLOOR} = 0.01):
+     * - `type_diversity` = Shannon entropy of thought_type distribution / log2(6)
+     * - `verification_coverage` = verified_hypotheses / max(total_hypotheses, 1) (1.0 if none)
+     * - `depth_efficiency` = max(chain_depth, branch_count + 1) / total_thoughts, clamped to 1.0
+     * - `confidence_stability` = 1 - stddev(confidences), default 0.5 when empty, null when single value
+     * - `structural_quality` = td^0.3 * vc^0.3 * de^0.2 * cs^0.2 (weighted geometric mean)
+     *
+     * Note: When confidence_stability is null (fewer than 2 confidence values), it is
+     * excluded from the geometric mean and the remaining weights are redistributed
+     * proportionally (td→0.375, vc→0.375, de→0.25).
+     *
+     * @returns Score + components, or `null` when history is empty
+     */
+    computeStructuralQuality(history: ThoughtData[], branches: Record<string, ThoughtData[]>, typeDistribution: Record<ThoughtType, number>, confidences: number[]): StructuralQualityResult | null;
+    /**
+     * Compute confidence stability: 1 - stddev(confidences).
+     *
+     * - Empty input → 0.5 (neutral default)
+     * - Single value → null (insufficient data, excluded from structural quality)
+     * - Otherwise → max(1 - stddev, FLOOR)
+     */
+    computeConfidenceStability(confidences: number[]): number | null;
+    /**
+     * Compute raw (unfloored) confidence stability: 1 - stddev(confidences).
+     *
+     * - Empty input → 0.5 (neutral default)
+     * - Single value → null (insufficient data)
+     * - Otherwise → 1 - stddev (may be below FLOOR)
+     */
+    computeRawConfidenceStability(confidences: number[]): number | null;
+}
+export {};
+//# sourceMappingURL=SignalComputer.d.ts.map

package/dist/core/evaluator/SignalComputer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SignalComputer.d.ts","sourceRoot":"","sources":["../../../src/core/evaluator/SignalComputer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AACtE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAgBjD,iEAAiE;AACjE,UAAU,uBAAuB;IAChC,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE;QACX,cAAc,EAAE,MAAM,CAAC;QACvB,qBAAqB,EAAE,MAAM,CAAC;QAC9B,gBAAgB,EAAE,MAAM,CAAC;QACzB,oBAAoB,EAAE,MAAM,GAAG,IAAI,CAAC;KACpC,CAAC;IACF,cAAc,EAAE;QACf,cAAc,EAAE,MAAM,CAAC;QACvB,qBAAqB,EAAE,MAAM,CAAC;QAC9B,gBAAgB,EAAE,MAAM,CAAC;QACzB,oBAAoB,EAAE,MAAM,GAAG,IAAI,CAAC;KACpC,CAAC;CACF;AAED;;;;;;GAMG;AACH,qBAAa,cAAc;IAC1B;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACH,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,eAAe,CAK5B;IAEX;;;OAGG;IACH,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,qBAAqB,CAIlC;IAEX;;;;;;OAMG;IACI,wBAAwB,CAC9B,OAAO,EAAE,WAAW,EAAE,EACtB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,EAAE,CAAC,GACrC,iBAAiB;IAiCpB;;;;;;;;;;;;;;;OAeG;IACI,wBAAwB,CAC9B,OAAO,EAAE,WAAW,EAAE,EACtB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,EAAE,CAAC,EACvC,gBAAgB,EAAE,MAAM,CAAC,WAAW,EAAE,MAAM,CAAC,EAC7C,WAAW,EAAE,MAAM,EAAE,GACnB,uBAAuB,GAAG,IAAI;IA+EjC;;;;;;OAMG;IACI,0BAA0B,CAAC,WAAW,EAAE,MAAM,EAAE,GAAG,MAAM,GAAG,IAAI;IAUvE;;;;;;OAMG;IACI,6BAA6B,CAAC,WAAW,EAAE,MAAM,EAAE,GAAG,MAAM,GAAG,IAAI;CAS1E"}

package/dist/core/evaluator/SignalComputer.js

@@ -0,0 +1,110 @@
+import { ALL_THOUGHT_TYPES, _computeChainDepth, _countByType } from "./internals.js";
+const FLOOR = 0.01;
+function roundToPrecision(value, decimals = 10) {
+    const factor = Math.pow(10, decimals);
+    return Math.round(value * factor) / factor;
+}
+class SignalComputer {
+    static QUALITY_WEIGHTS = {
+        typeDiversity: 0.3,
+        verificationCoverage: 0.3,
+        depthEfficiency: 0.2,
+        confidenceStability: 0.2
+    };
+    static QUALITY_WEIGHTS_NO_CS = {
+        typeDiversity: 0.375,
+        verificationCoverage: 0.375,
+        depthEfficiency: 0.25
+    };
+    computeConfidenceSignals(history, branches) {
+        const typeDistribution = _countByType(history);
+        const allConfidences = history.map((t)=>t.confidence).filter((c)=>void 0 !== c);
+        const structuralResult = this.computeStructuralQuality(history, branches, typeDistribution, allConfidences);
+        return {
+            reasoning_depth: history.length,
+            revision_count: history.filter((t)=>t.is_revision).length,
+            branch_count: Object.keys(branches).length,
+            thought_type_distribution: typeDistribution,
+            has_hypothesis: history.some((t)=>'hypothesis' === t.thought_type),
+            has_verification: history.some((t)=>'verification' === t.thought_type),
+            average_confidence: allConfidences.length > 0 ? roundToPrecision(allConfidences.reduce((a, b)=>a + b, 0) / allConfidences.length) : null,
+            ...null !== structuralResult && {
+                structural_quality: structuralResult.score,
+                quality_components: structuralResult.components,
+                quality_components_raw: structuralResult.raw_components
+            }
+        };
+    }
+    computeStructuralQuality(history, branches, typeDistribution, confidences) {
+        if (0 === history.length) return null;
+        const total = history.length;
+        let entropy = 0;
+        for (const type of ALL_THOUGHT_TYPES){
+            const count = typeDistribution[type];
+            if (count > 0) {
+                const pk = count / total;
+                entropy -= pk * Math.log2(pk);
+            }
+        }
+        const rawTypeDiversity = entropy / Math.log2(6);
+        const typeDiversity = Math.max(rawTypeDiversity, FLOOR);
+        const hypotheses = history.filter((t)=>'hypothesis' === t.thought_type);
+        const hypothesisIds = new Set(hypotheses.map((t)=>t.hypothesis_id).filter(Boolean));
+        const verifiedIds = new Set(history.filter((t)=>'verification' === t.thought_type && t.hypothesis_id).map((t)=>t.hypothesis_id));
+        const rawVerificationCoverage = 0 === hypothesisIds.size ? 1.0 : [
+            ...hypothesisIds
+        ].filter((id)=>verifiedIds.has(id)).length / hypothesisIds.size;
+        const verificationCoverage = Math.max(rawVerificationCoverage, FLOOR);
+        const chainDepth = _computeChainDepth(history);
+        const branchCount = Object.keys(branches).length;
+        const effectiveDepth = Math.max(chainDepth, branchCount + 1);
+        const rawDepthEfficiency = Math.min(effectiveDepth / total, 1.0);
+        const depthEfficiency = Math.max(rawDepthEfficiency, FLOOR);
+        const confidenceStability = this.computeConfidenceStability(confidences);
+        const rawConfidenceStability = this.computeRawConfidenceStability(confidences);
+        const components = {
+            type_diversity: typeDiversity,
+            verification_coverage: verificationCoverage,
+            depth_efficiency: depthEfficiency,
+            confidence_stability: confidenceStability
+        };
+        const rawComponents = {
+            type_diversity: rawTypeDiversity,
+            verification_coverage: rawVerificationCoverage,
+            depth_efficiency: rawDepthEfficiency,
+            confidence_stability: rawConfidenceStability
+        };
+        let score;
+        if (null !== confidenceStability) {
+            const w = SignalComputer.QUALITY_WEIGHTS;
+            score = Math.pow(typeDiversity, w.typeDiversity) * Math.pow(verificationCoverage, w.verificationCoverage) * Math.pow(depthEfficiency, w.depthEfficiency) * Math.pow(confidenceStability, w.confidenceStability);
+        } else {
+            const w3 = SignalComputer.QUALITY_WEIGHTS_NO_CS;
+            score = Math.pow(typeDiversity, w3.typeDiversity) * Math.pow(verificationCoverage, w3.verificationCoverage) * Math.pow(depthEfficiency, w3.depthEfficiency);
+        }
+        return {
+            score,
+            components,
+            raw_components: rawComponents
+        };
+    }
+    computeConfidenceStability(confidences) {
+        if (0 === confidences.length) return 0.5;
+        if (1 === confidences.length) return null;
+        const mean = confidences.reduce((a, b)=>a + b, 0) / confidences.length;
+        const variance = confidences.reduce((sum, c)=>sum + (c - mean) ** 2, 0) / confidences.length;
+        const stddev = Math.sqrt(variance);
+        return Math.max(1 - stddev, FLOOR);
+    }
+    computeRawConfidenceStability(confidences) {
+        if (0 === confidences.length) return 0.5;
+        if (1 === confidences.length) return null;
+        const mean = confidences.reduce((a, b)=>a + b, 0) / confidences.length;
+        const variance = confidences.reduce((sum, c)=>sum + (c - mean) ** 2, 0) / confidences.length;
+        const stddev = Math.sqrt(variance);
+        return 1 - stddev;
+    }
+}
+export { SignalComputer };
+
+//# sourceMappingURL=SignalComputer.js.map

package/dist/core/evaluator/SignalComputer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"core/evaluator/SignalComputer.js","sources":["../../../src/core/evaluator/SignalComputer.ts"],"sourcesContent":["/**\n * Confidence signal computation for sequential thinking.\n *\n * Provides {@link SignalComputer} — a pure stateless service that computes\n * {@link ConfidenceSignals} (including the composite `structural_quality`\n * score and its components) from thought history and branch data.\n *\n * Extracted from `ThoughtEvaluator` as part of the evaluator decomposition.\n * All methods are pure: no side effects, no I/O, no internal state.\n *\n * @module core/evaluator/SignalComputer\n */\n\nimport type { ConfidenceSignals, ThoughtType } from '../reasoning.js';\nimport type { ThoughtData } from '../thought.js';\nimport { ALL_THOUGHT_TYPES, _computeChainDepth, _countByType } from './internals.js';\n\n/** Floor value applied to each quality component to prevent geometric mean collapse. */\nconst FLOOR = 0.01;\n\n/**\n * Round a numeric value to a fixed number of decimal places to mitigate\n * IEEE 754 floating-point accumulation errors (e.g. 0.9 + 0.8 averaging to\n * 0.8500000000000001 instead of 0.85).\n */\nfunction roundToPrecision(value: number, decimals: number = 10): number {\n\tconst factor = Math.pow(10, decimals);\n\treturn Math.round(value * factor) / factor;\n}\n\n/** Result of {@link SignalComputer.computeStructuralQuality}. */\ninterface StructuralQualityResult {\n\tscore: number;\n\tcomponents: {\n\t\ttype_diversity: number;\n\t\tverification_coverage: number;\n\t\tdepth_efficiency: number;\n\t\tconfidence_stability: number | null;\n\t};\n\traw_components: {\n\t\ttype_diversity: number;\n\t\tverification_coverage: number;\n\t\tdepth_efficiency: number;\n\t\tconfidence_stability: number | null;\n\t};\n}\n\n/**\n * Stateless service that computes {@link ConfidenceSignals} from thought history.\n *\n * @remarks\n * Pure computation — no side effects, no I/O, no internal state.\n * Safe to register as singleton or transient in DI.\n */\nexport class SignalComputer {\n\t/**\n\t * Structural quality weight configuration.\n\t *\n\t * Weights reflect the relative importance of each quality dimension:\n\t * - type_diversity (0.3): Shannon entropy of thought types — rewards reasoning that uses\n\t *   multiple cognitive modes (hypothesis, verification, critique, synthesis) rather than\n\t *   monotonic sequences. Based on information theory: higher entropy = more information.\n\t *\n\t * - verification_coverage (0.3): Ratio of verified to total hypotheses — rewards scientific\n\t *   rigor. Hypotheses without verification are speculation; verification grounds reasoning.\n\t *   Equal weight with diversity because unverified reasoning is a common failure mode.\n\t *\n\t * - depth_efficiency (0.2): Ratio of structural depth to total thoughts — rewards efficient\n\t *   reasoning. Deep chains (many revisions/branches) are good; but only if proportionally\n\t *   dense. Padding with low-value thoughts penalizes this metric.\n\t *\n\t * - confidence_stability (0.2): Low variance in self-assessed confidence — rewards calibrated\n\t *   reasoning. Wildly fluctuating confidence suggests uncertainty about the approach.\n\t *   Lower weight because confidence values are LLM self-reports (inherently noisy).\n\t *\n\t * Design rationale:\n\t * - Diversity + Verification (0.6) > Depth + Stability (0.4): Structural properties of the\n\t *   reasoning DAG are more important than behavioral signals.\n\t * - All weights are positive (no dimension is penalizing).\n\t * - Weights sum to 1.0 for normalized scoring.\n\t * - When confidence_stability is unavailable (n<2), remaining weights redistribute\n\t *   proportionally: td→0.375, vc→0.375, de→0.25 (preserving relative ratios).\n\t */\n\tprivate static readonly QUALITY_WEIGHTS = {\n\t\ttypeDiversity: 0.3,\n\t\tverificationCoverage: 0.3,\n\t\tdepthEfficiency: 0.2,\n\t\tconfidenceStability: 0.2,\n\t} as const;\n\n\t/**\n\t * Redistributed weights when confidence_stability is excluded (n<2).\n\t * Preserves relative ratios of remaining components (sum = 1.0).\n\t */\n\tprivate static readonly QUALITY_WEIGHTS_NO_CS = {\n\t\ttypeDiversity: 0.375,\n\t\tverificationCoverage: 0.375,\n\t\tdepthEfficiency: 0.25,\n\t} as const;\n\n\t/**\n\t * Compute confidence signals from history context.\n\t *\n\t * @param history - All thoughts in the current session\n\t * @param branches - Map of branch IDs to their thought arrays\n\t * @returns Computed confidence signals reflecting reasoning quality\n\t */\n\tpublic computeConfidenceSignals(\n\t\thistory: ThoughtData[],\n\t\tbranches: Record<string, ThoughtData[]>\n\t): ConfidenceSignals {\n\t\tconst typeDistribution = _countByType(history);\n\t\tconst allConfidences = history\n\t\t\t.map((t) => t.confidence)\n\t\t\t.filter((c): c is number => c !== undefined);\n\n\t\t// Compute structural quality components\n\t\tconst structuralResult = this.computeStructuralQuality(\n\t\t\thistory,\n\t\t\tbranches,\n\t\t\ttypeDistribution,\n\t\t\tallConfidences\n\t\t);\n\n\t\treturn {\n\t\t\treasoning_depth: history.length,\n\t\t\trevision_count: history.filter((t) => t.is_revision).length,\n\t\t\tbranch_count: Object.keys(branches).length,\n\t\t\tthought_type_distribution: typeDistribution,\n\t\t\thas_hypothesis: history.some((t) => t.thought_type === 'hypothesis'),\n\t\t\thas_verification: history.some((t) => t.thought_type === 'verification'),\n\t\t\taverage_confidence:\n\t\t\t\tallConfidences.length > 0\n\t\t\t\t\t? roundToPrecision(allConfidences.reduce((a, b) => a + b, 0) / allConfidences.length)\n\t\t\t\t\t: null,\n\t\t\t...(structuralResult !== null && {\n\t\t\t\tstructural_quality: structuralResult.score,\n\t\t\t\tquality_components: structuralResult.components,\n\t\t\t\tquality_components_raw: structuralResult.raw_components,\n\t\t\t}),\n\t\t};\n\t}\n\n\t/**\n\t * Compute the composite structural quality score and its components.\n\t *\n\t * Algorithm (all components floored at {@link FLOOR} = 0.01):\n\t * - `type_diversity` = Shannon entropy of thought_type distribution / log2(6)\n\t * - `verification_coverage` = verified_hypotheses / max(total_hypotheses, 1) (1.0 if none)\n\t * - `depth_efficiency` = max(chain_depth, branch_count + 1) / total_thoughts, clamped to 1.0\n\t * - `confidence_stability` = 1 - stddev(confidences), default 0.5 when empty, null when single value\n\t * - `structural_quality` = td^0.3 * vc^0.3 * de^0.2 * cs^0.2 (weighted geometric mean)\n\t *\n\t * Note: When confidence_stability is null (fewer than 2 confidence values), it is\n\t * excluded from the geometric mean and the remaining weights are redistributed\n\t * proportionally (td→0.375, vc→0.375, de→0.25).\n\t *\n\t * @returns Score + components, or `null` when history is empty\n\t */\n\tpublic computeStructuralQuality(\n\t\thistory: ThoughtData[],\n\t\tbranches: Record<string, ThoughtData[]>,\n\t\ttypeDistribution: Record<ThoughtType, number>,\n\t\tconfidences: number[]\n\t): StructuralQualityResult | null {\n\t\tif (history.length === 0) return null;\n\n\t\t// 1. type_diversity: Shannon entropy / log2(6)\n\t\tconst total = history.length;\n\t\tlet entropy = 0;\n\t\tfor (const type of ALL_THOUGHT_TYPES) {\n\t\t\tconst count = typeDistribution[type];\n\t\t\tif (count > 0) {\n\t\t\t\tconst pk = count / total;\n\t\t\t\tentropy -= pk * Math.log2(pk);\n\t\t\t}\n\t\t}\n\t\tconst rawTypeDiversity = entropy / Math.log2(6);\n\t\tconst typeDiversity = Math.max(rawTypeDiversity, FLOOR);\n\n\t\t// 2. verification_coverage: verified / total hypotheses (1.0 if none)\n\t\tconst hypotheses = history.filter((t) => t.thought_type === 'hypothesis');\n\t\tconst hypothesisIds = new Set(hypotheses.map((t) => t.hypothesis_id).filter(Boolean));\n\t\tconst verifiedIds = new Set(\n\t\t\thistory\n\t\t\t\t.filter((t) => t.thought_type === 'verification' && t.hypothesis_id)\n\t\t\t\t.map((t) => t.hypothesis_id)\n\t\t);\n\t\tconst rawVerificationCoverage =\n\t\t\thypothesisIds.size === 0\n\t\t\t\t? 1.0\n\t\t\t\t: [...hypothesisIds].filter((id) => verifiedIds.has(id)).length / hypothesisIds.size;\n\t\tconst verificationCoverage = Math.max(rawVerificationCoverage, FLOOR);\n\n\t\t// 3. depth_efficiency: max(chain_depth, branch_count + 1) / total_thoughts, clamped to 1.0\n\t\t// NOTE (Metis H3): Branching is desirable — treat branches as depth-equivalent.\n\t\tconst chainDepth = _computeChainDepth(history);\n\t\tconst branchCount = Object.keys(branches).length;\n\t\tconst effectiveDepth = Math.max(chainDepth, branchCount + 1);\n\t\tconst rawDepthEfficiency = Math.min(effectiveDepth / total, 1.0);\n\t\tconst depthEfficiency = Math.max(rawDepthEfficiency, FLOOR);\n\n\t\t// 4. confidence_stability: 1 - stddev(confidences), default 0.5\n\t\tconst confidenceStability = this.computeConfidenceStability(confidences);\n\t\tconst rawConfidenceStability = this.computeRawConfidenceStability(confidences);\n\n\t\tconst components: StructuralQualityResult['components'] = {\n\t\t\ttype_diversity: typeDiversity,\n\t\t\tverification_coverage: verificationCoverage,\n\t\t\tdepth_efficiency: depthEfficiency,\n\t\t\tconfidence_stability: confidenceStability,\n\t\t};\n\n\t\tconst rawComponents: StructuralQualityResult['raw_components'] = {\n\t\t\ttype_diversity: rawTypeDiversity,\n\t\t\tverification_coverage: rawVerificationCoverage,\n\t\t\tdepth_efficiency: rawDepthEfficiency,\n\t\t\tconfidence_stability: rawConfidenceStability,\n\t\t};\n\n\t\t// Weighted geometric mean: td^0.3 * vc^0.3 * de^0.2 * cs^0.2\n\t\t// When confidence_stability is null (n<2), exclude it from the geomean\n\t\t// and redistribute its weight proportionally to remaining components\n\t\t// (normalized td=0.375, vc=0.375, de=0.25)\n\t\tlet score: number;\n\t\tif (confidenceStability !== null) {\n\t\t\tconst w = SignalComputer.QUALITY_WEIGHTS;\n\t\t\tscore =\n\t\t\t\tMath.pow(typeDiversity, w.typeDiversity) *\n\t\t\t\tMath.pow(verificationCoverage, w.verificationCoverage) *\n\t\t\t\tMath.pow(depthEfficiency, w.depthEfficiency) *\n\t\t\t\tMath.pow(confidenceStability, w.confidenceStability);\n\t\t} else {\n\t\t\tconst w3 = SignalComputer.QUALITY_WEIGHTS_NO_CS;\n\t\t\tscore =\n\t\t\t\tMath.pow(typeDiversity, w3.typeDiversity) *\n\t\t\t\tMath.pow(verificationCoverage, w3.verificationCoverage) *\n\t\t\t\tMath.pow(depthEfficiency, w3.depthEfficiency);\n\t\t}\n\n\t\treturn { score, components, raw_components: rawComponents };\n\t}\n\n\t/**\n\t * Compute confidence stability: 1 - stddev(confidences).\n\t *\n\t * - Empty input → 0.5 (neutral default)\n\t * - Single value → null (insufficient data, excluded from structural quality)\n\t * - Otherwise → max(1 - stddev, FLOOR)\n\t */\n\tpublic computeConfidenceStability(confidences: number[]): number | null {\n\t\tif (confidences.length === 0) return 0.5;\n\t\tif (confidences.length === 1) return null;\n\n\t\tconst mean = confidences.reduce((a, b) => a + b, 0) / confidences.length;\n\t\tconst variance = confidences.reduce((sum, c) => sum + (c - mean) ** 2, 0) / confidences.length;\n\t\tconst stddev = Math.sqrt(variance);\n\t\treturn Math.max(1 - stddev, FLOOR);\n\t}\n\n\t/**\n\t * Compute raw (unfloored) confidence stability: 1 - stddev(confidences).\n\t *\n\t * - Empty input → 0.5 (neutral default)\n\t * - Single value → null (insufficient data)\n\t * - Otherwise → 1 - stddev (may be below FLOOR)\n\t */\n\tpublic computeRawConfidenceStability(confidences: number[]): number | null {\n\t\tif (confidences.length === 0) return 0.5;\n\t\tif (confidences.length === 1) return null;\n\n\t\tconst mean = confidences.reduce((a, b) => a + b, 0) / confidences.length;\n\t\tconst variance = confidences.reduce((sum, c) => sum + (c - mean) ** 2, 0) / confidences.length;\n\t\tconst stddev = Math.sqrt(variance);\n\t\treturn 1 - stddev;\n\t}\n}\n"],"names":["FLOOR","roundToPrecision","value","decimals","factor","Math","SignalComputer","history","branches","typeDistribution","_countByType","allConfidences","t","c","undefined","structuralResult","Object","a","b","confidences","total","entropy","type","ALL_THOUGHT_TYPES","count","pk","rawTypeDiversity","typeDiversity","hypotheses","hypothesisIds","Set","Boolean","verifiedIds","rawVerificationCoverage","id","verificationCoverage","chainDepth","_computeChainDepth","branchCount","effectiveDepth","rawDepthEfficiency","depthEfficiency","confidenceStability","rawConfidenceStability","components","rawComponents","score","w","w3","mean","variance","sum","stddev"],"mappings":";AAkBA,MAAMA,QAAQ;AAOd,SAASC,iBAAiBC,KAAa,EAAEC,WAAmB,EAAE;IAC7D,MAAMC,SAASC,KAAK,GAAG,CAAC,IAAIF;IAC5B,OAAOE,KAAK,KAAK,CAACH,QAAQE,UAAUA;AACrC;AA0BO,MAAME;IA6BZ,OAAwB,kBAAkB;QACzC,eAAe;QACf,sBAAsB;QACtB,iBAAiB;QACjB,qBAAqB;IACtB,EAAW;IAMX,OAAwB,wBAAwB;QAC/C,eAAe;QACf,sBAAsB;QACtB,iBAAiB;IAClB,EAAW;IASJ,yBACNC,OAAsB,EACtBC,QAAuC,EACnB;QACpB,MAAMC,mBAAmBC,aAAaH;QACtC,MAAMI,iBAAiBJ,QACrB,GAAG,CAAC,CAACK,IAAMA,EAAE,UAAU,EACvB,MAAM,CAAC,CAACC,IAAmBA,AAAMC,WAAND;QAG7B,MAAME,mBAAmB,IAAI,CAAC,wBAAwB,CACrDR,SACAC,UACAC,kBACAE;QAGD,OAAO;YACN,iBAAiBJ,QAAQ,MAAM;YAC/B,gBAAgBA,QAAQ,MAAM,CAAC,CAACK,IAAMA,EAAE,WAAW,EAAE,MAAM;YAC3D,cAAcI,OAAO,IAAI,CAACR,UAAU,MAAM;YAC1C,2BAA2BC;YAC3B,gBAAgBF,QAAQ,IAAI,CAAC,CAACK,IAAMA,AAAmB,iBAAnBA,EAAE,YAAY;YAClD,kBAAkBL,QAAQ,IAAI,CAAC,CAACK,IAAMA,AAAmB,mBAAnBA,EAAE,YAAY;YACpD,oBACCD,eAAe,MAAM,GAAG,IACrBV,iBAAiBU,eAAe,MAAM,CAAC,CAACM,GAAGC,IAAMD,IAAIC,GAAG,KAAKP,eAAe,MAAM,IAClF;YACJ,GAAII,AAAqB,SAArBA,oBAA6B;gBAChC,oBAAoBA,iBAAiB,KAAK;gBAC1C,oBAAoBA,iBAAiB,UAAU;gBAC/C,wBAAwBA,iBAAiB,cAAc;YACxD,CAAC;QACF;IACD;IAkBO,yBACNR,OAAsB,EACtBC,QAAuC,EACvCC,gBAA6C,EAC7CU,WAAqB,EACY;QACjC,IAAIZ,AAAmB,MAAnBA,QAAQ,MAAM,EAAQ,OAAO;QAGjC,MAAMa,QAAQb,QAAQ,MAAM;QAC5B,IAAIc,UAAU;QACd,KAAK,MAAMC,QAAQC,kBAAmB;YACrC,MAAMC,QAAQf,gBAAgB,CAACa,KAAK;YACpC,IAAIE,QAAQ,GAAG;gBACd,MAAMC,KAAKD,QAAQJ;gBACnBC,WAAWI,KAAKpB,KAAK,IAAI,CAACoB;YAC3B;QACD;QACA,MAAMC,mBAAmBL,UAAUhB,KAAK,IAAI,CAAC;QAC7C,MAAMsB,gBAAgBtB,KAAK,GAAG,CAACqB,kBAAkB1B;QAGjD,MAAM4B,aAAarB,QAAQ,MAAM,CAAC,CAACK,IAAMA,AAAmB,iBAAnBA,EAAE,YAAY;QACvD,MAAMiB,gBAAgB,IAAIC,IAAIF,WAAW,GAAG,CAAC,CAAChB,IAAMA,EAAE,aAAa,EAAE,MAAM,CAACmB;QAC5E,MAAMC,cAAc,IAAIF,IACvBvB,QACE,MAAM,CAAC,CAACK,IAAMA,AAAmB,mBAAnBA,EAAE,YAAY,IAAuBA,EAAE,aAAa,EAClE,GAAG,CAAC,CAACA,IAAMA,EAAE,aAAa;QAE7B,MAAMqB,0BACLJ,AAAuB,MAAvBA,cAAc,IAAI,GACf,MACA;eAAIA;SAAc,CAAC,MAAM,CAAC,CAACK,KAAOF,YAAY,GAAG,CAACE,KAAK,MAAM,GAAGL,cAAc,IAAI;QACtF,MAAMM,uBAAuB9B,KAAK,GAAG,CAAC4B,yBAAyBjC;QAI/D,MAAMoC,aAAaC,mBAAmB9B;QACtC,MAAM+B,cAActB,OAAO,IAAI,CAACR,UAAU,MAAM;QAChD,MAAM+B,iBAAiBlC,KAAK,GAAG,CAAC+B,YAAYE,cAAc;QAC1D,MAAME,qBAAqBnC,KAAK,GAAG,CAACkC,iBAAiBnB,OAAO;QAC5D,MAAMqB,kBAAkBpC,KAAK,GAAG,CAACmC,oBAAoBxC;QAGrD,MAAM0C,sBAAsB,IAAI,CAAC,0BAA0B,CAACvB;QAC5D,MAAMwB,yBAAyB,IAAI,CAAC,6BAA6B,CAACxB;QAElE,MAAMyB,aAAoD;YACzD,gBAAgBjB;YAChB,uBAAuBQ;YACvB,kBAAkBM;YAClB,sBAAsBC;QACvB;QAEA,MAAMG,gBAA2D;YAChE,gBAAgBnB;YAChB,uBAAuBO;YACvB,kBAAkBO;YAClB,sBAAsBG;QACvB;QAMA,IAAIG;QACJ,IAAIJ,AAAwB,SAAxBA,qBAA8B;YACjC,MAAMK,IAAIzC,eAAe,eAAe;YACxCwC,QACCzC,KAAK,GAAG,CAACsB,eAAeoB,EAAE,aAAa,IACvC1C,KAAK,GAAG,CAAC8B,sBAAsBY,EAAE,oBAAoB,IACrD1C,KAAK,GAAG,CAACoC,iBAAiBM,EAAE,eAAe,IAC3C1C,KAAK,GAAG,CAACqC,qBAAqBK,EAAE,mBAAmB;QACrD,OAAO;YACN,MAAMC,KAAK1C,eAAe,qBAAqB;YAC/CwC,QACCzC,KAAK,GAAG,CAACsB,eAAeqB,GAAG,aAAa,IACxC3C,KAAK,GAAG,CAAC8B,sBAAsBa,GAAG,oBAAoB,IACtD3C,KAAK,GAAG,CAACoC,iBAAiBO,GAAG,eAAe;QAC9C;QAEA,OAAO;YAAEF;YAAOF;YAAY,gBAAgBC;QAAc;IAC3D;IASO,2BAA2B1B,WAAqB,EAAiB;QACvE,IAAIA,AAAuB,MAAvBA,YAAY,MAAM,EAAQ,OAAO;QACrC,IAAIA,AAAuB,MAAvBA,YAAY,MAAM,EAAQ,OAAO;QAErC,MAAM8B,OAAO9B,YAAY,MAAM,CAAC,CAACF,GAAGC,IAAMD,IAAIC,GAAG,KAAKC,YAAY,MAAM;QACxE,MAAM+B,WAAW/B,YAAY,MAAM,CAAC,CAACgC,KAAKtC,IAAMsC,MAAOtC,AAAAA,CAAAA,IAAIoC,IAAG,KAAM,GAAG,KAAK9B,YAAY,MAAM;QAC9F,MAAMiC,SAAS/C,KAAK,IAAI,CAAC6C;QACzB,OAAO7C,KAAK,GAAG,CAAC,IAAI+C,QAAQpD;IAC7B;IASO,8BAA8BmB,WAAqB,EAAiB;QAC1E,IAAIA,AAAuB,MAAvBA,YAAY,MAAM,EAAQ,OAAO;QACrC,IAAIA,AAAuB,MAAvBA,YAAY,MAAM,EAAQ,OAAO;QAErC,MAAM8B,OAAO9B,YAAY,MAAM,CAAC,CAACF,GAAGC,IAAMD,IAAIC,GAAG,KAAKC,YAAY,MAAM;QACxE,MAAM+B,WAAW/B,YAAY,MAAM,CAAC,CAACgC,KAAKtC,IAAMsC,MAAOtC,AAAAA,CAAAA,IAAIoC,IAAG,KAAM,GAAG,KAAK9B,YAAY,MAAM;QAC9F,MAAMiC,SAAS/C,KAAK,IAAI,CAAC6C;QACzB,OAAO,IAAIE;IACZ;AACD"}

package/dist/core/evaluator/calibration-math.d.ts

@@ -0,0 +1,39 @@
+import type { VerificationOutcome } from '../../contracts/interfaces.js';
+/** Candidate temperatures evaluated during grid search refit. */
+export declare const TEMPERATURE_GRID: readonly number[];
+/** Minimum outcomes required before temperature scaling is applied. */
+export declare const MIN_OUTCOMES_FOR_TEMPERATURE = 10;
+/** Small epsilon to keep log() finite when probabilities approach 0 or 1. */
+export declare const EPSILON = 1e-9;
+/**
+ * Apply temperature scaling to a probability `p`.
+ *
+ * Uses the standard logit re-scaling:
+ * `sigmoid(logit(p) / T)`. T=1 is the identity.
+ *
+ * @param p - Probability in `[0, 1]`.
+ * @param temperature - Temperature scalar (must be > 0).
+ * @returns Scaled probability in `[0, 1]`.
+ */
+export declare function applyTemperature(p: number, temperature: number): number;
+/**
+ * Compute negative log-likelihood for a candidate temperature.
+ *
+ * @param outcomes - Outcomes whose `predicted` is the raw confidence and
+ *                   `actual` is the observed 0/1 label.
+ * @param temperature - Temperature to evaluate.
+ * @returns Mean NLL across outcomes (lower is better). Returns `Infinity` if
+ *          `outcomes` is empty.
+ */
+export declare function negativeLogLikelihood(outcomes: readonly VerificationOutcome[], temperature: number): number;
+/**
+ * Grid-search the temperature minimizing NLL.
+ *
+ * Falls back to T=1.0 when there are fewer than {@link MIN_OUTCOMES_FOR_TEMPERATURE}
+ * outcomes available.
+ *
+ * @param outcomes - Outcomes to fit against.
+ * @returns Best temperature from {@link TEMPERATURE_GRID}.
+ */
+export declare function fitTemperature(outcomes: readonly VerificationOutcome[]): number;
+//# sourceMappingURL=calibration-math.d.ts.map

package/dist/core/evaluator/calibration-math.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"calibration-math.d.ts","sourceRoot":"","sources":["../../../src/core/evaluator/calibration-math.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,+BAA+B,CAAC;AAEzE,iEAAiE;AACjE,eAAO,MAAM,gBAAgB,EAAE,SAAS,MAAM,EAAqC,CAAC;AAEpF,uEAAuE;AACvE,eAAO,MAAM,4BAA4B,KAAK,CAAC;AAE/C,6EAA6E;AAC7E,eAAO,MAAM,OAAO,OAAO,CAAC;AAE5B;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,CAKvE;AAED;;;;;;;;GAQG;AACH,wBAAgB,qBAAqB,CACpC,QAAQ,EAAE,SAAS,mBAAmB,EAAE,EACxC,WAAW,EAAE,MAAM,GACjB,MAAM,CASR;AAED;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,SAAS,mBAAmB,EAAE,GAAG,MAAM,CAY/E"}

package/dist/core/evaluator/calibration-math.js

@@ -0,0 +1,42 @@
+const TEMPERATURE_GRID = [
+    0.5,
+    0.75,
+    1.0,
+    1.25,
+    1.5,
+    2.0
+];
+const MIN_OUTCOMES_FOR_TEMPERATURE = 10;
+const EPSILON = 1e-9;
+function applyTemperature(p, temperature) {
+    const clamped = Math.min(1 - EPSILON, Math.max(EPSILON, p));
+    const logit = Math.log(clamped / (1 - clamped));
+    const scaled = logit / temperature;
+    return 1 / (1 + Math.exp(-scaled));
+}
+function negativeLogLikelihood(outcomes, temperature) {
+    if (0 === outcomes.length) return 1 / 0;
+    let total = 0;
+    for (const o of outcomes){
+        const p = applyTemperature(o.predicted, temperature);
+        const clamped = Math.min(1 - EPSILON, Math.max(EPSILON, p));
+        total += -(o.actual * Math.log(clamped) + (1 - o.actual) * Math.log(1 - clamped));
+    }
+    return total / outcomes.length;
+}
+function fitTemperature(outcomes) {
+    if (outcomes.length < MIN_OUTCOMES_FOR_TEMPERATURE) return 1.0;
+    let best = 1.0;
+    let bestLoss = 1 / 0;
+    for (const t of TEMPERATURE_GRID){
+        const loss = negativeLogLikelihood(outcomes, t);
+        if (loss < bestLoss) {
+            bestLoss = loss;
+            best = t;
+        }
+    }
+    return best;
+}
+export { EPSILON, MIN_OUTCOMES_FOR_TEMPERATURE, TEMPERATURE_GRID, applyTemperature, fitTemperature, negativeLogLikelihood };
+
+//# sourceMappingURL=calibration-math.js.map

package/dist/core/evaluator/calibration-math.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"core/evaluator/calibration-math.js","sources":["../../../src/core/evaluator/calibration-math.ts"],"sourcesContent":["import type { VerificationOutcome } from '../../contracts/interfaces.js';\n\n/** Candidate temperatures evaluated during grid search refit. */\nexport const TEMPERATURE_GRID: readonly number[] = [0.5, 0.75, 1.0, 1.25, 1.5, 2.0];\n\n/** Minimum outcomes required before temperature scaling is applied. */\nexport const MIN_OUTCOMES_FOR_TEMPERATURE = 10;\n\n/** Small epsilon to keep log() finite when probabilities approach 0 or 1. */\nexport const EPSILON = 1e-9;\n\n/**\n * Apply temperature scaling to a probability `p`.\n *\n * Uses the standard logit re-scaling:\n * `sigmoid(logit(p) / T)`. T=1 is the identity.\n *\n * @param p - Probability in `[0, 1]`.\n * @param temperature - Temperature scalar (must be > 0).\n * @returns Scaled probability in `[0, 1]`.\n */\nexport function applyTemperature(p: number, temperature: number): number {\n\tconst clamped = Math.min(1 - EPSILON, Math.max(EPSILON, p));\n\tconst logit = Math.log(clamped / (1 - clamped));\n\tconst scaled = logit / temperature;\n\treturn 1 / (1 + Math.exp(-scaled));\n}\n\n/**\n * Compute negative log-likelihood for a candidate temperature.\n *\n * @param outcomes - Outcomes whose `predicted` is the raw confidence and\n *                   `actual` is the observed 0/1 label.\n * @param temperature - Temperature to evaluate.\n * @returns Mean NLL across outcomes (lower is better). Returns `Infinity` if\n *          `outcomes` is empty.\n */\nexport function negativeLogLikelihood(\n\toutcomes: readonly VerificationOutcome[],\n\ttemperature: number,\n): number {\n\tif (outcomes.length === 0) return Number.POSITIVE_INFINITY;\n\tlet total = 0;\n\tfor (const o of outcomes) {\n\t\tconst p = applyTemperature(o.predicted, temperature);\n\t\tconst clamped = Math.min(1 - EPSILON, Math.max(EPSILON, p));\n\t\ttotal += -(o.actual * Math.log(clamped) + (1 - o.actual) * Math.log(1 - clamped));\n\t}\n\treturn total / outcomes.length;\n}\n\n/**\n * Grid-search the temperature minimizing NLL.\n *\n * Falls back to T=1.0 when there are fewer than {@link MIN_OUTCOMES_FOR_TEMPERATURE}\n * outcomes available.\n *\n * @param outcomes - Outcomes to fit against.\n * @returns Best temperature from {@link TEMPERATURE_GRID}.\n */\nexport function fitTemperature(outcomes: readonly VerificationOutcome[]): number {\n\tif (outcomes.length < MIN_OUTCOMES_FOR_TEMPERATURE) return 1.0;\n\tlet best = 1.0;\n\tlet bestLoss = Number.POSITIVE_INFINITY;\n\tfor (const t of TEMPERATURE_GRID) {\n\t\tconst loss = negativeLogLikelihood(outcomes, t);\n\t\tif (loss < bestLoss) {\n\t\t\tbestLoss = loss;\n\t\t\tbest = t;\n\t\t}\n\t}\n\treturn best;\n}\n"],"names":["TEMPERATURE_GRID","MIN_OUTCOMES_FOR_TEMPERATURE","EPSILON","applyTemperature","p","temperature","clamped","Math","logit","scaled","negativeLogLikelihood","outcomes","Number","total","o","fitTemperature","best","bestLoss","t","loss"],"mappings":"AAGO,MAAMA,mBAAsC;IAAC;IAAK;IAAM;IAAK;IAAM;IAAK;CAAI;AAG5E,MAAMC,+BAA+B;AAGrC,MAAMC,UAAU;AAYhB,SAASC,iBAAiBC,CAAS,EAAEC,WAAmB;IAC9D,MAAMC,UAAUC,KAAK,GAAG,CAAC,IAAIL,SAASK,KAAK,GAAG,CAACL,SAASE;IACxD,MAAMI,QAAQD,KAAK,GAAG,CAACD,UAAW,KAAIA,OAAM;IAC5C,MAAMG,SAASD,QAAQH;IACvB,OAAO,IAAK,KAAIE,KAAK,GAAG,CAAC,CAACE,OAAM;AACjC;AAWO,SAASC,sBACfC,QAAwC,EACxCN,WAAmB;IAEnB,IAAIM,AAAoB,MAApBA,SAAS,MAAM,EAAQ,OAAOC,KAAwB;IAC1D,IAAIC,QAAQ;IACZ,KAAK,MAAMC,KAAKH,SAAU;QACzB,MAAMP,IAAID,iBAAiBW,EAAE,SAAS,EAAET;QACxC,MAAMC,UAAUC,KAAK,GAAG,CAAC,IAAIL,SAASK,KAAK,GAAG,CAACL,SAASE;QACxDS,SAAS,CAAEC,CAAAA,EAAE,MAAM,GAAGP,KAAK,GAAG,CAACD,WAAY,KAAIQ,EAAE,MAAK,IAAKP,KAAK,GAAG,CAAC,IAAID,QAAO;IAChF;IACA,OAAOO,QAAQF,SAAS,MAAM;AAC/B;AAWO,SAASI,eAAeJ,QAAwC;IACtE,IAAIA,SAAS,MAAM,GAAGV,8BAA8B,OAAO;IAC3D,IAAIe,OAAO;IACX,IAAIC,WAAWL,KAAwB;IACvC,KAAK,MAAMM,KAAKlB,iBAAkB;QACjC,MAAMmB,OAAOT,sBAAsBC,UAAUO;QAC7C,IAAIC,OAAOF,UAAU;YACpBA,WAAWE;YACXH,OAAOE;QACR;IACD;IACA,OAAOF;AACR"}

package/dist/core/evaluator/internals.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Shared internal helpers for evaluator submodules.
+ *
+ * Pure utility functions used by SignalComputer (and future evaluator
+ * components such as StatsComputer / PatternDetector). All helpers are
+ * stateless and have no side effects.
+ *
+ * @module core/evaluator/internals
+ */
+import type { ThoughtType } from '../reasoning.js';
+import type { ThoughtData } from '../thought.js';
+/** All valid thought types for distribution counting. */
+export declare const ALL_THOUGHT_TYPES: ThoughtType[];
+/**
+ * Count thoughts in `history` grouped by {@link ThoughtType}.
+ *
+ * Thoughts without an explicit `thought_type` are counted as `'regular'`.
+ *
+ * @param history - Thoughts to count
+ * @returns Record mapping each ThoughtType to its occurrence count
+ */
+export declare function _countByType(history: ThoughtData[]): Record<ThoughtType, number>;
+/** Alias of {@link _countByType} without the underscore prefix. */
+export declare const countByType: typeof _countByType;
+/**
+ * Compute the longest contiguous chain depth (sequence of thoughts without branching).
+ *
+ * A new chain starts whenever a thought has `branch_from_thought` set.
+ *
+ * @param history - Thoughts in chronological order
+ * @returns Length of the longest non-branching chain (0 for empty history)
+ */
+export declare function _computeChainDepth(history: ThoughtData[]): number;
+/** Alias of {@link _computeChainDepth} without the underscore prefix. */
+export declare const computeChainDepth: typeof _computeChainDepth;
+//# sourceMappingURL=internals.d.ts.map

package/dist/core/evaluator/internals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"internals.d.ts","sourceRoot":"","sources":["../../../src/core/evaluator/internals.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AACnD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAEjD,yDAAyD;AACzD,eAAO,MAAM,iBAAiB,EAAE,WAAW,EAY1C,CAAC;AAEF;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,WAAW,EAAE,GAAG,MAAM,CAAC,WAAW,EAAE,MAAM,CAAC,CAchF;AAED,mEAAmE;AACnE,eAAO,MAAM,WAAW,qBAAe,CAAC;AAExC;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,WAAW,EAAE,GAAG,MAAM,CAgBjE;AAED,yEAAyE;AACzE,eAAO,MAAM,iBAAiB,2BAAqB,CAAC"}