open-multi-agent-kit 0.90.4 → 0.90.6

package/dist/core/reasoning-router-weights.d.ts

@@ -1,155 +0,0 @@
-/**
- * Reasoning-router v2 — frozen types, feature vector, weight schema, the
- * V1_COMPAT_WEIGHTS v1-exact oracle (Req 1.4), and the DEFAULT_WEIGHTS
- * calibrated production preset (Goal 004 Lane I5b).
- *
- * Pure, side-effect-free, erasable TypeScript. No runtime imports.
- *
- * ============================================================================
- * WEIGHT PRESETS — V1_COMPAT_WEIGHTS (v1 oracle) + DEFAULT_WEIGHTS (calibrated)
- * ============================================================================
- * The v1 classifier (reasoning-router.ts) is a first-match keyword cascade with
- * FIXED precedence: debug > refactor > review > plan > simple-edit > code-gen,
- * then fence/diff, then length, then lane fallback, then default code-gen.
- *
- * We reproduce that precedence as DIGIT-POSITION weights. The keyword family at
- * precedence rank r contributes exactly 10^(6-r) to ITS OWN class score when its
- * pattern matches (strongKeyword diagonal, 0/1 match indicator):
- *
- *     debug      r=1 -> 10^5 = 100000
- *     refactor   r=2 -> 10^4 = 10000
- *     review     r=3 -> 10^3 = 1000
- *     plan       r=4 -> 10^2 = 100
- *     simple-edit r=5 -> 10^1 = 10
- *     code-gen   r=6 -> 10^0 = 1
- *
- * Why this is exact for v1's keyword step: a higher-precedence family always
- * outscores the SUM of every lower-precedence family (100000 > 10000+1000+100+
- * 10+1 = 11111), so argmax over scoreClass recovers "highest-precedence match
- * wins" with no possibility of ties between matched families.
- *
- * v1 steps 2-6 (fence/diff -> code-gen; len<40 -> trivial; len>=2400 -> plan;
- * lane fallback; default code-gen) are NOT linear in the v2 feature vector
- * (v1 uses hard 40/2400 thresholds; a single lenBucket weight is monotonic and
- * cannot reproduce both). They are therefore reproduced by classifyTaskV2's
- * zero-score cascade: when no keyword and no fence/diff signal fires (every
- * scoreClass term is 0 under DEFAULT_WEIGHTS), classifyTaskV2 applies v1 steps
- * 3-6 verbatim. The fence/diff flags live on the code-gen weight row (boolean
- * weight flag AND feature -> +1) so a fence/diff-only turn still scores code-gen
- * > 0 and is selected by argmax, matching v1 step 2. trivial carries no keyword
- * weight (it is not a keyword family) and is reached only via the cascade.
- *
- * Two presets ship from this encoding (both with thresholds 0, so the
- * sticky / consult / low-margin-judge paths stay INACTIVE):
- *  - V1_COMPAT_WEIGHTS: STRONG-only diagonal, every WEAK coefficient 0. This is
- *    the frozen Req 1.4 oracle — classifyTaskV2(input, V1_COMPAT_WEIGHTS) ===
- *    classifyTask(input) bit-for-bit on the v1 corpus. Do NOT recalibrate it.
- *  - DEFAULT_WEIGHTS: the calibrated production preset. Identical STRONG
- *    diagonal PLUS a constant WEAK diagonal of 1 per keyword class, so an
- *    ambiguous WEAK token (debug "fix", refactor "simplify", review "assess" /
- *    "lgtm", code-gen "add", plan "break down") contributes a small positive
- *    signal to its own class WITHOUT dominating a stronger sibling-class signal
- *    (every STRONG weight >= 1; higher-precedence STRONG weights strictly > 1).
- *    classifyTaskV2(input, DEFAULT_WEIGHTS) is strictly better than v1 on the
- *    gold set (CWA(v2) > CWA(v1)); see laneI5b-calibration.md.
- * ============================================================================
- */
-/** Closed set of v2 task classes (same labels as v1 TaskClass). */
-export type TaskClassV2 = "trivial" | "simple-edit" | "code-gen" | "debug" | "refactor" | "review" | "plan";
-/** Subagent lane types recognized by the v2 classifier and resolver. */
-export type ReasoningLaneTypeV2 = "planner" | "security" | "explorer" | "coder" | "reviewer" | "tester";
-/** Fixed iteration order over TaskClassV2 (matches the type-declaration order). */
-export declare const TASK_CLASSES_V2: readonly TaskClassV2[];
-/**
- * Feature vector for one turn, extracted by classifyTaskV2's caller layer.
- *
- * - strongKeyword[c] / weakKeyword[c]: per-class match counts (0 when absent).
- *   For v1-compat, strongKeyword[c] is the 0/1 result of v1's pattern.test.
- * - codeFence / diffHunk: prompt-embedded code-fence / diff-marker booleans.
- * - lenBucket: floor(log2(trimmedLen + 1)) clamped to [0, 7].
- * - multiTurnPrior: most-recent historical class (N=8 ring buffer) or null.
- * - pressureBucket: context-pressure band (0..<0.5, 1..<0.75, 2..<0.9, 3..>=0.9).
- * - judgeVote: optional tier-2 LLM-judge label, or null.
- */
-export interface RouterFeatures {
-    strongKeyword: Partial<Record<TaskClassV2, number>>;
-    weakKeyword: Partial<Record<TaskClassV2, number>>;
-    codeFence: boolean;
-    diffHunk: boolean;
-    lenBucket: number;
-    multiTurnPrior: TaskClassV2 | null;
-    pressureBucket: number;
-    judgeVote: TaskClassV2 | null;
-}
-/**
- * Tunable weight surface for the v2 router.
- *
- * classWeights[c] is a RouterFeatures-shaped row of per-feature coefficients for
- * class c. stickyThreshold / consultThreshold / marginThreshold steer
- * classifyTaskV2's hysteresis, AdaptOrch consultation, and low-confidence margin
- * gate respectively. laneStep mirrors v1's resolver ladder adjustment per lane.
- */
-export interface RouterWeights {
-    classWeights: Readonly<Record<TaskClassV2, RouterFeatures>>;
-    stickyThreshold: number;
-    consultThreshold: number;
-    marginThreshold: number;
-    laneStep: Readonly<Partial<Record<ReasoningLaneTypeV2, 1 | -1>>>;
-}
-/**
- * Pure integer-arithmetic scorer. Returns S(c) = sum of weighted features for
- * class c under weights w:
- *  - keyword terms: sum over classes c2 of strong/weak weight * feature count.
- *  - boolean signal terms (codeFence, diffHunk): +1 when both the weight flag
- *    AND the feature are set (magnitude is a unit; the flag gates the class).
- *  - numeric terms (lenBucket, pressureBucket): weight * feature product.
- *  - class-equality terms (multiTurnPrior, judgeVote): +1 on exact match with a
- *    non-null feature.
- *
- * Deterministic: same (c, f, w) -> same number. No clock, randomness, or I/O.
- */
-export declare function scoreClass(c: TaskClassV2, f: RouterFeatures, w: RouterWeights): number;
-/**
- * v1-compat oracle weight preset (Goal 004 Req 1.4 regression oracle).
- *
- * STRONG-only diagonal (10^(6-r), see file header); every WEAK coefficient is 0
- * so WEAK keywords are inert. code-gen owns the codeFence/diffHunk flags so v1
- * step 2 is captured inside scoreClass. Every length / prior / pressure / judge
- * coefficient is zero (v1 has no linear length signal, no history, no
- * context-pressure input, no judge). Thresholds are 0 so classifyTaskV2 never
- * enters the sticky / consult / low-margin-judge paths.
- *
- * classifyTaskV2(input, V1_COMPAT_WEIGHTS) === classifyTask(input) bit-for-bit
- * on the v1 corpus. Kept frozen as the oracle; do NOT recalibrate this preset.
- */
-export declare const V1_COMPAT_WEIGHTS: RouterWeights;
-/**
- * Calibrated production preset (Goal 004 Lane I5b). Extends V1_COMPAT_WEIGHTS
- * with a constant WEAK-keyword diagonal of 1 per keyword class.
- *
- * Weighting invariant:
- *  - STRONG keyword in class C: 10^(6-rank(C)) (unchanged from V1_COMPAT).
- *  - WEAK keyword in class C: 1 (constant, identical across classes).
- *
- * Because every STRONG weight (min 1 for code-gen) is >= the constant WEAK
- * weight 1, and higher-precedence STRONG weights (>=10) strictly exceed it, a
- * single STRONG hit in ANY class always beats or ties a lone WEAK hit, while two
- * STRONG hits resolve by the precedence diagonal (10^(6-r)). Concrete
- * consequences on the gold set:
- *  - "fix the typo": WEAK-debug(1) + STRONG-simple-edit(10) -> simple-edit wins
- *    (the Req 1.3 regression fix; v1 wrongly routed to debug).
- *  - "fix the race condition": WEAK-debug(1) alone -> debug beats the zero
- *    default (no len>=40 cascade to code-gen; v1 was already correct here, the
- *    STRONG-only oracle had regressed it).
- *  - "simplify the nested if-else": WEAK-refactor(1) alone -> refactor.
- *  - "lgtm, just double-check the tests": WEAK-review(1) alone -> review.
- *  - "crash the typo": STRONG-debug(100000) + STRONG-simple-edit(10) -> debug
- *    (a crash-dominated prompt stays debug; precedence diagonal preserved).
- *
- * classifyTaskV2(input, DEFAULT_WEIGHTS) is STRICTLY BETTER than v1 on the gold
- * set (CWA(v2) > CWA(v1)); see .omk/goals/004-reasoning-router-v2-impl/
- * laneI5b-calibration.md. Thresholds stay 0 so hysteresis/consult/margin paths
- * remain inactive (Phase A).
- */
-export declare const DEFAULT_WEIGHTS: RouterWeights;
-//# sourceMappingURL=reasoning-router-weights.d.ts.map

package/dist/core/reasoning-router-weights.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"reasoning-router-weights.d.ts","sourceRoot":"","sources":["../../src/core/reasoning-router-weights.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AAEH,mEAAmE;AACnE,MAAM,MAAM,WAAW,GAAG,SAAS,GAAG,aAAa,GAAG,UAAU,GAAG,OAAO,GAAG,UAAU,GAAG,QAAQ,GAAG,MAAM,CAAC;AAE5G,wEAAwE;AACxE,MAAM,MAAM,mBAAmB,GAAG,SAAS,GAAG,UAAU,GAAG,UAAU,GAAG,OAAO,GAAG,UAAU,GAAG,QAAQ,CAAC;AAExG,mFAAmF;AACnF,eAAO,MAAM,eAAe,EAAE,SAAS,WAAW,EAQjD,CAAC;AAEF;;;;;;;;;;GAUG;AACH,MAAM,WAAW,cAAc;IAC9B,aAAa,EAAE,OAAO,CAAC,MAAM,CAAC,WAAW,EAAE,MAAM,CAAC,CAAC,CAAC;IACpD,WAAW,EAAE,OAAO,CAAC,MAAM,CAAC,WAAW,EAAE,MAAM,CAAC,CAAC,CAAC;IAClD,SAAS,EAAE,OAAO,CAAC;IACnB,QAAQ,EAAE,OAAO,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,EAAE,WAAW,GAAG,IAAI,CAAC;IACnC,cAAc,EAAE,MAAM,CAAC;IACvB,SAAS,EAAE,WAAW,GAAG,IAAI,CAAC;CAC9B;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,aAAa;IAC7B,YAAY,EAAE,QAAQ,CAAC,MAAM,CAAC,WAAW,EAAE,cAAc,CAAC,CAAC,CAAC;IAC5D,eAAe,EAAE,MAAM,CAAC;IACxB,gBAAgB,EAAE,MAAM,CAAC;IACzB,eAAe,EAAE,MAAM,CAAC;IACxB,QAAQ,EAAE,QAAQ,CAAC,OAAO,CAAC,MAAM,CAAC,mBAAmB,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;CACjE;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,WAAW,EAAE,CAAC,EAAE,cAAc,EAAE,CAAC,EAAE,aAAa,GAAG,MAAM,CActF;AAuCD;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,iBAAiB,EAAE,aAc/B,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,eAAe,EAAE,aAc7B,CAAC","sourcesContent":["/**\n * Reasoning-router v2 — frozen types, feature vector, weight schema, the\n * V1_COMPAT_WEIGHTS v1-exact oracle (Req 1.4), and the DEFAULT_WEIGHTS\n * calibrated production preset (Goal 004 Lane I5b).\n *\n * Pure, side-effect-free, erasable TypeScript. No runtime imports.\n *\n * ============================================================================\n * WEIGHT PRESETS — V1_COMPAT_WEIGHTS (v1 oracle) + DEFAULT_WEIGHTS (calibrated)\n * ============================================================================\n * The v1 classifier (reasoning-router.ts) is a first-match keyword cascade with\n * FIXED precedence: debug > refactor > review > plan > simple-edit > code-gen,\n * then fence/diff, then length, then lane fallback, then default code-gen.\n *\n * We reproduce that precedence as DIGIT-POSITION weights. The keyword family at\n * precedence rank r contributes exactly 10^(6-r) to ITS OWN class score when its\n * pattern matches (strongKeyword diagonal, 0/1 match indicator):\n *\n *     debug      r=1 -> 10^5 = 100000\n *     refactor   r=2 -> 10^4 = 10000\n *     review     r=3 -> 10^3 = 1000\n *     plan       r=4 -> 10^2 = 100\n *     simple-edit r=5 -> 10^1 = 10\n *     code-gen   r=6 -> 10^0 = 1\n *\n * Why this is exact for v1's keyword step: a higher-precedence family always\n * outscores the SUM of every lower-precedence family (100000 > 10000+1000+100+\n * 10+1 = 11111), so argmax over scoreClass recovers \"highest-precedence match\n * wins\" with no possibility of ties between matched families.\n *\n * v1 steps 2-6 (fence/diff -> code-gen; len<40 -> trivial; len>=2400 -> plan;\n * lane fallback; default code-gen) are NOT linear in the v2 feature vector\n * (v1 uses hard 40/2400 thresholds; a single lenBucket weight is monotonic and\n * cannot reproduce both). They are therefore reproduced by classifyTaskV2's\n * zero-score cascade: when no keyword and no fence/diff signal fires (every\n * scoreClass term is 0 under DEFAULT_WEIGHTS), classifyTaskV2 applies v1 steps\n * 3-6 verbatim. The fence/diff flags live on the code-gen weight row (boolean\n * weight flag AND feature -> +1) so a fence/diff-only turn still scores code-gen\n * > 0 and is selected by argmax, matching v1 step 2. trivial carries no keyword\n * weight (it is not a keyword family) and is reached only via the cascade.\n *\n * Two presets ship from this encoding (both with thresholds 0, so the\n * sticky / consult / low-margin-judge paths stay INACTIVE):\n *  - V1_COMPAT_WEIGHTS: STRONG-only diagonal, every WEAK coefficient 0. This is\n *    the frozen Req 1.4 oracle — classifyTaskV2(input, V1_COMPAT_WEIGHTS) ===\n *    classifyTask(input) bit-for-bit on the v1 corpus. Do NOT recalibrate it.\n *  - DEFAULT_WEIGHTS: the calibrated production preset. Identical STRONG\n *    diagonal PLUS a constant WEAK diagonal of 1 per keyword class, so an\n *    ambiguous WEAK token (debug \"fix\", refactor \"simplify\", review \"assess\" /\n *    \"lgtm\", code-gen \"add\", plan \"break down\") contributes a small positive\n *    signal to its own class WITHOUT dominating a stronger sibling-class signal\n *    (every STRONG weight >= 1; higher-precedence STRONG weights strictly > 1).\n *    classifyTaskV2(input, DEFAULT_WEIGHTS) is strictly better than v1 on the\n *    gold set (CWA(v2) > CWA(v1)); see laneI5b-calibration.md.\n * ============================================================================\n */\n\n/** Closed set of v2 task classes (same labels as v1 TaskClass). */\nexport type TaskClassV2 = \"trivial\" | \"simple-edit\" | \"code-gen\" | \"debug\" | \"refactor\" | \"review\" | \"plan\";\n\n/** Subagent lane types recognized by the v2 classifier and resolver. */\nexport type ReasoningLaneTypeV2 = \"planner\" | \"security\" | \"explorer\" | \"coder\" | \"reviewer\" | \"tester\";\n\n/** Fixed iteration order over TaskClassV2 (matches the type-declaration order). */\nexport const TASK_CLASSES_V2: readonly TaskClassV2[] = [\n\t\"trivial\",\n\t\"simple-edit\",\n\t\"code-gen\",\n\t\"debug\",\n\t\"refactor\",\n\t\"review\",\n\t\"plan\",\n];\n\n/**\n * Feature vector for one turn, extracted by classifyTaskV2's caller layer.\n *\n * - strongKeyword[c] / weakKeyword[c]: per-class match counts (0 when absent).\n *   For v1-compat, strongKeyword[c] is the 0/1 result of v1's pattern.test.\n * - codeFence / diffHunk: prompt-embedded code-fence / diff-marker booleans.\n * - lenBucket: floor(log2(trimmedLen + 1)) clamped to [0, 7].\n * - multiTurnPrior: most-recent historical class (N=8 ring buffer) or null.\n * - pressureBucket: context-pressure band (0..<0.5, 1..<0.75, 2..<0.9, 3..>=0.9).\n * - judgeVote: optional tier-2 LLM-judge label, or null.\n */\nexport interface RouterFeatures {\n\tstrongKeyword: Partial<Record<TaskClassV2, number>>;\n\tweakKeyword: Partial<Record<TaskClassV2, number>>;\n\tcodeFence: boolean;\n\tdiffHunk: boolean;\n\tlenBucket: number;\n\tmultiTurnPrior: TaskClassV2 | null;\n\tpressureBucket: number;\n\tjudgeVote: TaskClassV2 | null;\n}\n\n/**\n * Tunable weight surface for the v2 router.\n *\n * classWeights[c] is a RouterFeatures-shaped row of per-feature coefficients for\n * class c. stickyThreshold / consultThreshold / marginThreshold steer\n * classifyTaskV2's hysteresis, AdaptOrch consultation, and low-confidence margin\n * gate respectively. laneStep mirrors v1's resolver ladder adjustment per lane.\n */\nexport interface RouterWeights {\n\tclassWeights: Readonly<Record<TaskClassV2, RouterFeatures>>;\n\tstickyThreshold: number;\n\tconsultThreshold: number;\n\tmarginThreshold: number;\n\tlaneStep: Readonly<Partial<Record<ReasoningLaneTypeV2, 1 | -1>>>;\n}\n\n/**\n * Pure integer-arithmetic scorer. Returns S(c) = sum of weighted features for\n * class c under weights w:\n *  - keyword terms: sum over classes c2 of strong/weak weight * feature count.\n *  - boolean signal terms (codeFence, diffHunk): +1 when both the weight flag\n *    AND the feature are set (magnitude is a unit; the flag gates the class).\n *  - numeric terms (lenBucket, pressureBucket): weight * feature product.\n *  - class-equality terms (multiTurnPrior, judgeVote): +1 on exact match with a\n *    non-null feature.\n *\n * Deterministic: same (c, f, w) -> same number. No clock, randomness, or I/O.\n */\nexport function scoreClass(c: TaskClassV2, f: RouterFeatures, w: RouterWeights): number {\n\tconst cw = w.classWeights[c];\n\tlet s = 0;\n\tfor (const c2 of TASK_CLASSES_V2) {\n\t\ts += (cw.strongKeyword[c2] ?? 0) * (f.strongKeyword[c2] ?? 0);\n\t\ts += (cw.weakKeyword[c2] ?? 0) * (f.weakKeyword[c2] ?? 0);\n\t}\n\tif (cw.codeFence && f.codeFence) s += 1;\n\tif (cw.diffHunk && f.diffHunk) s += 1;\n\ts += cw.lenBucket * f.lenBucket;\n\tif (f.multiTurnPrior !== null && cw.multiTurnPrior === f.multiTurnPrior) s += 1;\n\ts += cw.pressureBucket * f.pressureBucket;\n\tif (f.judgeVote !== null && cw.judgeVote === f.judgeVote) s += 1;\n\treturn s;\n}\n\n/**\n * All-neutral feature row (every coefficient inert). Used to build weight rows.\n */\nfunction neutralRow(): RouterFeatures {\n\treturn {\n\t\tstrongKeyword: {},\n\t\tweakKeyword: {},\n\t\tcodeFence: false,\n\t\tdiffHunk: false,\n\t\tlenBucket: 0,\n\t\tmultiTurnPrior: null,\n\t\tpressureBucket: 0,\n\t\tjudgeVote: null,\n\t};\n}\n\n/**\n * STRONG-keyword diagonal shared by both presets: family at precedence rank r\n * contributes 10^(6-r) to its own class (see file header). code-gen additionally\n * owns the codeFence/diffHunk flags so v1 step 2 is captured inside scoreClass.\n * Every WEAK / length / prior / pressure / judge coefficient is zero here.\n */\nconst STRONG_DIAGONAL: Readonly<Record<TaskClassV2, RouterFeatures>> = {\n\ttrivial: neutralRow(),\n\t\"simple-edit\": { ...neutralRow(), strongKeyword: { \"simple-edit\": 10 } },\n\t\"code-gen\": {\n\t\t...neutralRow(),\n\t\tstrongKeyword: { \"code-gen\": 1 },\n\t\tcodeFence: true,\n\t\tdiffHunk: true,\n\t},\n\tdebug: { ...neutralRow(), strongKeyword: { debug: 100000 } },\n\trefactor: { ...neutralRow(), strongKeyword: { refactor: 10000 } },\n\treview: { ...neutralRow(), strongKeyword: { review: 1000 } },\n\tplan: { ...neutralRow(), strongKeyword: { plan: 100 } },\n};\n\n/**\n * v1-compat oracle weight preset (Goal 004 Req 1.4 regression oracle).\n *\n * STRONG-only diagonal (10^(6-r), see file header); every WEAK coefficient is 0\n * so WEAK keywords are inert. code-gen owns the codeFence/diffHunk flags so v1\n * step 2 is captured inside scoreClass. Every length / prior / pressure / judge\n * coefficient is zero (v1 has no linear length signal, no history, no\n * context-pressure input, no judge). Thresholds are 0 so classifyTaskV2 never\n * enters the sticky / consult / low-margin-judge paths.\n *\n * classifyTaskV2(input, V1_COMPAT_WEIGHTS) === classifyTask(input) bit-for-bit\n * on the v1 corpus. Kept frozen as the oracle; do NOT recalibrate this preset.\n */\nexport const V1_COMPAT_WEIGHTS: RouterWeights = {\n\tclassWeights: {\n\t\ttrivial: { ...STRONG_DIAGONAL.trivial },\n\t\t\"simple-edit\": { ...STRONG_DIAGONAL[\"simple-edit\"] },\n\t\t\"code-gen\": { ...STRONG_DIAGONAL[\"code-gen\"] },\n\t\tdebug: { ...STRONG_DIAGONAL.debug },\n\t\trefactor: { ...STRONG_DIAGONAL.refactor },\n\t\treview: { ...STRONG_DIAGONAL.review },\n\t\tplan: { ...STRONG_DIAGONAL.plan },\n\t},\n\tstickyThreshold: 0,\n\tconsultThreshold: 0,\n\tmarginThreshold: 0,\n\tlaneStep: { planner: 1, security: 1, explorer: -1 },\n};\n\n/**\n * Calibrated production preset (Goal 004 Lane I5b). Extends V1_COMPAT_WEIGHTS\n * with a constant WEAK-keyword diagonal of 1 per keyword class.\n *\n * Weighting invariant:\n *  - STRONG keyword in class C: 10^(6-rank(C)) (unchanged from V1_COMPAT).\n *  - WEAK keyword in class C: 1 (constant, identical across classes).\n *\n * Because every STRONG weight (min 1 for code-gen) is >= the constant WEAK\n * weight 1, and higher-precedence STRONG weights (>=10) strictly exceed it, a\n * single STRONG hit in ANY class always beats or ties a lone WEAK hit, while two\n * STRONG hits resolve by the precedence diagonal (10^(6-r)). Concrete\n * consequences on the gold set:\n *  - \"fix the typo\": WEAK-debug(1) + STRONG-simple-edit(10) -> simple-edit wins\n *    (the Req 1.3 regression fix; v1 wrongly routed to debug).\n *  - \"fix the race condition\": WEAK-debug(1) alone -> debug beats the zero\n *    default (no len>=40 cascade to code-gen; v1 was already correct here, the\n *    STRONG-only oracle had regressed it).\n *  - \"simplify the nested if-else\": WEAK-refactor(1) alone -> refactor.\n *  - \"lgtm, just double-check the tests\": WEAK-review(1) alone -> review.\n *  - \"crash the typo\": STRONG-debug(100000) + STRONG-simple-edit(10) -> debug\n *    (a crash-dominated prompt stays debug; precedence diagonal preserved).\n *\n * classifyTaskV2(input, DEFAULT_WEIGHTS) is STRICTLY BETTER than v1 on the gold\n * set (CWA(v2) > CWA(v1)); see .omk/goals/004-reasoning-router-v2-impl/\n * laneI5b-calibration.md. Thresholds stay 0 so hysteresis/consult/margin paths\n * remain inactive (Phase A).\n */\nexport const DEFAULT_WEIGHTS: RouterWeights = {\n\tclassWeights: {\n\t\ttrivial: { ...STRONG_DIAGONAL.trivial },\n\t\t\"simple-edit\": { ...STRONG_DIAGONAL[\"simple-edit\"] },\n\t\t\"code-gen\": { ...STRONG_DIAGONAL[\"code-gen\"], weakKeyword: { \"code-gen\": 1 } },\n\t\tdebug: { ...STRONG_DIAGONAL.debug, weakKeyword: { debug: 1 } },\n\t\trefactor: { ...STRONG_DIAGONAL.refactor, weakKeyword: { refactor: 1 } },\n\t\treview: { ...STRONG_DIAGONAL.review, weakKeyword: { review: 1 } },\n\t\tplan: { ...STRONG_DIAGONAL.plan, weakKeyword: { plan: 1 } },\n\t},\n\tstickyThreshold: 0,\n\tconsultThreshold: 0,\n\tmarginThreshold: 0,\n\tlaneStep: { planner: 1, security: 1, explorer: -1 },\n};\n"]}

package/dist/core/reasoning-router-weights.js

@@ -1,204 +0,0 @@
-/**
- * Reasoning-router v2 — frozen types, feature vector, weight schema, the
- * V1_COMPAT_WEIGHTS v1-exact oracle (Req 1.4), and the DEFAULT_WEIGHTS
- * calibrated production preset (Goal 004 Lane I5b).
- *
- * Pure, side-effect-free, erasable TypeScript. No runtime imports.
- *
- * ============================================================================
- * WEIGHT PRESETS — V1_COMPAT_WEIGHTS (v1 oracle) + DEFAULT_WEIGHTS (calibrated)
- * ============================================================================
- * The v1 classifier (reasoning-router.ts) is a first-match keyword cascade with
- * FIXED precedence: debug > refactor > review > plan > simple-edit > code-gen,
- * then fence/diff, then length, then lane fallback, then default code-gen.
- *
- * We reproduce that precedence as DIGIT-POSITION weights. The keyword family at
- * precedence rank r contributes exactly 10^(6-r) to ITS OWN class score when its
- * pattern matches (strongKeyword diagonal, 0/1 match indicator):
- *
- *     debug      r=1 -> 10^5 = 100000
- *     refactor   r=2 -> 10^4 = 10000
- *     review     r=3 -> 10^3 = 1000
- *     plan       r=4 -> 10^2 = 100
- *     simple-edit r=5 -> 10^1 = 10
- *     code-gen   r=6 -> 10^0 = 1
- *
- * Why this is exact for v1's keyword step: a higher-precedence family always
- * outscores the SUM of every lower-precedence family (100000 > 10000+1000+100+
- * 10+1 = 11111), so argmax over scoreClass recovers "highest-precedence match
- * wins" with no possibility of ties between matched families.
- *
- * v1 steps 2-6 (fence/diff -> code-gen; len<40 -> trivial; len>=2400 -> plan;
- * lane fallback; default code-gen) are NOT linear in the v2 feature vector
- * (v1 uses hard 40/2400 thresholds; a single lenBucket weight is monotonic and
- * cannot reproduce both). They are therefore reproduced by classifyTaskV2's
- * zero-score cascade: when no keyword and no fence/diff signal fires (every
- * scoreClass term is 0 under DEFAULT_WEIGHTS), classifyTaskV2 applies v1 steps
- * 3-6 verbatim. The fence/diff flags live on the code-gen weight row (boolean
- * weight flag AND feature -> +1) so a fence/diff-only turn still scores code-gen
- * > 0 and is selected by argmax, matching v1 step 2. trivial carries no keyword
- * weight (it is not a keyword family) and is reached only via the cascade.
- *
- * Two presets ship from this encoding (both with thresholds 0, so the
- * sticky / consult / low-margin-judge paths stay INACTIVE):
- *  - V1_COMPAT_WEIGHTS: STRONG-only diagonal, every WEAK coefficient 0. This is
- *    the frozen Req 1.4 oracle — classifyTaskV2(input, V1_COMPAT_WEIGHTS) ===
- *    classifyTask(input) bit-for-bit on the v1 corpus. Do NOT recalibrate it.
- *  - DEFAULT_WEIGHTS: the calibrated production preset. Identical STRONG
- *    diagonal PLUS a constant WEAK diagonal of 1 per keyword class, so an
- *    ambiguous WEAK token (debug "fix", refactor "simplify", review "assess" /
- *    "lgtm", code-gen "add", plan "break down") contributes a small positive
- *    signal to its own class WITHOUT dominating a stronger sibling-class signal
- *    (every STRONG weight >= 1; higher-precedence STRONG weights strictly > 1).
- *    classifyTaskV2(input, DEFAULT_WEIGHTS) is strictly better than v1 on the
- *    gold set (CWA(v2) > CWA(v1)); see laneI5b-calibration.md.
- * ============================================================================
- */
-/** Fixed iteration order over TaskClassV2 (matches the type-declaration order). */
-export const TASK_CLASSES_V2 = [
-    "trivial",
-    "simple-edit",
-    "code-gen",
-    "debug",
-    "refactor",
-    "review",
-    "plan",
-];
-/**
- * Pure integer-arithmetic scorer. Returns S(c) = sum of weighted features for
- * class c under weights w:
- *  - keyword terms: sum over classes c2 of strong/weak weight * feature count.
- *  - boolean signal terms (codeFence, diffHunk): +1 when both the weight flag
- *    AND the feature are set (magnitude is a unit; the flag gates the class).
- *  - numeric terms (lenBucket, pressureBucket): weight * feature product.
- *  - class-equality terms (multiTurnPrior, judgeVote): +1 on exact match with a
- *    non-null feature.
- *
- * Deterministic: same (c, f, w) -> same number. No clock, randomness, or I/O.
- */
-export function scoreClass(c, f, w) {
-    const cw = w.classWeights[c];
-    let s = 0;
-    for (const c2 of TASK_CLASSES_V2) {
-        s += (cw.strongKeyword[c2] ?? 0) * (f.strongKeyword[c2] ?? 0);
-        s += (cw.weakKeyword[c2] ?? 0) * (f.weakKeyword[c2] ?? 0);
-    }
-    if (cw.codeFence && f.codeFence)
-        s += 1;
-    if (cw.diffHunk && f.diffHunk)
-        s += 1;
-    s += cw.lenBucket * f.lenBucket;
-    if (f.multiTurnPrior !== null && cw.multiTurnPrior === f.multiTurnPrior)
-        s += 1;
-    s += cw.pressureBucket * f.pressureBucket;
-    if (f.judgeVote !== null && cw.judgeVote === f.judgeVote)
-        s += 1;
-    return s;
-}
-/**
- * All-neutral feature row (every coefficient inert). Used to build weight rows.
- */
-function neutralRow() {
-    return {
-        strongKeyword: {},
-        weakKeyword: {},
-        codeFence: false,
-        diffHunk: false,
-        lenBucket: 0,
-        multiTurnPrior: null,
-        pressureBucket: 0,
-        judgeVote: null,
-    };
-}
-/**
- * STRONG-keyword diagonal shared by both presets: family at precedence rank r
- * contributes 10^(6-r) to its own class (see file header). code-gen additionally
- * owns the codeFence/diffHunk flags so v1 step 2 is captured inside scoreClass.
- * Every WEAK / length / prior / pressure / judge coefficient is zero here.
- */
-const STRONG_DIAGONAL = {
-    trivial: neutralRow(),
-    "simple-edit": { ...neutralRow(), strongKeyword: { "simple-edit": 10 } },
-    "code-gen": {
-        ...neutralRow(),
-        strongKeyword: { "code-gen": 1 },
-        codeFence: true,
-        diffHunk: true,
-    },
-    debug: { ...neutralRow(), strongKeyword: { debug: 100000 } },
-    refactor: { ...neutralRow(), strongKeyword: { refactor: 10000 } },
-    review: { ...neutralRow(), strongKeyword: { review: 1000 } },
-    plan: { ...neutralRow(), strongKeyword: { plan: 100 } },
-};
-/**
- * v1-compat oracle weight preset (Goal 004 Req 1.4 regression oracle).
- *
- * STRONG-only diagonal (10^(6-r), see file header); every WEAK coefficient is 0
- * so WEAK keywords are inert. code-gen owns the codeFence/diffHunk flags so v1
- * step 2 is captured inside scoreClass. Every length / prior / pressure / judge
- * coefficient is zero (v1 has no linear length signal, no history, no
- * context-pressure input, no judge). Thresholds are 0 so classifyTaskV2 never
- * enters the sticky / consult / low-margin-judge paths.
- *
- * classifyTaskV2(input, V1_COMPAT_WEIGHTS) === classifyTask(input) bit-for-bit
- * on the v1 corpus. Kept frozen as the oracle; do NOT recalibrate this preset.
- */
-export const V1_COMPAT_WEIGHTS = {
-    classWeights: {
-        trivial: { ...STRONG_DIAGONAL.trivial },
-        "simple-edit": { ...STRONG_DIAGONAL["simple-edit"] },
-        "code-gen": { ...STRONG_DIAGONAL["code-gen"] },
-        debug: { ...STRONG_DIAGONAL.debug },
-        refactor: { ...STRONG_DIAGONAL.refactor },
-        review: { ...STRONG_DIAGONAL.review },
-        plan: { ...STRONG_DIAGONAL.plan },
-    },
-    stickyThreshold: 0,
-    consultThreshold: 0,
-    marginThreshold: 0,
-    laneStep: { planner: 1, security: 1, explorer: -1 },
-};
-/**
- * Calibrated production preset (Goal 004 Lane I5b). Extends V1_COMPAT_WEIGHTS
- * with a constant WEAK-keyword diagonal of 1 per keyword class.
- *
- * Weighting invariant:
- *  - STRONG keyword in class C: 10^(6-rank(C)) (unchanged from V1_COMPAT).
- *  - WEAK keyword in class C: 1 (constant, identical across classes).
- *
- * Because every STRONG weight (min 1 for code-gen) is >= the constant WEAK
- * weight 1, and higher-precedence STRONG weights (>=10) strictly exceed it, a
- * single STRONG hit in ANY class always beats or ties a lone WEAK hit, while two
- * STRONG hits resolve by the precedence diagonal (10^(6-r)). Concrete
- * consequences on the gold set:
- *  - "fix the typo": WEAK-debug(1) + STRONG-simple-edit(10) -> simple-edit wins
- *    (the Req 1.3 regression fix; v1 wrongly routed to debug).
- *  - "fix the race condition": WEAK-debug(1) alone -> debug beats the zero
- *    default (no len>=40 cascade to code-gen; v1 was already correct here, the
- *    STRONG-only oracle had regressed it).
- *  - "simplify the nested if-else": WEAK-refactor(1) alone -> refactor.
- *  - "lgtm, just double-check the tests": WEAK-review(1) alone -> review.
- *  - "crash the typo": STRONG-debug(100000) + STRONG-simple-edit(10) -> debug
- *    (a crash-dominated prompt stays debug; precedence diagonal preserved).
- *
- * classifyTaskV2(input, DEFAULT_WEIGHTS) is STRICTLY BETTER than v1 on the gold
- * set (CWA(v2) > CWA(v1)); see .omk/goals/004-reasoning-router-v2-impl/
- * laneI5b-calibration.md. Thresholds stay 0 so hysteresis/consult/margin paths
- * remain inactive (Phase A).
- */
-export const DEFAULT_WEIGHTS = {
-    classWeights: {
-        trivial: { ...STRONG_DIAGONAL.trivial },
-        "simple-edit": { ...STRONG_DIAGONAL["simple-edit"] },
-        "code-gen": { ...STRONG_DIAGONAL["code-gen"], weakKeyword: { "code-gen": 1 } },
-        debug: { ...STRONG_DIAGONAL.debug, weakKeyword: { debug: 1 } },
-        refactor: { ...STRONG_DIAGONAL.refactor, weakKeyword: { refactor: 1 } },
-        review: { ...STRONG_DIAGONAL.review, weakKeyword: { review: 1 } },
-        plan: { ...STRONG_DIAGONAL.plan, weakKeyword: { plan: 1 } },
-    },
-    stickyThreshold: 0,
-    consultThreshold: 0,
-    marginThreshold: 0,
-    laneStep: { planner: 1, security: 1, explorer: -1 },
-};
-//# sourceMappingURL=reasoning-router-weights.js.map

package/dist/core/reasoning-router-weights.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"reasoning-router-weights.js","sourceRoot":"","sources":["../../src/core/reasoning-router-weights.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Reasoning-router v2 — frozen types, feature vector, weight schema, the\n * V1_COMPAT_WEIGHTS v1-exact oracle (Req 1.4), and the DEFAULT_WEIGHTS\n * calibrated production preset (Goal 004 Lane I5b).\n *\n * Pure, side-effect-free, erasable TypeScript. No runtime imports.\n *\n * ============================================================================\n * WEIGHT PRESETS — V1_COMPAT_WEIGHTS (v1 oracle) + DEFAULT_WEIGHTS (calibrated)\n * ============================================================================\n * The v1 classifier (reasoning-router.ts) is a first-match keyword cascade with\n * FIXED precedence: debug > refactor > review > plan > simple-edit > code-gen,\n * then fence/diff, then length, then lane fallback, then default code-gen.\n *\n * We reproduce that precedence as DIGIT-POSITION weights. The keyword family at\n * precedence rank r contributes exactly 10^(6-r) to ITS OWN class score when its\n * pattern matches (strongKeyword diagonal, 0/1 match indicator):\n *\n *     debug      r=1 -> 10^5 = 100000\n *     refactor   r=2 -> 10^4 = 10000\n *     review     r=3 -> 10^3 = 1000\n *     plan       r=4 -> 10^2 = 100\n *     simple-edit r=5 -> 10^1 = 10\n *     code-gen   r=6 -> 10^0 = 1\n *\n * Why this is exact for v1's keyword step: a higher-precedence family always\n * outscores the SUM of every lower-precedence family (100000 > 10000+1000+100+\n * 10+1 = 11111), so argmax over scoreClass recovers \"highest-precedence match\n * wins\" with no possibility of ties between matched families.\n *\n * v1 steps 2-6 (fence/diff -> code-gen; len<40 -> trivial; len>=2400 -> plan;\n * lane fallback; default code-gen) are NOT linear in the v2 feature vector\n * (v1 uses hard 40/2400 thresholds; a single lenBucket weight is monotonic and\n * cannot reproduce both). They are therefore reproduced by classifyTaskV2's\n * zero-score cascade: when no keyword and no fence/diff signal fires (every\n * scoreClass term is 0 under DEFAULT_WEIGHTS), classifyTaskV2 applies v1 steps\n * 3-6 verbatim. The fence/diff flags live on the code-gen weight row (boolean\n * weight flag AND feature -> +1) so a fence/diff-only turn still scores code-gen\n * > 0 and is selected by argmax, matching v1 step 2. trivial carries no keyword\n * weight (it is not a keyword family) and is reached only via the cascade.\n *\n * Two presets ship from this encoding (both with thresholds 0, so the\n * sticky / consult / low-margin-judge paths stay INACTIVE):\n *  - V1_COMPAT_WEIGHTS: STRONG-only diagonal, every WEAK coefficient 0. This is\n *    the frozen Req 1.4 oracle — classifyTaskV2(input, V1_COMPAT_WEIGHTS) ===\n *    classifyTask(input) bit-for-bit on the v1 corpus. Do NOT recalibrate it.\n *  - DEFAULT_WEIGHTS: the calibrated production preset. Identical STRONG\n *    diagonal PLUS a constant WEAK diagonal of 1 per keyword class, so an\n *    ambiguous WEAK token (debug \"fix\", refactor \"simplify\", review \"assess\" /\n *    \"lgtm\", code-gen \"add\", plan \"break down\") contributes a small positive\n *    signal to its own class WITHOUT dominating a stronger sibling-class signal\n *    (every STRONG weight >= 1; higher-precedence STRONG weights strictly > 1).\n *    classifyTaskV2(input, DEFAULT_WEIGHTS) is strictly better than v1 on the\n *    gold set (CWA(v2) > CWA(v1)); see laneI5b-calibration.md.\n * ============================================================================\n */\n\n/** Closed set of v2 task classes (same labels as v1 TaskClass). */\nexport type TaskClassV2 = \"trivial\" | \"simple-edit\" | \"code-gen\" | \"debug\" | \"refactor\" | \"review\" | \"plan\";\n\n/** Subagent lane types recognized by the v2 classifier and resolver. */\nexport type ReasoningLaneTypeV2 = \"planner\" | \"security\" | \"explorer\" | \"coder\" | \"reviewer\" | \"tester\";\n\n/** Fixed iteration order over TaskClassV2 (matches the type-declaration order). */\nexport const TASK_CLASSES_V2: readonly TaskClassV2[] = [\n\t\"trivial\",\n\t\"simple-edit\",\n\t\"code-gen\",\n\t\"debug\",\n\t\"refactor\",\n\t\"review\",\n\t\"plan\",\n];\n\n/**\n * Feature vector for one turn, extracted by classifyTaskV2's caller layer.\n *\n * - strongKeyword[c] / weakKeyword[c]: per-class match counts (0 when absent).\n *   For v1-compat, strongKeyword[c] is the 0/1 result of v1's pattern.test.\n * - codeFence / diffHunk: prompt-embedded code-fence / diff-marker booleans.\n * - lenBucket: floor(log2(trimmedLen + 1)) clamped to [0, 7].\n * - multiTurnPrior: most-recent historical class (N=8 ring buffer) or null.\n * - pressureBucket: context-pressure band (0..<0.5, 1..<0.75, 2..<0.9, 3..>=0.9).\n * - judgeVote: optional tier-2 LLM-judge label, or null.\n */\nexport interface RouterFeatures {\n\tstrongKeyword: Partial<Record<TaskClassV2, number>>;\n\tweakKeyword: Partial<Record<TaskClassV2, number>>;\n\tcodeFence: boolean;\n\tdiffHunk: boolean;\n\tlenBucket: number;\n\tmultiTurnPrior: TaskClassV2 | null;\n\tpressureBucket: number;\n\tjudgeVote: TaskClassV2 | null;\n}\n\n/**\n * Tunable weight surface for the v2 router.\n *\n * classWeights[c] is a RouterFeatures-shaped row of per-feature coefficients for\n * class c. stickyThreshold / consultThreshold / marginThreshold steer\n * classifyTaskV2's hysteresis, AdaptOrch consultation, and low-confidence margin\n * gate respectively. laneStep mirrors v1's resolver ladder adjustment per lane.\n */\nexport interface RouterWeights {\n\tclassWeights: Readonly<Record<TaskClassV2, RouterFeatures>>;\n\tstickyThreshold: number;\n\tconsultThreshold: number;\n\tmarginThreshold: number;\n\tlaneStep: Readonly<Partial<Record<ReasoningLaneTypeV2, 1 | -1>>>;\n}\n\n/**\n * Pure integer-arithmetic scorer. Returns S(c) = sum of weighted features for\n * class c under weights w:\n *  - keyword terms: sum over classes c2 of strong/weak weight * feature count.\n *  - boolean signal terms (codeFence, diffHunk): +1 when both the weight flag\n *    AND the feature are set (magnitude is a unit; the flag gates the class).\n *  - numeric terms (lenBucket, pressureBucket): weight * feature product.\n *  - class-equality terms (multiTurnPrior, judgeVote): +1 on exact match with a\n *    non-null feature.\n *\n * Deterministic: same (c, f, w) -> same number. No clock, randomness, or I/O.\n */\nexport function scoreClass(c: TaskClassV2, f: RouterFeatures, w: RouterWeights): number {\n\tconst cw = w.classWeights[c];\n\tlet s = 0;\n\tfor (const c2 of TASK_CLASSES_V2) {\n\t\ts += (cw.strongKeyword[c2] ?? 0) * (f.strongKeyword[c2] ?? 0);\n\t\ts += (cw.weakKeyword[c2] ?? 0) * (f.weakKeyword[c2] ?? 0);\n\t}\n\tif (cw.codeFence && f.codeFence) s += 1;\n\tif (cw.diffHunk && f.diffHunk) s += 1;\n\ts += cw.lenBucket * f.lenBucket;\n\tif (f.multiTurnPrior !== null && cw.multiTurnPrior === f.multiTurnPrior) s += 1;\n\ts += cw.pressureBucket * f.pressureBucket;\n\tif (f.judgeVote !== null && cw.judgeVote === f.judgeVote) s += 1;\n\treturn s;\n}\n\n/**\n * All-neutral feature row (every coefficient inert). Used to build weight rows.\n */\nfunction neutralRow(): RouterFeatures {\n\treturn {\n\t\tstrongKeyword: {},\n\t\tweakKeyword: {},\n\t\tcodeFence: false,\n\t\tdiffHunk: false,\n\t\tlenBucket: 0,\n\t\tmultiTurnPrior: null,\n\t\tpressureBucket: 0,\n\t\tjudgeVote: null,\n\t};\n}\n\n/**\n * STRONG-keyword diagonal shared by both presets: family at precedence rank r\n * contributes 10^(6-r) to its own class (see file header). code-gen additionally\n * owns the codeFence/diffHunk flags so v1 step 2 is captured inside scoreClass.\n * Every WEAK / length / prior / pressure / judge coefficient is zero here.\n */\nconst STRONG_DIAGONAL: Readonly<Record<TaskClassV2, RouterFeatures>> = {\n\ttrivial: neutralRow(),\n\t\"simple-edit\": { ...neutralRow(), strongKeyword: { \"simple-edit\": 10 } },\n\t\"code-gen\": {\n\t\t...neutralRow(),\n\t\tstrongKeyword: { \"code-gen\": 1 },\n\t\tcodeFence: true,\n\t\tdiffHunk: true,\n\t},\n\tdebug: { ...neutralRow(), strongKeyword: { debug: 100000 } },\n\trefactor: { ...neutralRow(), strongKeyword: { refactor: 10000 } },\n\treview: { ...neutralRow(), strongKeyword: { review: 1000 } },\n\tplan: { ...neutralRow(), strongKeyword: { plan: 100 } },\n};\n\n/**\n * v1-compat oracle weight preset (Goal 004 Req 1.4 regression oracle).\n *\n * STRONG-only diagonal (10^(6-r), see file header); every WEAK coefficient is 0\n * so WEAK keywords are inert. code-gen owns the codeFence/diffHunk flags so v1\n * step 2 is captured inside scoreClass. Every length / prior / pressure / judge\n * coefficient is zero (v1 has no linear length signal, no history, no\n * context-pressure input, no judge). Thresholds are 0 so classifyTaskV2 never\n * enters the sticky / consult / low-margin-judge paths.\n *\n * classifyTaskV2(input, V1_COMPAT_WEIGHTS) === classifyTask(input) bit-for-bit\n * on the v1 corpus. Kept frozen as the oracle; do NOT recalibrate this preset.\n */\nexport const V1_COMPAT_WEIGHTS: RouterWeights = {\n\tclassWeights: {\n\t\ttrivial: { ...STRONG_DIAGONAL.trivial },\n\t\t\"simple-edit\": { ...STRONG_DIAGONAL[\"simple-edit\"] },\n\t\t\"code-gen\": { ...STRONG_DIAGONAL[\"code-gen\"] },\n\t\tdebug: { ...STRONG_DIAGONAL.debug },\n\t\trefactor: { ...STRONG_DIAGONAL.refactor },\n\t\treview: { ...STRONG_DIAGONAL.review },\n\t\tplan: { ...STRONG_DIAGONAL.plan },\n\t},\n\tstickyThreshold: 0,\n\tconsultThreshold: 0,\n\tmarginThreshold: 0,\n\tlaneStep: { planner: 1, security: 1, explorer: -1 },\n};\n\n/**\n * Calibrated production preset (Goal 004 Lane I5b). Extends V1_COMPAT_WEIGHTS\n * with a constant WEAK-keyword diagonal of 1 per keyword class.\n *\n * Weighting invariant:\n *  - STRONG keyword in class C: 10^(6-rank(C)) (unchanged from V1_COMPAT).\n *  - WEAK keyword in class C: 1 (constant, identical across classes).\n *\n * Because every STRONG weight (min 1 for code-gen) is >= the constant WEAK\n * weight 1, and higher-precedence STRONG weights (>=10) strictly exceed it, a\n * single STRONG hit in ANY class always beats or ties a lone WEAK hit, while two\n * STRONG hits resolve by the precedence diagonal (10^(6-r)). Concrete\n * consequences on the gold set:\n *  - \"fix the typo\": WEAK-debug(1) + STRONG-simple-edit(10) -> simple-edit wins\n *    (the Req 1.3 regression fix; v1 wrongly routed to debug).\n *  - \"fix the race condition\": WEAK-debug(1) alone -> debug beats the zero\n *    default (no len>=40 cascade to code-gen; v1 was already correct here, the\n *    STRONG-only oracle had regressed it).\n *  - \"simplify the nested if-else\": WEAK-refactor(1) alone -> refactor.\n *  - \"lgtm, just double-check the tests\": WEAK-review(1) alone -> review.\n *  - \"crash the typo\": STRONG-debug(100000) + STRONG-simple-edit(10) -> debug\n *    (a crash-dominated prompt stays debug; precedence diagonal preserved).\n *\n * classifyTaskV2(input, DEFAULT_WEIGHTS) is STRICTLY BETTER than v1 on the gold\n * set (CWA(v2) > CWA(v1)); see .omk/goals/004-reasoning-router-v2-impl/\n * laneI5b-calibration.md. Thresholds stay 0 so hysteresis/consult/margin paths\n * remain inactive (Phase A).\n */\nexport const DEFAULT_WEIGHTS: RouterWeights = {\n\tclassWeights: {\n\t\ttrivial: { ...STRONG_DIAGONAL.trivial },\n\t\t\"simple-edit\": { ...STRONG_DIAGONAL[\"simple-edit\"] },\n\t\t\"code-gen\": { ...STRONG_DIAGONAL[\"code-gen\"], weakKeyword: { \"code-gen\": 1 } },\n\t\tdebug: { ...STRONG_DIAGONAL.debug, weakKeyword: { debug: 1 } },\n\t\trefactor: { ...STRONG_DIAGONAL.refactor, weakKeyword: { refactor: 1 } },\n\t\treview: { ...STRONG_DIAGONAL.review, weakKeyword: { review: 1 } },\n\t\tplan: { ...STRONG_DIAGONAL.plan, weakKeyword: { plan: 1 } },\n\t},\n\tstickyThreshold: 0,\n\tconsultThreshold: 0,\n\tmarginThreshold: 0,\n\tlaneStep: { planner: 1, security: 1, explorer: -1 },\n};\n"]}

package/dist/core/reasoning-router.d.ts

@@ -1,44 +0,0 @@
-/**
- * Reasoning-effort router: pure, side-effect-free task classification and
- * ThinkingLevel resolution for the `auto` thinking mode.
- *
- * Deterministic by construction: consumes only the prompt text and an optional
- * subagent lane type. No clock, randomness, I/O, or imports from session, TUI,
- * or provider code (the ThinkingLevel import below is type-only and erased).
- */
-import type { ThinkingLevel } from "omk-agent-core";
-/** Closed set of task classes the router can assign to a turn. */
-export type TaskClass = "trivial" | "simple-edit" | "code-gen" | "debug" | "refactor" | "review" | "plan";
-/** Subagent lane types recognized by the classifier and resolver. */
-export type ReasoningLaneType = "planner" | "security" | "explorer" | "coder" | "reviewer" | "tester";
-export interface TaskClassifierInput {
-    prompt: string;
-    laneType?: ReasoningLaneType;
-}
-/**
- * Classify a turn deterministically. Signal precedence (first match wins):
- * 1. Keyword families (debug > refactor > review > plan > simple-edit > code-gen)
- * 2. Code fence or diff markers -> code-gen
- * 3. Trimmed length < TRIVIAL_MAX_CHARS -> trivial
- * 4. Trimmed length >= COMPLEX_PROSE_MIN_CHARS -> plan (long prose brief)
- * 5. Lane fallback (see LANE_FALLBACK_CLASS)
- * 6. Default -> code-gen
- */
-export declare function classifyTask(input: TaskClassifierInput): TaskClass;
-/** Static rule table: task class -> recommended ThinkingLevel (before lane adjustment and clamping). */
-export declare const TASK_CLASS_THINKING_LEVELS: Readonly<Record<TaskClass, ThinkingLevel>>;
-/**
- * Resolve the recommended ThinkingLevel for a task class:
- * 1. Look up the static rule table.
- * 2. Apply the lane adjustment (one ladder step, saturating at ladder ends).
- * 3. Clamp to the highest level in `availableLevels` that is <= the target;
- *    if no available level is at/below the target, return the lowest available
- *    reasoning level. Never invents a level outside `availableLevels`.
- *
- * `"off"` is never a router output for reasoning models. If `availableLevels`
- * contains no ladder level at all (e.g. a non-reasoning model exposing only
- * "off"), the first available level is returned; callers are expected to
- * bypass the router entirely for models with `reasoning: false`.
- */
-export declare function resolveThinkingLevel(taskClass: TaskClass, availableLevels: readonly ThinkingLevel[], laneType?: ReasoningLaneType): ThinkingLevel;
-//# sourceMappingURL=reasoning-router.d.ts.map

package/dist/core/reasoning-router.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"reasoning-router.d.ts","sourceRoot":"","sources":["../../src/core/reasoning-router.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAEpD,kEAAkE;AAClE,MAAM,MAAM,SAAS,GAAG,SAAS,GAAG,aAAa,GAAG,UAAU,GAAG,OAAO,GAAG,UAAU,GAAG,QAAQ,GAAG,MAAM,CAAC;AAE1G,qEAAqE;AACrE,MAAM,MAAM,iBAAiB,GAAG,SAAS,GAAG,UAAU,GAAG,UAAU,GAAG,OAAO,GAAG,UAAU,GAAG,QAAQ,CAAC;AAEtG,MAAM,WAAW,mBAAmB;IACnC,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,iBAAiB,CAAC;CAC7B;AAqED;;;;;;;;GAQG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,mBAAmB,GAAG,SAAS,CAYlE;AAKD,wGAAwG;AACxG,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,MAAM,CAAC,SAAS,EAAE,aAAa,CAAC,CAQjF,CAAC;AASF;;;;;;;;;;;;GAYG;AACH,wBAAgB,oBAAoB,CACnC,SAAS,EAAE,SAAS,EACpB,eAAe,EAAE,SAAS,aAAa,EAAE,EACzC,QAAQ,CAAC,EAAE,iBAAiB,GAC1B,aAAa,CAef","sourcesContent":["/**\n * Reasoning-effort router: pure, side-effect-free task classification and\n * ThinkingLevel resolution for the `auto` thinking mode.\n *\n * Deterministic by construction: consumes only the prompt text and an optional\n * subagent lane type. No clock, randomness, I/O, or imports from session, TUI,\n * or provider code (the ThinkingLevel import below is type-only and erased).\n */\n\nimport type { ThinkingLevel } from \"omk-agent-core\";\n\n/** Closed set of task classes the router can assign to a turn. */\nexport type TaskClass = \"trivial\" | \"simple-edit\" | \"code-gen\" | \"debug\" | \"refactor\" | \"review\" | \"plan\";\n\n/** Subagent lane types recognized by the classifier and resolver. */\nexport type ReasoningLaneType = \"planner\" | \"security\" | \"explorer\" | \"coder\" | \"reviewer\" | \"tester\";\n\nexport interface TaskClassifierInput {\n\tprompt: string;\n\tlaneType?: ReasoningLaneType;\n}\n\n/** Prompts shorter than this (trimmed) classify as trivial when no stronger signal matches. */\nconst TRIVIAL_MAX_CHARS = 40;\n/** Prompts at/above this length with no keyword/code/diff signal are treated as long prose briefs (plan). */\nconst COMPLEX_PROSE_MIN_CHARS = 2400;\n\n/**\n * Keyword families in FIXED precedence order:\n * debug > refactor > review > plan > simple-edit > code-gen.\n * The first matching family wins; ties are impossible by construction.\n * Patterns are case-insensitive and stateless (no `g` flag, so no lastIndex carry-over).\n */\nconst KEYWORD_FAMILIES: ReadonlyArray<{ taskClass: TaskClass; pattern: RegExp }> = [\n\t{\n\t\ttaskClass: \"debug\",\n\t\tpattern:\n\t\t\t/\\b(debug(ging)?|bugs?|fix(es|ing|ed)?|errors?|exceptions?|crash(es|ing|ed)?|stack\\s*trace|traceback|regressions?|broken|fail(s|ing|ed|ure|ures)?|flaky|reproduce)\\b/i,\n\t},\n\t{\n\t\ttaskClass: \"refactor\",\n\t\tpattern:\n\t\t\t/\\b(refactor(ing|ed)?|restructur(e|ing)|renam(e|ing)|extract(ing)?|clean\\s*up|cleanup|simplif(y|ying|ied)|deduplicat(e|ing)|reorganiz(e|ing)|rewrit(e|ing)|modulariz(e|ing))\\b/i,\n\t},\n\t{\n\t\ttaskClass: \"review\",\n\t\tpattern: /\\b(review(s|ing|ed)?|audit(s|ing|ed)?|critique|assess(ing|ment)?|inspect(ing)?|lgtm|approve)\\b/i,\n\t},\n\t{\n\t\ttaskClass: \"plan\",\n\t\tpattern:\n\t\t\t/\\b(plan(s|ning)?|design(s|ing)?|architect(s|ure|ing)?|roadmap|spec(s|ification|ifications)?|strateg(y|ies|ize)|decompos(e|ing|ition)|break\\s+(this\\s+|it\\s+)?down|milestones?)\\b/i,\n\t},\n\t{\n\t\ttaskClass: \"simple-edit\",\n\t\tpattern:\n\t\t\t/\\b(typos?|tweak(s|ing|ed)?|one-?liner?|single\\s+line|bump(s|ing|ed)?|whitespace|reword(s|ing|ed)?|indentation|punctuation)\\b/i,\n\t},\n\t{\n\t\ttaskClass: \"code-gen\",\n\t\tpattern:\n\t\t\t/\\b(implement(s|ing|ation)?|writ(e|ing)|creat(e|es|ing)|add(s|ing|ed)?|build(s|ing)?|generat(e|es|ing)|scaffold(ing)?|prototype)\\b/i,\n\t},\n];\n\n/** Fallback class per lane when no keyword, code/diff, or length signal decides. */\nconst LANE_FALLBACK_CLASS: Record<ReasoningLaneType, TaskClass> = {\n\tplanner: \"plan\",\n\tsecurity: \"review\",\n\texplorer: \"review\",\n\tcoder: \"code-gen\",\n\treviewer: \"review\",\n\ttester: \"code-gen\",\n};\n\nfunction hasCodeFence(text: string): boolean {\n\treturn text.includes(\"```\");\n}\n\n/**\n * Diff detection: explicit hunk (`@@ ... @@`) or `diff --git` headers count alone;\n * bare `+`/`-` line starts only count when both added AND removed lines are present\n * (avoids false positives on markdown bullet lists).\n */\nfunction hasDiffMarkers(text: string): boolean {\n\tif (/^@@[^\\n]*@@/m.test(text) || /^diff --git /m.test(text)) return true;\n\treturn /^\\+(?!\\+)/m.test(text) && /^-(?!-)/m.test(text);\n}\n\n/**\n * Classify a turn deterministically. Signal precedence (first match wins):\n * 1. Keyword families (debug > refactor > review > plan > simple-edit > code-gen)\n * 2. Code fence or diff markers -> code-gen\n * 3. Trimmed length < TRIVIAL_MAX_CHARS -> trivial\n * 4. Trimmed length >= COMPLEX_PROSE_MIN_CHARS -> plan (long prose brief)\n * 5. Lane fallback (see LANE_FALLBACK_CLASS)\n * 6. Default -> code-gen\n */\nexport function classifyTask(input: TaskClassifierInput): TaskClass {\n\tconst prompt = input.prompt.trim();\n\n\tfor (const family of KEYWORD_FAMILIES) {\n\t\tif (family.pattern.test(prompt)) return family.taskClass;\n\t}\n\n\tif (hasCodeFence(prompt) || hasDiffMarkers(prompt)) return \"code-gen\";\n\tif (prompt.length < TRIVIAL_MAX_CHARS) return \"trivial\";\n\tif (prompt.length >= COMPLEX_PROSE_MIN_CHARS) return \"plan\";\n\tif (input.laneType) return LANE_FALLBACK_CLASS[input.laneType];\n\treturn \"code-gen\";\n}\n\n/** Reasoning ladder used for targets and clamping. Intentionally excludes \"off\". */\nconst REASONING_LADDER: readonly ThinkingLevel[] = [\"minimal\", \"low\", \"medium\", \"high\", \"xhigh\", \"max\"];\n\n/** Static rule table: task class -> recommended ThinkingLevel (before lane adjustment and clamping). */\nexport const TASK_CLASS_THINKING_LEVELS: Readonly<Record<TaskClass, ThinkingLevel>> = {\n\ttrivial: \"minimal\",\n\t\"simple-edit\": \"low\",\n\t\"code-gen\": \"medium\",\n\tdebug: \"high\",\n\trefactor: \"high\",\n\treview: \"high\",\n\tplan: \"xhigh\",\n};\n\n/** Lane adjustment in ladder steps: planner/security escalate, explorer de-escalates. */\nconst LANE_STEP: Readonly<Partial<Record<ReasoningLaneType, 1 | -1>>> = {\n\tplanner: 1,\n\tsecurity: 1,\n\texplorer: -1,\n};\n\n/**\n * Resolve the recommended ThinkingLevel for a task class:\n * 1. Look up the static rule table.\n * 2. Apply the lane adjustment (one ladder step, saturating at ladder ends).\n * 3. Clamp to the highest level in `availableLevels` that is <= the target;\n *    if no available level is at/below the target, return the lowest available\n *    reasoning level. Never invents a level outside `availableLevels`.\n *\n * `\"off\"` is never a router output for reasoning models. If `availableLevels`\n * contains no ladder level at all (e.g. a non-reasoning model exposing only\n * \"off\"), the first available level is returned; callers are expected to\n * bypass the router entirely for models with `reasoning: false`.\n */\nexport function resolveThinkingLevel(\n\ttaskClass: TaskClass,\n\tavailableLevels: readonly ThinkingLevel[],\n\tlaneType?: ReasoningLaneType,\n): ThinkingLevel {\n\tconst baseIndex = REASONING_LADDER.indexOf(TASK_CLASS_THINKING_LEVELS[taskClass]);\n\tconst step = laneType ? (LANE_STEP[laneType] ?? 0) : 0;\n\tconst targetIndex = Math.min(Math.max(baseIndex + step, 0), REASONING_LADDER.length - 1);\n\n\tconst availableOnLadder = REASONING_LADDER.filter((level) => availableLevels.includes(level));\n\tif (availableOnLadder.length === 0) {\n\t\treturn availableLevels[0] ?? \"off\";\n\t}\n\n\tfor (let i = targetIndex; i >= 0; i--) {\n\t\tconst candidate = REASONING_LADDER[i];\n\t\tif (availableOnLadder.includes(candidate)) return candidate;\n\t}\n\treturn availableOnLadder[0];\n}\n"]}

package/dist/core/reasoning-router.js

@@ -1,138 +0,0 @@
-/**
- * Reasoning-effort router: pure, side-effect-free task classification and
- * ThinkingLevel resolution for the `auto` thinking mode.
- *
- * Deterministic by construction: consumes only the prompt text and an optional
- * subagent lane type. No clock, randomness, I/O, or imports from session, TUI,
- * or provider code (the ThinkingLevel import below is type-only and erased).
- */
-/** Prompts shorter than this (trimmed) classify as trivial when no stronger signal matches. */
-const TRIVIAL_MAX_CHARS = 40;
-/** Prompts at/above this length with no keyword/code/diff signal are treated as long prose briefs (plan). */
-const COMPLEX_PROSE_MIN_CHARS = 2400;
-/**
- * Keyword families in FIXED precedence order:
- * debug > refactor > review > plan > simple-edit > code-gen.
- * The first matching family wins; ties are impossible by construction.
- * Patterns are case-insensitive and stateless (no `g` flag, so no lastIndex carry-over).
- */
-const KEYWORD_FAMILIES = [
-    {
-        taskClass: "debug",
-        pattern: /\b(debug(ging)?|bugs?|fix(es|ing|ed)?|errors?|exceptions?|crash(es|ing|ed)?|stack\s*trace|traceback|regressions?|broken|fail(s|ing|ed|ure|ures)?|flaky|reproduce)\b/i,
-    },
-    {
-        taskClass: "refactor",
-        pattern: /\b(refactor(ing|ed)?|restructur(e|ing)|renam(e|ing)|extract(ing)?|clean\s*up|cleanup|simplif(y|ying|ied)|deduplicat(e|ing)|reorganiz(e|ing)|rewrit(e|ing)|modulariz(e|ing))\b/i,
-    },
-    {
-        taskClass: "review",
-        pattern: /\b(review(s|ing|ed)?|audit(s|ing|ed)?|critique|assess(ing|ment)?|inspect(ing)?|lgtm|approve)\b/i,
-    },
-    {
-        taskClass: "plan",
-        pattern: /\b(plan(s|ning)?|design(s|ing)?|architect(s|ure|ing)?|roadmap|spec(s|ification|ifications)?|strateg(y|ies|ize)|decompos(e|ing|ition)|break\s+(this\s+|it\s+)?down|milestones?)\b/i,
-    },
-    {
-        taskClass: "simple-edit",
-        pattern: /\b(typos?|tweak(s|ing|ed)?|one-?liner?|single\s+line|bump(s|ing|ed)?|whitespace|reword(s|ing|ed)?|indentation|punctuation)\b/i,
-    },
-    {
-        taskClass: "code-gen",
-        pattern: /\b(implement(s|ing|ation)?|writ(e|ing)|creat(e|es|ing)|add(s|ing|ed)?|build(s|ing)?|generat(e|es|ing)|scaffold(ing)?|prototype)\b/i,
-    },
-];
-/** Fallback class per lane when no keyword, code/diff, or length signal decides. */
-const LANE_FALLBACK_CLASS = {
-    planner: "plan",
-    security: "review",
-    explorer: "review",
-    coder: "code-gen",
-    reviewer: "review",
-    tester: "code-gen",
-};
-function hasCodeFence(text) {
-    return text.includes("```");
-}
-/**
- * Diff detection: explicit hunk (`@@ ... @@`) or `diff --git` headers count alone;
- * bare `+`/`-` line starts only count when both added AND removed lines are present
- * (avoids false positives on markdown bullet lists).
- */
-function hasDiffMarkers(text) {
-    if (/^@@[^\n]*@@/m.test(text) || /^diff --git /m.test(text))
-        return true;
-    return /^\+(?!\+)/m.test(text) && /^-(?!-)/m.test(text);
-}
-/**
- * Classify a turn deterministically. Signal precedence (first match wins):
- * 1. Keyword families (debug > refactor > review > plan > simple-edit > code-gen)
- * 2. Code fence or diff markers -> code-gen
- * 3. Trimmed length < TRIVIAL_MAX_CHARS -> trivial
- * 4. Trimmed length >= COMPLEX_PROSE_MIN_CHARS -> plan (long prose brief)
- * 5. Lane fallback (see LANE_FALLBACK_CLASS)
- * 6. Default -> code-gen
- */
-export function classifyTask(input) {
-    const prompt = input.prompt.trim();
-    for (const family of KEYWORD_FAMILIES) {
-        if (family.pattern.test(prompt))
-            return family.taskClass;
-    }
-    if (hasCodeFence(prompt) || hasDiffMarkers(prompt))
-        return "code-gen";
-    if (prompt.length < TRIVIAL_MAX_CHARS)
-        return "trivial";
-    if (prompt.length >= COMPLEX_PROSE_MIN_CHARS)
-        return "plan";
-    if (input.laneType)
-        return LANE_FALLBACK_CLASS[input.laneType];
-    return "code-gen";
-}
-/** Reasoning ladder used for targets and clamping. Intentionally excludes "off". */
-const REASONING_LADDER = ["minimal", "low", "medium", "high", "xhigh", "max"];
-/** Static rule table: task class -> recommended ThinkingLevel (before lane adjustment and clamping). */
-export const TASK_CLASS_THINKING_LEVELS = {
-    trivial: "minimal",
-    "simple-edit": "low",
-    "code-gen": "medium",
-    debug: "high",
-    refactor: "high",
-    review: "high",
-    plan: "xhigh",
-};
-/** Lane adjustment in ladder steps: planner/security escalate, explorer de-escalates. */
-const LANE_STEP = {
-    planner: 1,
-    security: 1,
-    explorer: -1,
-};
-/**
- * Resolve the recommended ThinkingLevel for a task class:
- * 1. Look up the static rule table.
- * 2. Apply the lane adjustment (one ladder step, saturating at ladder ends).
- * 3. Clamp to the highest level in `availableLevels` that is <= the target;
- *    if no available level is at/below the target, return the lowest available
- *    reasoning level. Never invents a level outside `availableLevels`.
- *
- * `"off"` is never a router output for reasoning models. If `availableLevels`
- * contains no ladder level at all (e.g. a non-reasoning model exposing only
- * "off"), the first available level is returned; callers are expected to
- * bypass the router entirely for models with `reasoning: false`.
- */
-export function resolveThinkingLevel(taskClass, availableLevels, laneType) {
-    const baseIndex = REASONING_LADDER.indexOf(TASK_CLASS_THINKING_LEVELS[taskClass]);
-    const step = laneType ? (LANE_STEP[laneType] ?? 0) : 0;
-    const targetIndex = Math.min(Math.max(baseIndex + step, 0), REASONING_LADDER.length - 1);
-    const availableOnLadder = REASONING_LADDER.filter((level) => availableLevels.includes(level));
-    if (availableOnLadder.length === 0) {
-        return availableLevels[0] ?? "off";
-    }
-    for (let i = targetIndex; i >= 0; i--) {
-        const candidate = REASONING_LADDER[i];
-        if (availableOnLadder.includes(candidate))
-            return candidate;
-    }
-    return availableOnLadder[0];
-}
-//# sourceMappingURL=reasoning-router.js.map