@iworkforces/tracelattice 2.0.3

package/dist/core/reasoning/strategies/StrategyFactory.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Strategy factory — maps a {@link FeatureFlags.reasoningStrategy} value to
+ * a concrete {@link IReasoningStrategy} instance.
+ *
+ * Today {@link SequentialStrategy} and {@link TreeOfThoughtStrategy} are
+ * implemented and are the only valid strategy values.
+ *
+ * @module core/reasoning/strategies/StrategyFactory
+ */
+import type { IReasoningStrategy } from '../../../contracts/strategy.js';
+import type { FeatureFlags } from '../../../contracts/features.js';
+/**
+ * Build a reasoning strategy by name.
+ *
+ * @param name - Strategy identifier from {@link FeatureFlags.reasoningStrategy}.
+ * @returns A concrete {@link IReasoningStrategy} instance.
+ *
+ * @example
+ * ```ts
+ * const strategy = createReasoningStrategy(config.features.reasoningStrategy);
+ * const decision = strategy.decide(ctx);
+ * ```
+ */
+export declare function createReasoningStrategy(name: FeatureFlags['reasoningStrategy']): IReasoningStrategy;
+//# sourceMappingURL=StrategyFactory.d.ts.map

package/dist/core/reasoning/strategies/StrategyFactory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StrategyFactory.d.ts","sourceRoot":"","sources":["../../../../src/core/reasoning/strategies/StrategyFactory.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AACzE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gCAAgC,CAAC;AAKnE;;;;;;;;;;;GAWG;AACH,wBAAgB,uBAAuB,CACtC,IAAI,EAAE,YAAY,CAAC,mBAAmB,CAAC,GACrC,kBAAkB,CASpB"}

package/dist/core/reasoning/strategies/StrategyFactory.js

@@ -0,0 +1,16 @@
+import { SequentialStrategy } from "./SequentialStrategy.js";
+import { TreeOfThoughtStrategy } from "./TreeOfThoughtStrategy.js";
+import { assertNever } from "../../../utils.js";
+function createReasoningStrategy(name) {
+    switch(name){
+        case 'sequential':
+            return new SequentialStrategy();
+        case 'tot':
+            return new TreeOfThoughtStrategy();
+        default:
+            return assertNever(name);
+    }
+}
+export { createReasoningStrategy };
+
+//# sourceMappingURL=StrategyFactory.js.map

package/dist/core/reasoning/strategies/StrategyFactory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"core/reasoning/strategies/StrategyFactory.js","sources":["../../../../src/core/reasoning/strategies/StrategyFactory.ts"],"sourcesContent":["/**\n * Strategy factory — maps a {@link FeatureFlags.reasoningStrategy} value to\n * a concrete {@link IReasoningStrategy} instance.\n *\n * Today {@link SequentialStrategy} and {@link TreeOfThoughtStrategy} are\n * implemented and are the only valid strategy values.\n *\n * @module core/reasoning/strategies/StrategyFactory\n */\n\nimport type { IReasoningStrategy } from '../../../contracts/strategy.js';\nimport type { FeatureFlags } from '../../../contracts/features.js';\nimport { SequentialStrategy } from './SequentialStrategy.js';\nimport { TreeOfThoughtStrategy } from './TreeOfThoughtStrategy.js';\nimport { assertNever } from '../../../utils.js';\n\n/**\n * Build a reasoning strategy by name.\n *\n * @param name - Strategy identifier from {@link FeatureFlags.reasoningStrategy}.\n * @returns A concrete {@link IReasoningStrategy} instance.\n *\n * @example\n * ```ts\n * const strategy = createReasoningStrategy(config.features.reasoningStrategy);\n * const decision = strategy.decide(ctx);\n * ```\n */\nexport function createReasoningStrategy(\n\tname: FeatureFlags['reasoningStrategy'],\n): IReasoningStrategy {\n\tswitch (name) {\n\t\tcase 'sequential':\n\t\t\treturn new SequentialStrategy();\n\t\tcase 'tot':\n\t\t\treturn new TreeOfThoughtStrategy();\n\t\tdefault:\n\t\t\treturn assertNever(name);\n\t}\n}\n"],"names":["createReasoningStrategy","name","SequentialStrategy","TreeOfThoughtStrategy","assertNever"],"mappings":";;;AA4BO,SAASA,wBACfC,IAAuC;IAEvC,OAAQA;QACP,KAAK;YACJ,OAAO,IAAIC;QACZ,KAAK;YACJ,OAAO,IAAIC;QACZ;YACC,OAAOC,YAAYH;IACrB;AACD"}

package/dist/core/reasoning/strategies/TreeOfThoughtStrategy.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Tree-of-Thought reasoning strategy — beam search over the thought DAG.
+ *
+ * Observes the frontier (graph leaves), scores each leaf via
+ * {@link scoreThought}, and decides whether to continue, branch (when the
+ * current thought falls outside the beam), or terminate (on confidence
+ * threshold or score plateau).
+ *
+ * Pure policy: configuration lives in a module-level {@link WeakMap}, not
+ * on the instance, so `Object.getOwnPropertyNames(strategy)` only ever
+ * surfaces the readonly `name` discriminator. All other state is derived
+ * from the {@link StrategyContext} on every call.
+ *
+ * @module core/reasoning/strategies/TreeOfThoughtStrategy
+ */
+import type { IReasoningStrategy, StrategyContext, StrategyDecision } from '../../../contracts/strategy.js';
+/**
+ * Configuration knobs for {@link TreeOfThoughtStrategy}. All fields are
+ * optional; defaults are applied in the constructor.
+ */
+export interface TotConfig {
+    /** Top-K candidates kept on the frontier (default `3`). */
+    readonly beamWidth?: number;
+    /** Maximum exploration depth before forcing termination (default `8`). */
+    readonly depthCap?: number;
+    /** Score at/above which the chain terminates (default `0.85`). */
+    readonly terminationConfidence?: number;
+    /** Window size for plateau detection (default `3`). */
+    readonly plateauWindow?: number;
+    /** Minimum meaningful score change for plateau detection (default `0.02`). */
+    readonly plateauEpsilon?: number;
+}
+/**
+ * Tree-of-Thought strategy: beam search over the thought DAG. Pure policy.
+ *
+ * @example
+ * ```typescript
+ * const strategy = new TreeOfThoughtStrategy({ beamWidth: 4 });
+ * const decision = strategy.decide(ctx);
+ * ```
+ */
+export declare class TreeOfThoughtStrategy implements IReasoningStrategy {
+    readonly name: "tot";
+    /** @param config - See {@link TotConfig}. */
+    constructor(config?: TotConfig);
+    /**
+     * Compute the next action for the chain.
+     *
+     * Order of checks: termination by confidence → termination by plateau →
+     * branch when the current thought is outside the beam → continue.
+     */
+    decide(ctx: StrategyContext): StrategyDecision;
+    /** True when the frontier is wider than the beam (diverse exploration). */
+    shouldBranch(ctx: StrategyContext): boolean;
+    /** True when the best frontier score crosses the threshold OR scores plateau. */
+    shouldTerminate(ctx: StrategyContext): boolean;
+}
+//# sourceMappingURL=TreeOfThoughtStrategy.d.ts.map

package/dist/core/reasoning/strategies/TreeOfThoughtStrategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TreeOfThoughtStrategy.d.ts","sourceRoot":"","sources":["../../../../src/core/reasoning/strategies/TreeOfThoughtStrategy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EACX,kBAAkB,EAClB,eAAe,EACf,gBAAgB,EAChB,MAAM,gCAAgC,CAAC;AAKxC;;;GAGG;AACH,MAAM,WAAW,SAAS;IACzB,2DAA2D;IAC3D,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,0EAA0E;IAC1E,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,kEAAkE;IAClE,QAAQ,CAAC,qBAAqB,CAAC,EAAE,MAAM,CAAC;IACxC,uDAAuD;IACvD,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC,8EAA8E;IAC9E,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;CACjC;AAgED;;;;;;;;GAQG;AACH,qBAAa,qBAAsB,YAAW,kBAAkB;IAC/D,QAAQ,CAAC,IAAI,EAAG,KAAK,CAAU;IAE/B,6CAA6C;gBACjC,MAAM,CAAC,EAAE,SAAS;IAI9B;;;;;OAKG;IACH,MAAM,CAAC,GAAG,EAAE,eAAe,GAAG,gBAAgB;IAiC9C,2EAA2E;IAC3E,YAAY,CAAC,GAAG,EAAE,eAAe,GAAG,OAAO;IAO3C,iFAAiF;IACjF,eAAe,CAAC,GAAG,EAAE,eAAe,GAAG,OAAO;CAY9C"}

package/dist/core/reasoning/strategies/TreeOfThoughtStrategy.js

@@ -0,0 +1,103 @@
+import { scoreThought, selectBeam } from "./totScoring.js";
+import { detectPlateau } from "./plateau.js";
+const DEFAULTS = {
+    beamWidth: 3,
+    depthCap: 8,
+    terminationConfidence: 0.85,
+    plateauWindow: 3,
+    plateauEpsilon: 0.02
+};
+const CONFIGS = new WeakMap();
+function configOf(s) {
+    return CONFIGS.get(s) ?? DEFAULTS;
+}
+function thoughtKey(t) {
+    return t.id ?? String(t.thought_number);
+}
+function indexHistory(history) {
+    const out = new Map();
+    for (const t of history)out.set(thoughtKey(t), t);
+    return out;
+}
+function scoreFrontier(frontier, byKey) {
+    const out = [];
+    for (const id of frontier){
+        const t = byKey.get(id);
+        if (void 0 !== t) out.push({
+            id,
+            score: scoreThought(t)
+        });
+    }
+    return out;
+}
+function bestScore(scored) {
+    let best = -1 / 0;
+    for (const c of scored)if (c.score > best) best = c.score;
+    return best;
+}
+function recentScores(history, window) {
+    const start = history.length > window ? history.length - window : 0;
+    const out = [];
+    for(let i = start; i < history.length; i++)out.push(scoreThought(history[i]));
+    return out;
+}
+class TreeOfThoughtStrategy {
+    name = 'tot';
+    constructor(config){
+        CONFIGS.set(this, {
+            ...DEFAULTS,
+            ...config ?? {}
+        });
+    }
+    decide(ctx) {
+        const cfg = configOf(this);
+        if (!ctx.graph) return {
+            action: 'continue'
+        };
+        const frontier = ctx.graph.leaves(ctx.sessionId);
+        const byKey = indexHistory(ctx.history);
+        const scored = scoreFrontier(frontier, byKey);
+        if (scored.length > 0 && bestScore(scored) >= cfg.terminationConfidence) return {
+            action: 'terminate',
+            reason: 'confidence threshold'
+        };
+        const recent = recentScores(ctx.history, cfg.plateauWindow);
+        if (detectPlateau(recent, cfg.plateauWindow, cfg.plateauEpsilon)) return {
+            action: 'terminate',
+            reason: 'plateau'
+        };
+        if (scored.length > cfg.beamWidth) {
+            const beam = selectBeam(scored, cfg.beamWidth);
+            const currentKey = thoughtKey(ctx.currentThought);
+            if (!beam.includes(currentKey)) return {
+                action: 'branch',
+                branchId: `tot-${ctx.currentThought.thought_number}`,
+                fromThought: ctx.currentThought.thought_number,
+                reason: 'outside beam'
+            };
+        }
+        return {
+            action: 'continue',
+            nextHint: 'explore frontier'
+        };
+    }
+    shouldBranch(ctx) {
+        const cfg = configOf(this);
+        if (!ctx.graph) return false;
+        const frontier = ctx.graph.leaves(ctx.sessionId);
+        return frontier.length > cfg.beamWidth;
+    }
+    shouldTerminate(ctx) {
+        const cfg = configOf(this);
+        if (!ctx.graph) return false;
+        const frontier = ctx.graph.leaves(ctx.sessionId);
+        const byKey = indexHistory(ctx.history);
+        const scored = scoreFrontier(frontier, byKey);
+        if (scored.length > 0 && bestScore(scored) >= cfg.terminationConfidence) return true;
+        const recent = recentScores(ctx.history, cfg.plateauWindow);
+        return detectPlateau(recent, cfg.plateauWindow, cfg.plateauEpsilon);
+    }
+}
+export { TreeOfThoughtStrategy };
+
+//# sourceMappingURL=TreeOfThoughtStrategy.js.map

package/dist/core/reasoning/strategies/TreeOfThoughtStrategy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"core/reasoning/strategies/TreeOfThoughtStrategy.js","sources":["../../../../src/core/reasoning/strategies/TreeOfThoughtStrategy.ts"],"sourcesContent":["/**\n * Tree-of-Thought reasoning strategy — beam search over the thought DAG.\n *\n * Observes the frontier (graph leaves), scores each leaf via\n * {@link scoreThought}, and decides whether to continue, branch (when the\n * current thought falls outside the beam), or terminate (on confidence\n * threshold or score plateau).\n *\n * Pure policy: configuration lives in a module-level {@link WeakMap}, not\n * on the instance, so `Object.getOwnPropertyNames(strategy)` only ever\n * surfaces the readonly `name` discriminator. All other state is derived\n * from the {@link StrategyContext} on every call.\n *\n * @module core/reasoning/strategies/TreeOfThoughtStrategy\n */\n\nimport type {\n\tIReasoningStrategy,\n\tStrategyContext,\n\tStrategyDecision,\n} from '../../../contracts/strategy.js';\nimport type { ThoughtData } from '../../thought.js';\nimport { scoreThought, selectBeam, type ScoredCandidate } from './totScoring.js';\nimport { detectPlateau } from './plateau.js';\n\n/**\n * Configuration knobs for {@link TreeOfThoughtStrategy}. All fields are\n * optional; defaults are applied in the constructor.\n */\nexport interface TotConfig {\n\t/** Top-K candidates kept on the frontier (default `3`). */\n\treadonly beamWidth?: number;\n\t/** Maximum exploration depth before forcing termination (default `8`). */\n\treadonly depthCap?: number;\n\t/** Score at/above which the chain terminates (default `0.85`). */\n\treadonly terminationConfidence?: number;\n\t/** Window size for plateau detection (default `3`). */\n\treadonly plateauWindow?: number;\n\t/** Minimum meaningful score change for plateau detection (default `0.02`). */\n\treadonly plateauEpsilon?: number;\n}\n\n/** Defaults applied when a {@link TotConfig} field is omitted. */\nconst DEFAULTS: Required<TotConfig> = {\n\tbeamWidth: 3,\n\tdepthCap: 8,\n\tterminationConfidence: 0.85,\n\tplateauWindow: 3,\n\tplateauEpsilon: 0.02,\n};\n\n/**\n * Module-private config storage. Keyed by strategy instance so that no\n * own-properties leak onto `this` (preserving the purity contract).\n */\nconst CONFIGS: WeakMap<TreeOfThoughtStrategy, Required<TotConfig>> = new WeakMap();\n\n/** Resolve the per-instance config (constructor always populates the map). */\nfunction configOf(s: TreeOfThoughtStrategy): Required<TotConfig> {\n\treturn CONFIGS.get(s) ?? DEFAULTS;\n}\n\n/** Stable identifier for a thought: `id` if present, else its sequence number. */\nfunction thoughtKey(t: ThoughtData): string {\n\treturn t.id ?? String(t.thought_number);\n}\n\n/** Index history by stable key for O(1) leaf-id → ThoughtData lookup. */\nfunction indexHistory(history: readonly ThoughtData[]): Map<string, ThoughtData> {\n\tconst out = new Map<string, ThoughtData>();\n\tfor (const t of history) out.set(thoughtKey(t), t);\n\treturn out;\n}\n\n/** Score the frontier (graph leaves), skipping ids absent from history. */\nfunction scoreFrontier(\n\tfrontier: readonly string[],\n\tbyKey: Map<string, ThoughtData>\n): ScoredCandidate[] {\n\tconst out: ScoredCandidate[] = [];\n\tfor (const id of frontier) {\n\t\tconst t = byKey.get(id);\n\t\tif (t !== undefined) out.push({ id, score: scoreThought(t) });\n\t}\n\treturn out;\n}\n\n/** Highest score in a candidate set, or `-Infinity` when empty. */\nfunction bestScore(scored: readonly ScoredCandidate[]): number {\n\tlet best = Number.NEGATIVE_INFINITY;\n\tfor (const c of scored) {\n\t\tif (c.score > best) best = c.score;\n\t}\n\treturn best;\n}\n\n/** Recent per-thought scores, used for plateau detection. */\nfunction recentScores(history: readonly ThoughtData[], window: number): number[] {\n\tconst start = history.length > window ? history.length - window : 0;\n\tconst out: number[] = [];\n\tfor (let i = start; i < history.length; i++) out.push(scoreThought(history[i]!));\n\treturn out;\n}\n\n/**\n * Tree-of-Thought strategy: beam search over the thought DAG. Pure policy.\n *\n * @example\n * ```typescript\n * const strategy = new TreeOfThoughtStrategy({ beamWidth: 4 });\n * const decision = strategy.decide(ctx);\n * ```\n */\nexport class TreeOfThoughtStrategy implements IReasoningStrategy {\n\treadonly name = 'tot' as const;\n\n\t/** @param config - See {@link TotConfig}. */\n\tconstructor(config?: TotConfig) {\n\t\tCONFIGS.set(this, { ...DEFAULTS, ...(config ?? {}) });\n\t}\n\n\t/**\n\t * Compute the next action for the chain.\n\t *\n\t * Order of checks: termination by confidence → termination by plateau →\n\t * branch when the current thought is outside the beam → continue.\n\t */\n\tdecide(ctx: StrategyContext): StrategyDecision {\n\t\tconst cfg = configOf(this);\n\t\tif (!ctx.graph) {\n\t\t\treturn { action: 'continue' };\n\t\t}\n\t\tconst frontier = ctx.graph.leaves(ctx.sessionId);\n\t\tconst byKey = indexHistory(ctx.history);\n\t\tconst scored = scoreFrontier(frontier, byKey);\n\t\tif (scored.length > 0 && bestScore(scored) >= cfg.terminationConfidence) {\n\t\t\treturn { action: 'terminate', reason: 'confidence threshold' };\n\t\t}\n\n\t\tconst recent = recentScores(ctx.history, cfg.plateauWindow);\n\t\tif (detectPlateau(recent, cfg.plateauWindow, cfg.plateauEpsilon)) {\n\t\t\treturn { action: 'terminate', reason: 'plateau' };\n\t\t}\n\n\t\tif (scored.length > cfg.beamWidth) {\n\t\t\tconst beam = selectBeam(scored, cfg.beamWidth);\n\t\t\tconst currentKey = thoughtKey(ctx.currentThought);\n\t\t\tif (!beam.includes(currentKey)) {\n\t\t\t\treturn {\n\t\t\t\t\taction: 'branch',\n\t\t\t\t\tbranchId: `tot-${ctx.currentThought.thought_number}`,\n\t\t\t\t\tfromThought: ctx.currentThought.thought_number,\n\t\t\t\t\treason: 'outside beam',\n\t\t\t\t};\n\t\t\t}\n\t\t}\n\n\t\treturn { action: 'continue', nextHint: 'explore frontier' };\n\t}\n\n\t/** True when the frontier is wider than the beam (diverse exploration). */\n\tshouldBranch(ctx: StrategyContext): boolean {\n\t\tconst cfg = configOf(this);\n\t\tif (!ctx.graph) return false;\n\t\tconst frontier = ctx.graph.leaves(ctx.sessionId);\n\t\treturn frontier.length > cfg.beamWidth;\n\t}\n\n\t/** True when the best frontier score crosses the threshold OR scores plateau. */\n\tshouldTerminate(ctx: StrategyContext): boolean {\n\t\tconst cfg = configOf(this);\n\t\tif (!ctx.graph) return false;\n\t\tconst frontier = ctx.graph.leaves(ctx.sessionId);\n\t\tconst byKey = indexHistory(ctx.history);\n\t\tconst scored = scoreFrontier(frontier, byKey);\n\t\tif (scored.length > 0 && bestScore(scored) >= cfg.terminationConfidence) {\n\t\t\treturn true;\n\t\t}\n\t\tconst recent = recentScores(ctx.history, cfg.plateauWindow);\n\t\treturn detectPlateau(recent, cfg.plateauWindow, cfg.plateauEpsilon);\n\t}\n}\n"],"names":["DEFAULTS","CONFIGS","WeakMap","configOf","s","thoughtKey","t","String","indexHistory","history","out","Map","scoreFrontier","frontier","byKey","id","undefined","scoreThought","bestScore","scored","best","Number","c","recentScores","window","start","i","TreeOfThoughtStrategy","config","ctx","cfg","recent","detectPlateau","beam","selectBeam","currentKey"],"mappings":"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"}

package/dist/core/reasoning/strategies/plateau.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Detect if scores have plateaued (no meaningful improvement).
+ *
+ * A plateau is detected when the recent `window` scores show:
+ * 1. Low variance (range < epsilon)
+ * 2. No upward trend (last - first <= epsilon)
+ *
+ * @param scores - Array of sequential confidence/quality scores
+ * @param window - Number of recent scores to examine (default 3)
+ * @param epsilon - Minimum meaningful change threshold (default 0.02)
+ * @returns true if the last `window` scores show no upward trend
+ *
+ * @example
+ * detectPlateau([0.5, 0.5, 0.5]); // true
+ * detectPlateau([0.1, 0.5, 0.9]); // false (upward trend)
+ */
+export declare function detectPlateau(scores: readonly number[], window?: number, epsilon?: number): boolean;
+//# sourceMappingURL=plateau.d.ts.map

package/dist/core/reasoning/strategies/plateau.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plateau.d.ts","sourceRoot":"","sources":["../../../../src/core/reasoning/strategies/plateau.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,aAAa,CAC5B,MAAM,EAAE,SAAS,MAAM,EAAE,EACzB,MAAM,GAAE,MAAU,EAClB,OAAO,GAAE,MAAa,GACpB,OAAO,CAYT"}

package/dist/core/reasoning/strategies/plateau.js

@@ -0,0 +1,12 @@
+function detectPlateau(scores, window = 3, epsilon = 0.02) {
+    if (scores.length < window) return false;
+    const recent = scores.slice(-window);
+    const min = Math.min(...recent);
+    const max = Math.max(...recent);
+    const range = max - min;
+    const hasUpwardTrend = recent[recent.length - 1] - recent[0] > epsilon;
+    return range < epsilon && !hasUpwardTrend;
+}
+export { detectPlateau };
+
+//# sourceMappingURL=plateau.js.map

package/dist/core/reasoning/strategies/plateau.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"core/reasoning/strategies/plateau.js","sources":["../../../../src/core/reasoning/strategies/plateau.ts"],"sourcesContent":["/**\n * Detect if scores have plateaued (no meaningful improvement).\n *\n * A plateau is detected when the recent `window` scores show:\n * 1. Low variance (range < epsilon)\n * 2. No upward trend (last - first <= epsilon)\n *\n * @param scores - Array of sequential confidence/quality scores\n * @param window - Number of recent scores to examine (default 3)\n * @param epsilon - Minimum meaningful change threshold (default 0.02)\n * @returns true if the last `window` scores show no upward trend\n *\n * @example\n * detectPlateau([0.5, 0.5, 0.5]); // true\n * detectPlateau([0.1, 0.5, 0.9]); // false (upward trend)\n */\nexport function detectPlateau(\n\tscores: readonly number[],\n\twindow: number = 3,\n\tepsilon: number = 0.02,\n): boolean {\n\tif (scores.length < window) return false;\n\n\tconst recent = scores.slice(-window);\n\n\tconst min = Math.min(...recent);\n\tconst max = Math.max(...recent);\n\tconst range = max - min;\n\n\tconst hasUpwardTrend = recent[recent.length - 1]! - recent[0]! > epsilon;\n\n\treturn range < epsilon && !hasUpwardTrend;\n}\n"],"names":["detectPlateau","scores","window","epsilon","recent","min","Math","max","range","hasUpwardTrend"],"mappings":"AAgBO,SAASA,cACfC,MAAyB,EACzBC,SAAiB,CAAC,EAClBC,UAAkB,IAAI;IAEtB,IAAIF,OAAO,MAAM,GAAGC,QAAQ,OAAO;IAEnC,MAAME,SAASH,OAAO,KAAK,CAAC,CAACC;IAE7B,MAAMG,MAAMC,KAAK,GAAG,IAAIF;IACxB,MAAMG,MAAMD,KAAK,GAAG,IAAIF;IACxB,MAAMI,QAAQD,MAAMF;IAEpB,MAAMI,iBAAiBL,MAAM,CAACA,OAAO,MAAM,GAAG,EAAE,GAAIA,MAAM,CAAC,EAAE,GAAID;IAEjE,OAAOK,QAAQL,WAAW,CAACM;AAC5B"}

package/dist/core/reasoning/strategies/totScoring.d.ts

@@ -0,0 +1,91 @@
+/**
+ * Tree-of-Thought scoring helpers — pure functions for ranking and frontier
+ * exploration over the thought DAG.
+ *
+ * This module exposes three primitives used by the ToT strategy:
+ *
+ * - {@link scoreThought}: combine confidence and quality into a [0, 1] score.
+ * - {@link selectBeam}: pick the top-K candidates with deterministic tiebreaks.
+ * - {@link breadthFirstFrontier}: BFS from roots, returning leaves of the
+ *   explored subgraph capped by depth.
+ *
+ * All functions are pure: no I/O, no mutable module state, no DI.
+ *
+ * @module core/reasoning/strategies/totScoring
+ */
+import type { ThoughtData } from '../../thought.js';
+import type { GraphView } from '../../graph/GraphView.js';
+import type { SessionId } from '../../../contracts/ids.js';
+/**
+ * A scored candidate suitable for {@link selectBeam}.
+ */
+export interface ScoredCandidate {
+    readonly id: string;
+    readonly score: number;
+}
+/**
+ * Score a thought by combining its (calibrated) confidence with its
+ * self-assessed quality, then applying a per-type weight.
+ *
+ * Formula: `(calibrated_confidence ?? confidence ?? 0) * (quality_score ?? 0.5) * typeWeight(thought_type)`
+ *
+ * The `calibrated_confidence` (when present on `confidence_signals`) is
+ * preferred over the raw `confidence` field. The result is clamped to the
+ * inclusive range `[0, 1]`.
+ *
+ * @param t - The thought to score.
+ * @returns A score in `[0, 1]`.
+ *
+ * @example
+ * ```typescript
+ * const s = scoreThought({ ...base, confidence: 0.8, quality_score: 0.5 });
+ * // s === 0.4
+ * ```
+ */
+export declare function scoreThought(t: ThoughtData): number;
+/**
+ * Select the top-`width` candidates by score, descending.
+ *
+ * Sorting is stable and deterministic: ties on `score` are broken by
+ * lexicographic comparison of `id` (ascending). When `width >= candidates.length`
+ * all candidates are returned in sorted order. When `width <= 0` the result
+ * is empty.
+ *
+ * @param candidates - Scored candidates (input is not mutated).
+ * @param width - Beam width (top-K).
+ * @returns Selected ids in descending score order.
+ *
+ * @example
+ * ```typescript
+ * const top = selectBeam([{ id: 'a', score: 0.1 }, { id: 'b', score: 0.9 }], 1);
+ * // top === ['b']
+ * ```
+ */
+export declare function selectBeam(candidates: readonly ScoredCandidate[], width: number): readonly string[];
+/**
+ * Compute the BFS frontier reachable from `roots` within `depthCap` levels.
+ *
+ * Traverses outgoing edges via `graph.descendants(sessionId, id, 1)`. The returned
+ * set contains the *leaves* of the explored subgraph — nodes that either
+ * (a) sit at the depth cap, or (b) have no outgoing edges within the
+ * explored region.
+ *
+ * Special cases:
+ * - `depthCap === 0` returns the unique roots in input order.
+ * - empty `roots` returns an empty array.
+ *
+ * Each node is visited at most once, so cycles cannot cause infinite loops.
+ *
+ * @param graph - Read-only graph view.
+ * @param sessionId - Session scoping the traversal.
+ * @param roots - Starting thought ids.
+ * @param depthCap - Maximum BFS depth (0 = roots only).
+ * @returns Frontier (leaf) thought ids of the explored subgraph.
+ *
+ * @example
+ * ```typescript
+ * const frontier = breadthFirstFrontier(view, 's1', ['root'], 2);
+ * ```
+ */
+export declare function breadthFirstFrontier(graph: GraphView, sessionId: SessionId, roots: readonly string[], depthCap: number): readonly string[];
+//# sourceMappingURL=totScoring.d.ts.map

package/dist/core/reasoning/strategies/totScoring.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"totScoring.d.ts","sourceRoot":"","sources":["../../../../src/core/reasoning/strategies/totScoring.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAEpD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AAC1D,OAAO,KAAK,EAAE,SAAS,EAAa,MAAM,2BAA2B,CAAC;AAYtE;;GAEG;AACH,MAAM,WAAW,eAAe;IAC/B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACvB;AAuCD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,WAAW,GAAG,MAAM,CAQnD;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,UAAU,CACzB,UAAU,EAAE,SAAS,eAAe,EAAE,EACtC,KAAK,EAAE,MAAM,GACX,SAAS,MAAM,EAAE,CAcnB;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,oBAAoB,CACnC,KAAK,EAAE,SAAS,EAChB,SAAS,EAAE,SAAS,EACpB,KAAK,EAAE,SAAS,MAAM,EAAE,EACxB,QAAQ,EAAE,MAAM,GACd,SAAS,MAAM,EAAE,CAqDnB"}

package/dist/core/reasoning/strategies/totScoring.js

@@ -0,0 +1,88 @@
+import { assertNever } from "../../../utils.js";
+function getTypeWeight(type) {
+    if (void 0 === type) return 1.0;
+    switch(type){
+        case 'assumption':
+            return 0.5;
+        case 'decomposition':
+            return 1.2;
+        case 'backtrack':
+            return 0.8;
+        case 'tool_call':
+            return 1.0;
+        case 'tool_observation':
+            return 1.0;
+        case 'regular':
+        case 'hypothesis':
+        case 'verification':
+        case 'critique':
+        case 'synthesis':
+        case 'meta':
+            return 1.0;
+        default:
+            return assertNever(type);
+    }
+}
+function scoreThought(t) {
+    const calibrated = t.confidence_signals?.calibrated_confidence;
+    const confidence = calibrated ?? t.confidence ?? 0;
+    const quality = t.quality_score ?? 0.5;
+    const raw = confidence * quality * getTypeWeight(t.thought_type);
+    if (raw < 0) return 0;
+    if (raw > 1) return 1;
+    return raw;
+}
+function selectBeam(candidates, width) {
+    if (width <= 0 || 0 === candidates.length) return [];
+    const sorted = [
+        ...candidates
+    ].sort((a, b)=>{
+        if (b.score !== a.score) return b.score - a.score;
+        return a.id < b.id ? -1 : 1;
+    });
+    const k = width >= sorted.length ? sorted.length : width;
+    const result = [];
+    for(let i = 0; i < k; i++)result.push(sorted[i].id);
+    return result;
+}
+function breadthFirstFrontier(graph, sessionId, roots, depthCap) {
+    if (0 === roots.length) return [];
+    const uniqueRoots = [];
+    const seenRoots = new Set();
+    for (const r of roots)if (!seenRoots.has(r)) {
+        seenRoots.add(r);
+        uniqueRoots.push(r);
+    }
+    if (depthCap <= 0) return uniqueRoots;
+    const visited = new Set(uniqueRoots);
+    let frontier = [
+        ...uniqueRoots
+    ];
+    let depth = 0;
+    while(frontier.length > 0 && depth < depthCap){
+        const next = [];
+        for (const node of frontier)for (const child of graph.descendants(sessionId, node, 1))if (!visited.has(child)) {
+            visited.add(child);
+            next.push(child);
+        }
+        frontier = next;
+        depth++;
+    }
+    const explored = visited;
+    const leaves = [];
+    const seenLeaf = new Set();
+    const collect = (id)=>{
+        seenLeaf.add(id);
+        leaves.push(id);
+    };
+    if (depth >= depthCap && frontier.length > 0) for (const id of frontier)collect(id);
+    for (const id of explored){
+        if (seenLeaf.has(id)) continue;
+        const children = graph.descendants(sessionId, id, 1);
+        if (0 === children.length) collect(id);
+    }
+    return leaves;
+}
+export { breadthFirstFrontier, scoreThought, selectBeam };
+
+//# sourceMappingURL=totScoring.js.map

package/dist/core/reasoning/strategies/totScoring.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"core/reasoning/strategies/totScoring.js","sources":["../../../../src/core/reasoning/strategies/totScoring.ts"],"sourcesContent":["/**\n * Tree-of-Thought scoring helpers — pure functions for ranking and frontier\n * exploration over the thought DAG.\n *\n * This module exposes three primitives used by the ToT strategy:\n *\n * - {@link scoreThought}: combine confidence and quality into a [0, 1] score.\n * - {@link selectBeam}: pick the top-K candidates with deterministic tiebreaks.\n * - {@link breadthFirstFrontier}: BFS from roots, returning leaves of the\n *   explored subgraph capped by depth.\n *\n * All functions are pure: no I/O, no mutable module state, no DI.\n *\n * @module core/reasoning/strategies/totScoring\n */\n\nimport type { ThoughtData } from '../../thought.js';\nimport type { ConfidenceSignals, ThoughtType } from '../../reasoning.js';\nimport type { GraphView } from '../../graph/GraphView.js';\nimport type { SessionId, ThoughtId } from '../../../contracts/ids.js';\nimport { assertNever } from '../../../utils.js';\n\n/**\n * Optional `confidence_signals` carried alongside a thought. The core\n * `ThoughtData` type does not declare this field, but evaluator output may\n * be attached by callers that want calibrated scoring.\n */\ntype ThoughtWithSignals = ThoughtData & {\n\treadonly confidence_signals?: ConfidenceSignals;\n};\n\n/**\n * A scored candidate suitable for {@link selectBeam}.\n */\nexport interface ScoredCandidate {\n\treadonly id: string;\n\treadonly score: number;\n}\n\n/**\n * Per-type score multiplier applied on top of the base confidence×quality score.\n *\n * Weights bias the ToT frontier towards productive thought kinds:\n * - `assumption` (0.5): low confidence until backed by verification.\n * - `decomposition` (1.2): encouraged for problem-splitting.\n * - `backtrack` (0.8): signals exploration but not preferred.\n * - `tool_call` / `tool_observation` (1.0): neutral exogenous information.\n * - All other types (regular, hypothesis, verification, critique, synthesis, meta): 1.0.\n *\n * Pure function: deterministic, no I/O.\n */\nfunction getTypeWeight(type: ThoughtType | undefined): number {\n\tif (type === undefined) return 1.0;\n\tswitch (type) {\n\t\tcase 'assumption':\n\t\t\treturn 0.5;\n\t\tcase 'decomposition':\n\t\t\treturn 1.2;\n\t\tcase 'backtrack':\n\t\t\treturn 0.8;\n\t\tcase 'tool_call':\n\t\t\treturn 1.0;\n\t\tcase 'tool_observation':\n\t\t\treturn 1.0;\n\t\tcase 'regular':\n\t\tcase 'hypothesis':\n\t\tcase 'verification':\n\t\tcase 'critique':\n\t\tcase 'synthesis':\n\t\tcase 'meta':\n\t\t\treturn 1.0;\n\t\tdefault:\n\t\t\treturn assertNever(type);\n\t}\n}\n\n/**\n * Score a thought by combining its (calibrated) confidence with its\n * self-assessed quality, then applying a per-type weight.\n *\n * Formula: `(calibrated_confidence ?? confidence ?? 0) * (quality_score ?? 0.5) * typeWeight(thought_type)`\n *\n * The `calibrated_confidence` (when present on `confidence_signals`) is\n * preferred over the raw `confidence` field. The result is clamped to the\n * inclusive range `[0, 1]`.\n *\n * @param t - The thought to score.\n * @returns A score in `[0, 1]`.\n *\n * @example\n * ```typescript\n * const s = scoreThought({ ...base, confidence: 0.8, quality_score: 0.5 });\n * // s === 0.4\n * ```\n */\nexport function scoreThought(t: ThoughtData): number {\n\tconst calibrated = (t as ThoughtWithSignals).confidence_signals?.calibrated_confidence;\n\tconst confidence = calibrated ?? t.confidence ?? 0;\n\tconst quality = t.quality_score ?? 0.5;\n\tconst raw = confidence * quality * getTypeWeight(t.thought_type);\n\tif (raw < 0) return 0;\n\tif (raw > 1) return 1;\n\treturn raw;\n}\n\n/**\n * Select the top-`width` candidates by score, descending.\n *\n * Sorting is stable and deterministic: ties on `score` are broken by\n * lexicographic comparison of `id` (ascending). When `width >= candidates.length`\n * all candidates are returned in sorted order. When `width <= 0` the result\n * is empty.\n *\n * @param candidates - Scored candidates (input is not mutated).\n * @param width - Beam width (top-K).\n * @returns Selected ids in descending score order.\n *\n * @example\n * ```typescript\n * const top = selectBeam([{ id: 'a', score: 0.1 }, { id: 'b', score: 0.9 }], 1);\n * // top === ['b']\n * ```\n */\nexport function selectBeam(\n\tcandidates: readonly ScoredCandidate[],\n\twidth: number\n): readonly string[] {\n\tif (width <= 0 || candidates.length === 0) {\n\t\treturn [];\n\t}\n\tconst sorted = [...candidates].sort((a, b) => {\n\t\tif (b.score !== a.score) return b.score - a.score;\n\t\treturn a.id < b.id ? -1 : 1;\n\t});\n\tconst k = width >= sorted.length ? sorted.length : width;\n\tconst result: string[] = [];\n\tfor (let i = 0; i < k; i++) {\n\t\tresult.push(sorted[i]!.id);\n\t}\n\treturn result;\n}\n\n/**\n * Compute the BFS frontier reachable from `roots` within `depthCap` levels.\n *\n * Traverses outgoing edges via `graph.descendants(sessionId, id, 1)`. The returned\n * set contains the *leaves* of the explored subgraph — nodes that either\n * (a) sit at the depth cap, or (b) have no outgoing edges within the\n * explored region.\n *\n * Special cases:\n * - `depthCap === 0` returns the unique roots in input order.\n * - empty `roots` returns an empty array.\n *\n * Each node is visited at most once, so cycles cannot cause infinite loops.\n *\n * @param graph - Read-only graph view.\n * @param sessionId - Session scoping the traversal.\n * @param roots - Starting thought ids.\n * @param depthCap - Maximum BFS depth (0 = roots only).\n * @returns Frontier (leaf) thought ids of the explored subgraph.\n *\n * @example\n * ```typescript\n * const frontier = breadthFirstFrontier(view, 's1', ['root'], 2);\n * ```\n */\nexport function breadthFirstFrontier(\n\tgraph: GraphView,\n\tsessionId: SessionId,\n\troots: readonly string[],\n\tdepthCap: number\n): readonly string[] {\n\tif (roots.length === 0) {\n\t\treturn [];\n\t}\n\tconst uniqueRoots: string[] = [];\n\tconst seenRoots = new Set<string>();\n\tfor (const r of roots) {\n\t\tif (!seenRoots.has(r)) {\n\t\t\tseenRoots.add(r);\n\t\t\tuniqueRoots.push(r);\n\t\t}\n\t}\n\tif (depthCap <= 0) {\n\t\treturn uniqueRoots;\n\t}\n\n\tconst visited = new Set<string>(uniqueRoots);\n\tlet frontier: string[] = [...uniqueRoots];\n\tlet depth = 0;\n\n\twhile (frontier.length > 0 && depth < depthCap) {\n\t\tconst next: string[] = [];\n\t\tfor (const node of frontier) {\n\t\t\tfor (const child of graph.descendants(sessionId, node as ThoughtId, 1)) {\n\t\t\t\tif (visited.has(child)) continue;\n\t\t\t\tvisited.add(child);\n\t\t\t\tnext.push(child);\n\t\t\t}\n\t\t}\n\t\tfrontier = next;\n\t\tdepth++;\n\t}\n\n\tconst explored = visited;\n\tconst leaves: string[] = [];\n\tconst seenLeaf = new Set<string>();\n\tconst collect = (id: string): void => {\n\t\tseenLeaf.add(id);\n\t\tleaves.push(id);\n\t};\n\n\tif (depth >= depthCap && frontier.length > 0) {\n\t\t// Hit the depth cap — current frontier is leaves regardless of children.\n\t\tfor (const id of frontier) collect(id);\n\t}\n\t// Any explored node with no outgoing edges inside the explored set is also\n\t// a leaf (covers nodes shallower than depthCap that terminated naturally).\n\tfor (const id of explored) {\n\t\tif (seenLeaf.has(id)) continue;\n\t\tconst children = graph.descendants(sessionId, id as ThoughtId, 1);\n\t\tif (children.length === 0) collect(id);\n\t}\n\treturn leaves;\n}\n"],"names":["getTypeWeight","type","undefined","assertNever","scoreThought","t","calibrated","confidence","quality","raw","selectBeam","candidates","width","sorted","a","b","k","result","i","breadthFirstFrontier","graph","sessionId","roots","depthCap","uniqueRoots","seenRoots","Set","r","visited","frontier","depth","next","node","child","explored","leaves","seenLeaf","collect","id","children"],"mappings":";AAmDA,SAASA,cAAcC,IAA6B;IACnD,IAAIA,AAASC,WAATD,MAAoB,OAAO;IAC/B,OAAQA;QACP,KAAK;YACJ,OAAO;QACR,KAAK;YACJ,OAAO;QACR,KAAK;YACJ,OAAO;QACR,KAAK;YACJ,OAAO;QACR,KAAK;YACJ,OAAO;QACR,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;YACJ,OAAO;QACR;YACC,OAAOE,YAAYF;IACrB;AACD;AAqBO,SAASG,aAAaC,CAAc;IAC1C,MAAMC,aAAcD,EAAyB,kBAAkB,EAAE;IACjE,MAAME,aAAaD,cAAcD,EAAE,UAAU,IAAI;IACjD,MAAMG,UAAUH,EAAE,aAAa,IAAI;IACnC,MAAMI,MAAMF,aAAaC,UAAUR,cAAcK,EAAE,YAAY;IAC/D,IAAII,MAAM,GAAG,OAAO;IACpB,IAAIA,MAAM,GAAG,OAAO;IACpB,OAAOA;AACR;AAoBO,SAASC,WACfC,UAAsC,EACtCC,KAAa;IAEb,IAAIA,SAAS,KAAKD,AAAsB,MAAtBA,WAAW,MAAM,EAClC,OAAO,EAAE;IAEV,MAAME,SAAS;WAAIF;KAAW,CAAC,IAAI,CAAC,CAACG,GAAGC;QACvC,IAAIA,EAAE,KAAK,KAAKD,EAAE,KAAK,EAAE,OAAOC,EAAE,KAAK,GAAGD,EAAE,KAAK;QACjD,OAAOA,EAAE,EAAE,GAAGC,EAAE,EAAE,GAAG,KAAK;IAC3B;IACA,MAAMC,IAAIJ,SAASC,OAAO,MAAM,GAAGA,OAAO,MAAM,GAAGD;IACnD,MAAMK,SAAmB,EAAE;IAC3B,IAAK,IAAIC,IAAI,GAAGA,IAAIF,GAAGE,IACtBD,OAAO,IAAI,CAACJ,MAAM,CAACK,EAAE,CAAE,EAAE;IAE1B,OAAOD;AACR;AA2BO,SAASE,qBACfC,KAAgB,EAChBC,SAAoB,EACpBC,KAAwB,EACxBC,QAAgB;IAEhB,IAAID,AAAiB,MAAjBA,MAAM,MAAM,EACf,OAAO,EAAE;IAEV,MAAME,cAAwB,EAAE;IAChC,MAAMC,YAAY,IAAIC;IACtB,KAAK,MAAMC,KAAKL,MACf,IAAI,CAACG,UAAU,GAAG,CAACE,IAAI;QACtBF,UAAU,GAAG,CAACE;QACdH,YAAY,IAAI,CAACG;IAClB;IAED,IAAIJ,YAAY,GACf,OAAOC;IAGR,MAAMI,UAAU,IAAIF,IAAYF;IAChC,IAAIK,WAAqB;WAAIL;KAAY;IACzC,IAAIM,QAAQ;IAEZ,MAAOD,SAAS,MAAM,GAAG,KAAKC,QAAQP,SAAU;QAC/C,MAAMQ,OAAiB,EAAE;QACzB,KAAK,MAAMC,QAAQH,SAClB,KAAK,MAAMI,SAASb,MAAM,WAAW,CAACC,WAAWW,MAAmB,GACnE,KAAIJ,QAAQ,GAAG,CAACK;YAChBL,QAAQ,GAAG,CAACK;YACZF,KAAK,IAAI,CAACE;;QAGZJ,WAAWE;QACXD;IACD;IAEA,MAAMI,WAAWN;IACjB,MAAMO,SAAmB,EAAE;IAC3B,MAAMC,WAAW,IAAIV;IACrB,MAAMW,UAAU,CAACC;QAChBF,SAAS,GAAG,CAACE;QACbH,OAAO,IAAI,CAACG;IACb;IAEA,IAAIR,SAASP,YAAYM,SAAS,MAAM,GAAG,GAE1C,KAAK,MAAMS,MAAMT,SAAUQ,QAAQC;IAIpC,KAAK,MAAMA,MAAMJ,SAAU;QAC1B,IAAIE,SAAS,GAAG,CAACE,KAAK;QACtB,MAAMC,WAAWnB,MAAM,WAAW,CAACC,WAAWiB,IAAiB;QAC/D,IAAIC,AAAoB,MAApBA,SAAS,MAAM,EAAQF,QAAQC;IACpC;IACA,OAAOH;AACR"}