@cleocode/core 2026.6.13 → 2026.6.14

package/dist/llm/complexity-classifier.d.ts

@@ -0,0 +1,208 @@
+/**
+ * L1 complexity classifier — a prompt-complexity **tier proposer** for the E9
+ * LLM chokepoint.
+ *
+ * ## What this is
+ *
+ * A faithful TypeScript port of the deleted Rust `cant-router` Layer-1
+ * classifier (`crates/cant-router/src/features.rs` + `classifier.rs`, retired
+ * in T11807 / D11137). It converts a raw prompt string into five auditable
+ * heuristic features, scores them with a fixed linear model, and maps the
+ * scalar score to a three-level complexity tier (`low` / `mid` / `high`).
+ *
+ * The classifier is a **proposer** that COMPLEMENTS — never replaces — the E9
+ * resolver {@link resolveLLMForSystem}. The flow is:
+ *
+ * ```text
+ *   classifyComplexity(prompt)  ->  ComplexityTier ('low'|'mid'|'high')
+ *   complexityTierToRole(tier)  ->  RoleName       (cheap → capable ladder)
+ *   resolveLLMForSystem({ kind:'role', id })  ->  model + credential
+ * ```
+ *
+ * So when a caller has NO explicit tier/role, it can derive one from the
+ * prompt's complexity and feed it to the chokepoint.
+ *
+ * ## What this is NOT (Gate-13 LLM Chokepoint Guard — T11783)
+ *
+ * - It NEVER constructs a transport or SDK client.
+ * - It NEVER reads `*_API_KEY` (no credential I/O at all).
+ * - It NEVER hardcodes a model-id literal. The tier→model mapping is the E9
+ *   resolver's job; this module stops at proposing a {@link RoleName}.
+ *
+ * It returns a TIER (and, via the helper, a role). The provider, model, and
+ * credential are resolved exclusively by {@link resolveLLMForSystem}.
+ *
+ * The classifier is a pure, deterministic function with no I/O and no module
+ * side effects — safe to import anywhere in the chokepoint.
+ *
+ * @module llm/complexity-classifier
+ * @task T11906
+ * @epic T11745
+ * @see {@link resolveLLMForSystem} — the E9 chokepoint this proposer feeds.
+ */
+import type { RoleName } from '@cleocode/contracts';
+/**
+ * The three-level complexity ladder proposed by {@link classifyComplexity}.
+ *
+ * Ported verbatim from the Rust `Tier` enum (`low` / `mid` / `high`, in
+ * lowercase serde rename order). It is distinct from the dispatch
+ * `Tier = 0 | 1 | 2` in `@cleocode/contracts`: this ladder describes prompt
+ * complexity, not dispatch privilege.
+ *
+ * - `low`  — fastest, cheapest models. Short, simple prompts.
+ * - `mid`  — balanced cost/latency/capability. The default workhorse.
+ * - `high` — most capable, most expensive models. Complex reasoning.
+ */
+export type ComplexityTier = 'low' | 'mid' | 'high';
+/**
+ * The five heuristic features extracted from a prompt — the inputs to the
+ * linear classifier.
+ *
+ * Each field corresponds to one of the five signals defined in the deleted
+ * Rust `PromptFeatures` struct (ULTRAPLAN §11.1). Pure heuristics, no ML
+ * runtime — each extractor is a small, auditable signal.
+ */
+export interface PromptFeatures {
+    /** Raw whitespace-delimited token count of the prompt. */
+    tokenCount: number;
+    /** Syntactic complexity in `[0.0, 1.0]` — proxied by nested bracket depth. */
+    syntacticComplexity: number;
+    /** Count of reasoning keywords (why / should / compare / decide / …). */
+    reasoningDepth: number;
+    /** Domain-specificity in `[0.0, 1.0]` — proxied by CamelCase identifier density. */
+    domainSpecificity: number;
+    /** Number of file references detected in the prompt. */
+    touchesFilesCount: number;
+}
+/**
+ * A classification result — the tier recommended for a prompt, plus the raw
+ * score and feature vector that produced it.
+ *
+ * Mirrors the deleted Rust `Classification` struct so downstream consumers can
+ * inspect the signals behind the decision.
+ */
+export interface Classification {
+    /** Scalar complexity score in `[0.0, 1.0]` produced by the weighted sum. */
+    score: number;
+    /** The tier chosen by threshold-mapping `score`. */
+    tier: ComplexityTier;
+    /** The raw feature vector that produced this classification. */
+    features: PromptFeatures;
+}
+/** Weight applied to the normalized `tokenCount` feature. */
+export declare const WEIGHT_TOKEN_COUNT = 0.15;
+/** Weight applied to the normalized `syntacticComplexity` feature. */
+export declare const WEIGHT_SYNTACTIC_COMPLEXITY = 0.25;
+/** Weight applied to the normalized `reasoningDepth` feature. */
+export declare const WEIGHT_REASONING_DEPTH = 0.3;
+/** Weight applied to the normalized `domainSpecificity` feature. */
+export declare const WEIGHT_DOMAIN_SPECIFICITY = 0.2;
+/** Weight applied to the normalized `touchesFilesCount` feature. */
+export declare const WEIGHT_TOUCHES_FILES_COUNT = 0.1;
+/** Score at or above which the classifier returns the `high` tier. */
+export declare const THRESHOLD_HIGH = 0.75;
+/**
+ * Score at or above which the classifier returns the `mid` tier.
+ *
+ * Scores strictly below this threshold are mapped to `low`.
+ */
+export declare const THRESHOLD_MID = 0.35;
+/**
+ * Extract a {@link PromptFeatures} vector from a raw prompt string.
+ *
+ * Pure heuristics, no ML runtime — the Layer-1 input stage. Each field is a
+ * small, auditable signal that feeds {@link classify}.
+ *
+ * @param prompt - The raw prompt string.
+ * @returns The five-feature vector for `prompt`.
+ *
+ * @example
+ * ```ts
+ * const f = extractFeatures('Refactor auth.ts to use JWT tokens.');
+ * f.tokenCount; // > 0
+ * ```
+ */
+export declare function extractFeatures(prompt: string): PromptFeatures;
+/**
+ * Classify a feature vector into a {@link Classification} result.
+ *
+ * Applies the linear weighted sum from ULTRAPLAN §11.1 and maps the resulting
+ * score to a tier via {@link THRESHOLD_HIGH} and {@link THRESHOLD_MID}. The
+ * input {@link PromptFeatures} is preserved so downstream consumers can inspect
+ * the raw signals that produced the decision.
+ *
+ * @param features - The five-feature vector to score.
+ * @returns The score, tier, and preserved feature vector.
+ */
+export declare function classify(features: PromptFeatures): Classification;
+/**
+ * Classify a raw prompt into a complexity {@link ComplexityTier}.
+ *
+ * The one-call entry point: `extractFeatures` → `classify` → tier. This is the
+ * **proposer** half of the L1 router — it stops at a tier and never touches a
+ * model, transport, or credential (Gate-13 compliant).
+ *
+ * @param prompt - The raw prompt string to classify.
+ * @returns The proposed complexity tier (`low` / `mid` / `high`).
+ *
+ * @example
+ * ```ts
+ * classifyComplexity('list files');                       // 'low'
+ * classifyComplexity('Why should we compare these and decide the trade-off?'); // 'mid'+
+ * ```
+ */
+export declare function classifyComplexity(prompt: string): ComplexityTier;
+/**
+ * The next tier up for escalation — ported from the Rust `Tier::escalate`.
+ *
+ * Returns `null` when already at `high`, signalling the caller that no further
+ * escalation is possible.
+ *
+ * @param tier - The current complexity tier.
+ * @returns The next tier up, or `null` at the top of the ladder.
+ */
+export declare function escalateTier(tier: ComplexityTier): ComplexityTier | null;
+/**
+ * Map a complexity {@link ComplexityTier} to the {@link RoleName} that
+ * {@link resolveLLMForSystem} should resolve when no explicit tier/role was
+ * given.
+ *
+ * This is the wiring contract (AC2) that lets a tier flow into the E9
+ * chokepoint: the classifier proposes a tier, this maps it to a role, and
+ * `resolveLLMForSystem({ kind: 'role', id })` performs the actual model +
+ * credential resolution. The mapping is a cheap → capable ladder over the
+ * canonical {@link RoleName} set — it pins NO model literal of its own.
+ *
+ * - `low`  → `hygiene`      — cheapest single-turn cleanup-class role.
+ * - `mid`  → `consolidation` — the default workhorse role.
+ * - `high` → `judgement`    — the most-capable reasoning role.
+ *
+ * @param tier - The proposed complexity tier.
+ * @returns The {@link RoleName} to feed into the E9 resolver.
+ */
+export declare function complexityTierToRole(tier: ComplexityTier): RoleName;
+/**
+ * Propose the {@link RoleName} for a raw prompt by classifying its complexity
+ * and mapping the resulting tier to a role.
+ *
+ * Convenience composition of {@link classifyComplexity} and
+ * {@link complexityTierToRole} — the single call a caller uses to derive a role
+ * for {@link resolveLLMForSystem} when it has no explicit tier/role.
+ *
+ * The returned role is intended to be passed as the structured descriptor:
+ * `resolveLLMForSystem({ kind: 'role', id: proposeRoleForPrompt(prompt) })`.
+ *
+ * @param prompt - The raw prompt string.
+ * @returns The proposed {@link RoleName} for the E9 chokepoint.
+ *
+ * @example
+ * ```ts
+ * import { proposeRoleForPrompt } from './complexity-classifier.js';
+ * import { resolveLLMForSystem } from './system-resolver.js';
+ *
+ * const role = proposeRoleForPrompt(userPrompt);
+ * const llm = await resolveLLMForSystem({ kind: 'role', id: role }, { projectRoot });
+ * ```
+ */
+export declare function proposeRoleForPrompt(prompt: string): RoleName;
+//# sourceMappingURL=complexity-classifier.d.ts.map

package/dist/llm/complexity-classifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"complexity-classifier.d.ts","sourceRoot":"","sources":["../../src/llm/complexity-classifier.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAMpD;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,cAAc,GAAG,KAAK,GAAG,KAAK,GAAG,MAAM,CAAC;AAEpD;;;;;;;GAOG;AACH,MAAM,WAAW,cAAc;IAC7B,0DAA0D;IAC1D,UAAU,EAAE,MAAM,CAAC;IACnB,8EAA8E;IAC9E,mBAAmB,EAAE,MAAM,CAAC;IAC5B,yEAAyE;IACzE,cAAc,EAAE,MAAM,CAAC;IACvB,oFAAoF;IACpF,iBAAiB,EAAE,MAAM,CAAC;IAC1B,wDAAwD;IACxD,iBAAiB,EAAE,MAAM,CAAC;CAC3B;AAED;;;;;;GAMG;AACH,MAAM,WAAW,cAAc;IAC7B,4EAA4E;IAC5E,KAAK,EAAE,MAAM,CAAC;IACd,oDAAoD;IACpD,IAAI,EAAE,cAAc,CAAC;IACrB,gEAAgE;IAChE,QAAQ,EAAE,cAAc,CAAC;CAC1B;AAMD,6DAA6D;AAC7D,eAAO,MAAM,kBAAkB,OAAO,CAAC;AAEvC,sEAAsE;AACtE,eAAO,MAAM,2BAA2B,OAAO,CAAC;AAEhD,iEAAiE;AACjE,eAAO,MAAM,sBAAsB,MAAM,CAAC;AAE1C,oEAAoE;AACpE,eAAO,MAAM,yBAAyB,MAAM,CAAC;AAE7C,oEAAoE;AACpE,eAAO,MAAM,0BAA0B,MAAM,CAAC;AAE9C,sEAAsE;AACtE,eAAO,MAAM,cAAc,OAAO,CAAC;AAEnC;;;;GAIG;AACH,eAAO,MAAM,aAAa,OAAO,CAAC;AA2IlC;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,cAAc,CAQ9D;AAyCD;;;;;;;;;;GAUG;AACH,wBAAgB,QAAQ,CAAC,QAAQ,EAAE,cAAc,GAAG,cAAc,CAajE;AAMD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,GAAG,cAAc,CAEjE;AAED;;;;;;;;GAQG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,cAAc,GAAG,cAAc,GAAG,IAAI,CASxE;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,cAAc,GAAG,QAAQ,CASnE;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,GAAG,QAAQ,CAE7D"}

package/dist/llm/complexity-classifier.js

@@ -0,0 +1,359 @@
+/**
+ * L1 complexity classifier — a prompt-complexity **tier proposer** for the E9
+ * LLM chokepoint.
+ *
+ * ## What this is
+ *
+ * A faithful TypeScript port of the deleted Rust `cant-router` Layer-1
+ * classifier (`crates/cant-router/src/features.rs` + `classifier.rs`, retired
+ * in T11807 / D11137). It converts a raw prompt string into five auditable
+ * heuristic features, scores them with a fixed linear model, and maps the
+ * scalar score to a three-level complexity tier (`low` / `mid` / `high`).
+ *
+ * The classifier is a **proposer** that COMPLEMENTS — never replaces — the E9
+ * resolver {@link resolveLLMForSystem}. The flow is:
+ *
+ * ```text
+ *   classifyComplexity(prompt)  ->  ComplexityTier ('low'|'mid'|'high')
+ *   complexityTierToRole(tier)  ->  RoleName       (cheap → capable ladder)
+ *   resolveLLMForSystem({ kind:'role', id })  ->  model + credential
+ * ```
+ *
+ * So when a caller has NO explicit tier/role, it can derive one from the
+ * prompt's complexity and feed it to the chokepoint.
+ *
+ * ## What this is NOT (Gate-13 LLM Chokepoint Guard — T11783)
+ *
+ * - It NEVER constructs a transport or SDK client.
+ * - It NEVER reads `*_API_KEY` (no credential I/O at all).
+ * - It NEVER hardcodes a model-id literal. The tier→model mapping is the E9
+ *   resolver's job; this module stops at proposing a {@link RoleName}.
+ *
+ * It returns a TIER (and, via the helper, a role). The provider, model, and
+ * credential are resolved exclusively by {@link resolveLLMForSystem}.
+ *
+ * The classifier is a pure, deterministic function with no I/O and no module
+ * side effects — safe to import anywhere in the chokepoint.
+ *
+ * @module llm/complexity-classifier
+ * @task T11906
+ * @epic T11745
+ * @see {@link resolveLLMForSystem} — the E9 chokepoint this proposer feeds.
+ */
+// ---------------------------------------------------------------------------
+// Classifier weights + thresholds (ULTRAPLAN §11.1 — ported from classifier.rs)
+// ---------------------------------------------------------------------------
+/** Weight applied to the normalized `tokenCount` feature. */
+export const WEIGHT_TOKEN_COUNT = 0.15;
+/** Weight applied to the normalized `syntacticComplexity` feature. */
+export const WEIGHT_SYNTACTIC_COMPLEXITY = 0.25;
+/** Weight applied to the normalized `reasoningDepth` feature. */
+export const WEIGHT_REASONING_DEPTH = 0.3;
+/** Weight applied to the normalized `domainSpecificity` feature. */
+export const WEIGHT_DOMAIN_SPECIFICITY = 0.2;
+/** Weight applied to the normalized `touchesFilesCount` feature. */
+export const WEIGHT_TOUCHES_FILES_COUNT = 0.1;
+/** Score at or above which the classifier returns the `high` tier. */
+export const THRESHOLD_HIGH = 0.75;
+/**
+ * Score at or above which the classifier returns the `mid` tier.
+ *
+ * Scores strictly below this threshold are mapped to `low`.
+ */
+export const THRESHOLD_MID = 0.35;
+// ---------------------------------------------------------------------------
+// Feature extraction (ported from features.rs — five pure heuristics)
+// ---------------------------------------------------------------------------
+/**
+ * Estimate syntactic complexity by counting nested bracket depth.
+ *
+ * Walks the string once tracking the running depth of `(`, `{`, `[` (and their
+ * matching closers). The maximum depth observed is divided by 5 and clamped to
+ * `[0.0, 1.0]`, so a prompt with no brackets scores 0 and one with 5+ nested
+ * brackets scores 1.
+ *
+ * @param s - The raw prompt string.
+ * @returns A syntactic-complexity score in `[0.0, 1.0]`.
+ */
+function estimateSyntacticComplexity(s) {
+    let depth = 0;
+    let maxDepth = 0;
+    for (const c of s) {
+        if (c === '(' || c === '{' || c === '[') {
+            depth += 1;
+            if (depth > maxDepth)
+                maxDepth = depth;
+        }
+        else if (c === ')' || c === '}' || c === ']') {
+            depth = Math.max(depth - 1, 0);
+        }
+    }
+    return Math.min(maxDepth / 5.0, 1.0);
+}
+/**
+ * Reasoning-signal keywords — terms that correlate with multi-step reasoning.
+ *
+ * Intentionally short and biased; ported verbatim from the Rust `KEYWORDS`
+ * slice in `count_reasoning_keywords`.
+ */
+const REASONING_KEYWORDS = [
+    'why',
+    'should',
+    'compare',
+    'decide',
+    'explain',
+    'analyze',
+    'evaluate',
+    'consider',
+    'trade-off',
+    'tradeoff',
+];
+/**
+ * Count reasoning-signal keyword occurrences in the prompt (case-insensitive,
+ * counting every (possibly overlapping-free) occurrence, matching the Rust
+ * `str::matches` semantics).
+ *
+ * @param s - The raw prompt string.
+ * @returns The total number of reasoning-keyword occurrences.
+ */
+function countReasoningKeywords(s) {
+    const lower = s.toLowerCase();
+    let total = 0;
+    for (const keyword of REASONING_KEYWORDS) {
+        let from = 0;
+        for (;;) {
+            const idx = lower.indexOf(keyword, from);
+            if (idx === -1)
+                break;
+            total += 1;
+            // Rust's `str::matches` advances past each non-overlapping match.
+            from = idx + keyword.length;
+        }
+    }
+    return total;
+}
+/**
+ * Count the uppercase characters in a token (used by the CamelCase proxy).
+ *
+ * @param w - A single whitespace-delimited token.
+ * @returns The number of uppercase characters in `w`.
+ */
+function uppercaseCount(w) {
+    let n = 0;
+    for (const c of w) {
+        // An uppercase letter is one that differs from its lowercase form and equals
+        // its own uppercase form (excludes digits/punctuation, mirroring Rust's
+        // `char::is_uppercase`).
+        if (c !== c.toLowerCase() && c === c.toUpperCase())
+            n += 1;
+    }
+    return n;
+}
+/**
+ * Estimate domain specificity via CamelCase identifier density.
+ *
+ * Counts whitespace-delimited tokens containing at least two uppercase letters
+ * (a rough proxy for domain-specific identifiers like `ModelSelection` or
+ * `XDGBaseDir`). The count is divided by 10 and clamped to `[0.0, 1.0]`.
+ *
+ * @param s - The raw prompt string.
+ * @returns A domain-specificity score in `[0.0, 1.0]`.
+ */
+function estimateDomainSpecificity(s) {
+    const camelCaseCount = splitWhitespace(s).filter((w) => uppercaseCount(w) >= 2).length;
+    return Math.min(camelCaseCount / 10.0, 1.0);
+}
+/**
+ * Count file references in the prompt.
+ *
+ * A token is a file reference if it contains a `/` or ends in a known
+ * source-file extension (`.rs`, `.ts`, `.md`, `.json`). Punctuation on the
+ * token is left intact for v1 — callers aware of this limitation can pre-clean
+ * their prompts.
+ *
+ * @param s - The raw prompt string.
+ * @returns The number of file-reference tokens.
+ */
+function countFileReferences(s) {
+    return splitWhitespace(s).filter((w) => w.includes('/') ||
+        w.endsWith('.rs') ||
+        w.endsWith('.ts') ||
+        w.endsWith('.md') ||
+        w.endsWith('.json')).length;
+}
+/**
+ * Split a string on Unicode whitespace, dropping empty segments — matching
+ * Rust's `str::split_whitespace` (which never yields empty tokens).
+ *
+ * @param s - The string to split.
+ * @returns The non-empty whitespace-delimited tokens of `s`.
+ */
+function splitWhitespace(s) {
+    return s.split(/\s+/).filter((w) => w.length > 0);
+}
+/**
+ * Extract a {@link PromptFeatures} vector from a raw prompt string.
+ *
+ * Pure heuristics, no ML runtime — the Layer-1 input stage. Each field is a
+ * small, auditable signal that feeds {@link classify}.
+ *
+ * @param prompt - The raw prompt string.
+ * @returns The five-feature vector for `prompt`.
+ *
+ * @example
+ * ```ts
+ * const f = extractFeatures('Refactor auth.ts to use JWT tokens.');
+ * f.tokenCount; // > 0
+ * ```
+ */
+export function extractFeatures(prompt) {
+    return {
+        tokenCount: splitWhitespace(prompt).length,
+        syntacticComplexity: estimateSyntacticComplexity(prompt),
+        reasoningDepth: countReasoningKeywords(prompt),
+        domainSpecificity: estimateDomainSpecificity(prompt),
+        touchesFilesCount: countFileReferences(prompt),
+    };
+}
+/**
+ * Clamp a value to `[lo, hi]` — equivalent to Rust's `f64::clamp`. Returns `lo`
+ * for `NaN`, matching the saturating intent of the original normalizers.
+ */
+function clamp(value, lo, hi) {
+    if (Number.isNaN(value))
+        return lo;
+    return Math.min(Math.max(value, lo), hi);
+}
+/**
+ * Normalize each feature to `[0.0, 1.0]` for the weighted sum.
+ *
+ * These normalization constants are the heuristic v1 defaults tuned against
+ * the ULTRAPLAN §11.1 example ranges (not a labeled corpus). Ported verbatim
+ * from the Rust `normalize_features`.
+ */
+function normalizeFeatures(f) {
+    return {
+        tokenCount: Math.min(f.tokenCount / 1000.0, 1.0),
+        syntacticComplexity: clamp(f.syntacticComplexity, 0.0, 1.0),
+        reasoningDepth: Math.min(f.reasoningDepth / 10.0, 1.0),
+        domainSpecificity: clamp(f.domainSpecificity, 0.0, 1.0),
+        touchesFilesCount: Math.min(f.touchesFilesCount / 20.0, 1.0),
+    };
+}
+/**
+ * Classify a feature vector into a {@link Classification} result.
+ *
+ * Applies the linear weighted sum from ULTRAPLAN §11.1 and maps the resulting
+ * score to a tier via {@link THRESHOLD_HIGH} and {@link THRESHOLD_MID}. The
+ * input {@link PromptFeatures} is preserved so downstream consumers can inspect
+ * the raw signals that produced the decision.
+ *
+ * @param features - The five-feature vector to score.
+ * @returns The score, tier, and preserved feature vector.
+ */
+export function classify(features) {
+    const normalized = normalizeFeatures(features);
+    const score = WEIGHT_TOKEN_COUNT * normalized.tokenCount +
+        WEIGHT_SYNTACTIC_COMPLEXITY * normalized.syntacticComplexity +
+        WEIGHT_REASONING_DEPTH * normalized.reasoningDepth +
+        WEIGHT_DOMAIN_SPECIFICITY * normalized.domainSpecificity +
+        WEIGHT_TOUCHES_FILES_COUNT * normalized.touchesFilesCount;
+    const tier = score >= THRESHOLD_HIGH ? 'high' : score >= THRESHOLD_MID ? 'mid' : 'low';
+    return { score, tier, features };
+}
+// ---------------------------------------------------------------------------
+// Public proposer API
+// ---------------------------------------------------------------------------
+/**
+ * Classify a raw prompt into a complexity {@link ComplexityTier}.
+ *
+ * The one-call entry point: `extractFeatures` → `classify` → tier. This is the
+ * **proposer** half of the L1 router — it stops at a tier and never touches a
+ * model, transport, or credential (Gate-13 compliant).
+ *
+ * @param prompt - The raw prompt string to classify.
+ * @returns The proposed complexity tier (`low` / `mid` / `high`).
+ *
+ * @example
+ * ```ts
+ * classifyComplexity('list files');                       // 'low'
+ * classifyComplexity('Why should we compare these and decide the trade-off?'); // 'mid'+
+ * ```
+ */
+export function classifyComplexity(prompt) {
+    return classify(extractFeatures(prompt)).tier;
+}
+/**
+ * The next tier up for escalation — ported from the Rust `Tier::escalate`.
+ *
+ * Returns `null` when already at `high`, signalling the caller that no further
+ * escalation is possible.
+ *
+ * @param tier - The current complexity tier.
+ * @returns The next tier up, or `null` at the top of the ladder.
+ */
+export function escalateTier(tier) {
+    switch (tier) {
+        case 'low':
+            return 'mid';
+        case 'mid':
+            return 'high';
+        case 'high':
+            return null;
+    }
+}
+/**
+ * Map a complexity {@link ComplexityTier} to the {@link RoleName} that
+ * {@link resolveLLMForSystem} should resolve when no explicit tier/role was
+ * given.
+ *
+ * This is the wiring contract (AC2) that lets a tier flow into the E9
+ * chokepoint: the classifier proposes a tier, this maps it to a role, and
+ * `resolveLLMForSystem({ kind: 'role', id })` performs the actual model +
+ * credential resolution. The mapping is a cheap → capable ladder over the
+ * canonical {@link RoleName} set — it pins NO model literal of its own.
+ *
+ * - `low`  → `hygiene`      — cheapest single-turn cleanup-class role.
+ * - `mid`  → `consolidation` — the default workhorse role.
+ * - `high` → `judgement`    — the most-capable reasoning role.
+ *
+ * @param tier - The proposed complexity tier.
+ * @returns The {@link RoleName} to feed into the E9 resolver.
+ */
+export function complexityTierToRole(tier) {
+    switch (tier) {
+        case 'low':
+            return 'hygiene';
+        case 'mid':
+            return 'consolidation';
+        case 'high':
+            return 'judgement';
+    }
+}
+/**
+ * Propose the {@link RoleName} for a raw prompt by classifying its complexity
+ * and mapping the resulting tier to a role.
+ *
+ * Convenience composition of {@link classifyComplexity} and
+ * {@link complexityTierToRole} — the single call a caller uses to derive a role
+ * for {@link resolveLLMForSystem} when it has no explicit tier/role.
+ *
+ * The returned role is intended to be passed as the structured descriptor:
+ * `resolveLLMForSystem({ kind: 'role', id: proposeRoleForPrompt(prompt) })`.
+ *
+ * @param prompt - The raw prompt string.
+ * @returns The proposed {@link RoleName} for the E9 chokepoint.
+ *
+ * @example
+ * ```ts
+ * import { proposeRoleForPrompt } from './complexity-classifier.js';
+ * import { resolveLLMForSystem } from './system-resolver.js';
+ *
+ * const role = proposeRoleForPrompt(userPrompt);
+ * const llm = await resolveLLMForSystem({ kind: 'role', id: role }, { projectRoot });
+ * ```
+ */
+export function proposeRoleForPrompt(prompt) {
+    return complexityTierToRole(classifyComplexity(prompt));
+}
+//# sourceMappingURL=complexity-classifier.js.map

package/dist/llm/complexity-classifier.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"complexity-classifier.js","sourceRoot":"","sources":["../../src/llm/complexity-classifier.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AA2DH,8EAA8E;AAC9E,gFAAgF;AAChF,8EAA8E;AAE9E,6DAA6D;AAC7D,MAAM,CAAC,MAAM,kBAAkB,GAAG,IAAI,CAAC;AAEvC,sEAAsE;AACtE,MAAM,CAAC,MAAM,2BAA2B,GAAG,IAAI,CAAC;AAEhD,iEAAiE;AACjE,MAAM,CAAC,MAAM,sBAAsB,GAAG,GAAG,CAAC;AAE1C,oEAAoE;AACpE,MAAM,CAAC,MAAM,yBAAyB,GAAG,GAAG,CAAC;AAE7C,oEAAoE;AACpE,MAAM,CAAC,MAAM,0BAA0B,GAAG,GAAG,CAAC;AAE9C,sEAAsE;AACtE,MAAM,CAAC,MAAM,cAAc,GAAG,IAAI,CAAC;AAEnC;;;;GAIG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,IAAI,CAAC;AAElC,8EAA8E;AAC9E,sEAAsE;AACtE,8EAA8E;AAE9E;;;;;;;;;;GAUG;AACH,SAAS,2BAA2B,CAAC,CAAS;IAC5C,IAAI,KAAK,GAAG,CAAC,CAAC;IACd,IAAI,QAAQ,GAAG,CAAC,CAAC;IACjB,KAAK,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC;QAClB,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,GAAG,EAAE,CAAC;YACxC,KAAK,IAAI,CAAC,CAAC;YACX,IAAI,KAAK,GAAG,QAAQ;gBAAE,QAAQ,GAAG,KAAK,CAAC;QACzC,CAAC;aAAM,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,GAAG,EAAE,CAAC;YAC/C,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,KAAK,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC;QACjC,CAAC;IACH,CAAC;IACD,OAAO,IAAI,CAAC,GAAG,CAAC,QAAQ,GAAG,GAAG,EAAE,GAAG,CAAC,CAAC;AACvC,CAAC;AAED;;;;;GAKG;AACH,MAAM,kBAAkB,GAAsB;IAC5C,KAAK;IACL,QAAQ;IACR,SAAS;IACT,QAAQ;IACR,SAAS;IACT,SAAS;IACT,UAAU;IACV,UAAU;IACV,WAAW;IACX,UAAU;CACX,CAAC;AAEF;;;;;;;GAOG;AACH,SAAS,sBAAsB,CAAC,CAAS;IACvC,MAAM,KAAK,GAAG,CAAC,CAAC,WAAW,EAAE,CAAC;IAC9B,IAAI,KAAK,GAAG,CAAC,CAAC;IACd,KAAK,MAAM,OAAO,IAAI,kBAAkB,EAAE,CAAC;QACzC,IAAI,IAAI,GAAG,CAAC,CAAC;QACb,SAAS,CAAC;YACR,MAAM,GAAG,GAAG,KAAK,CAAC,OAAO,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;YACzC,IAAI,GAAG,KAAK,CAAC,CAAC;gBAAE,MAAM;YACtB,KAAK,IAAI,CAAC,CAAC;YACX,kEAAkE;YAClE,IAAI,GAAG,GAAG,GAAG,OAAO,CAAC,MAAM,CAAC;QAC9B,CAAC;IACH,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;;;GAKG;AACH,SAAS,cAAc,CAAC,CAAS;IAC/B,IAAI,CAAC,GAAG,CAAC,CAAC;IACV,KAAK,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC;QAClB,6EAA6E;QAC7E,wEAAwE;QACxE,yBAAyB;QACzB,IAAI,CAAC,KAAK,CAAC,CAAC,WAAW,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,WAAW,EAAE;YAAE,CAAC,IAAI,CAAC,CAAC;IAC7D,CAAC;IACD,OAAO,CAAC,CAAC;AACX,CAAC;AAED;;;;;;;;;GASG;AACH,SAAS,yBAAyB,CAAC,CAAS;IAC1C,MAAM,cAAc,GAAG,eAAe,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,cAAc,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC;IACvF,OAAO,IAAI,CAAC,GAAG,CAAC,cAAc,GAAG,IAAI,EAAE,GAAG,CAAC,CAAC;AAC9C,CAAC;AAED;;;;;;;;;;GAUG;AACH,SAAS,mBAAmB,CAAC,CAAS;IACpC,OAAO,eAAe,CAAC,CAAC,CAAC,CAAC,MAAM,CAC9B,CAAC,CAAC,EAAE,EAAE,CACJ,CAAC,CAAC,QAAQ,CAAC,GAAG,CAAC;QACf,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC;QACjB,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC;QACjB,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC;QACjB,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC,CACtB,CAAC,MAAM,CAAC;AACX,CAAC;AAED;;;;;;GAMG;AACH,SAAS,eAAe,CAAC,CAAS;IAChC,OAAO,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;AACpD,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,eAAe,CAAC,MAAc;IAC5C,OAAO;QACL,UAAU,EAAE,eAAe,CAAC,MAAM,CAAC,CAAC,MAAM;QAC1C,mBAAmB,EAAE,2BAA2B,CAAC,MAAM,CAAC;QACxD,cAAc,EAAE,sBAAsB,CAAC,MAAM,CAAC;QAC9C,iBAAiB,EAAE,yBAAyB,CAAC,MAAM,CAAC;QACpD,iBAAiB,EAAE,mBAAmB,CAAC,MAAM,CAAC;KAC/C,CAAC;AACJ,CAAC;AAeD;;;GAGG;AACH,SAAS,KAAK,CAAC,KAAa,EAAE,EAAU,EAAE,EAAU;IAClD,IAAI,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC;QAAE,OAAO,EAAE,CAAC;IACnC,OAAO,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,EAAE,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC;AAC3C,CAAC;AAED;;;;;;GAMG;AACH,SAAS,iBAAiB,CAAC,CAAiB;IAC1C,OAAO;QACL,UAAU,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,UAAU,GAAG,MAAM,EAAE,GAAG,CAAC;QAChD,mBAAmB,EAAE,KAAK,CAAC,CAAC,CAAC,mBAAmB,EAAE,GAAG,EAAE,GAAG,CAAC;QAC3D,cAAc,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,cAAc,GAAG,IAAI,EAAE,GAAG,CAAC;QACtD,iBAAiB,EAAE,KAAK,CAAC,CAAC,CAAC,iBAAiB,EAAE,GAAG,EAAE,GAAG,CAAC;QACvD,iBAAiB,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,iBAAiB,GAAG,IAAI,EAAE,GAAG,CAAC;KAC7D,CAAC;AACJ,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,UAAU,QAAQ,CAAC,QAAwB;IAC/C,MAAM,UAAU,GAAG,iBAAiB,CAAC,QAAQ,CAAC,CAAC;IAC/C,MAAM,KAAK,GACT,kBAAkB,GAAG,UAAU,CAAC,UAAU;QAC1C,2BAA2B,GAAG,UAAU,CAAC,mBAAmB;QAC5D,sBAAsB,GAAG,UAAU,CAAC,cAAc;QAClD,yBAAyB,GAAG,UAAU,CAAC,iBAAiB;QACxD,0BAA0B,GAAG,UAAU,CAAC,iBAAiB,CAAC;IAE5D,MAAM,IAAI,GACR,KAAK,IAAI,cAAc,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,IAAI,aAAa,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC;IAE5E,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC;AACnC,CAAC;AAED,8EAA8E;AAC9E,sBAAsB;AACtB,8EAA8E;AAE9E;;;;;;;;;;;;;;;GAeG;AACH,MAAM,UAAU,kBAAkB,CAAC,MAAc;IAC/C,OAAO,QAAQ,CAAC,eAAe,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC;AAChD,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,YAAY,CAAC,IAAoB;IAC/C,QAAQ,IAAI,EAAE,CAAC;QACb,KAAK,KAAK;YACR,OAAO,KAAK,CAAC;QACf,KAAK,KAAK;YACR,OAAO,MAAM,CAAC;QAChB,KAAK,MAAM;YACT,OAAO,IAAI,CAAC;IAChB,CAAC;AACH,CAAC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,UAAU,oBAAoB,CAAC,IAAoB;IACvD,QAAQ,IAAI,EAAE,CAAC;QACb,KAAK,KAAK;YACR,OAAO,SAAS,CAAC;QACnB,KAAK,KAAK;YACR,OAAO,eAAe,CAAC;QACzB,KAAK,MAAM;YACT,OAAO,WAAW,CAAC;IACvB,CAAC;AACH,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,UAAU,oBAAoB,CAAC,MAAc;IACjD,OAAO,oBAAoB,CAAC,kBAAkB,CAAC,MAAM,CAAC,CAAC,CAAC;AAC1D,CAAC"}

package/dist/llm/credential-pool.d.ts

@@ -243,7 +243,9 @@ export declare class CredentialPool {
      * @param existing      - Credential entry to refresh.
      * @param tokenEndpoint - Provider token endpoint URL.
      * @param clientId      - OAuth client ID.
+     * @param bodyFormat    - Token request body encoding (`'json'` for Anthropic).
      * @task T9302
+     * @task T11958
      */
     private _refreshViaPkce;
     /**

package/dist/llm/credential-pool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"credential-pool.d.ts","sourceRoot":"","sources":["../../src/llm/credential-pool.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"credential-pool.d.ts","sourceRoot":"","sources":["../../src/llm/credential-pool.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAGH,OAAO,EAEL,KAAK,gBAAgB,EAEtB,MAAM,+BAA+B,CAAC;AACvC,OAAO,KAAK,EAAE,wBAAwB,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAWzF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AA8BxD;;;;;;;;GAQG;AACH,MAAM,MAAM,YAAY,GAAG,YAAY,GAAG,aAAa,GAAG,YAAY,CAAC;AAEvE;;;;GAIG;AACH,MAAM,WAAW,eAAe;IAC9B,8DAA8D;IAC9D,QAAQ,CAAC,EAAE,YAAY,CAAC;CACzB;AAED;;;;GAIG;AACH,MAAM,WAAW,cAAc;IAC7B,qCAAqC;IACrC,UAAU,EAAE,gBAAgB,CAAC;IAC7B,8DAA8D;IAC9D,QAAQ,EAAE,MAAM,CAAC;CAClB;AAMD;;;;;;;;GAQG;AACH,qBAAa,kBAAmB,SAAQ,KAAK;aAWzB,QAAQ,EAAE,cAAc;aACxB,QAAQ,EAAE,MAAM;aAChB,UAAU,EAAE,MAAM;IAZpC,8BAA8B;IAC9B,QAAQ,CAAC,IAAI,0BAA0B;IAEvC;;;;;OAKG;gBAEe,QAAQ,EAAE,cAAc,EACxB,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,MAAM;CAQrC;AA2DD;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,qBAAa,cAAc;IAUb,OAAO,CAAC,QAAQ,CAAC,QAAQ;IATrC;;;OAGG;IACH,OAAO,CAAC,QAAQ,CAAK;IAErB;;OAEG;gBAC0B,QAAQ,EAAE,cAAc;IAMrD;;;;;;;;;;;;OAYG;IACG,IAAI,CAAC,IAAI,CAAC,EAAE,eAAe,GAAG,OAAO,CAAC,cAAc,CAAC;IA+D3D;;;;;;;;;;;;;;;OAeG;IACG,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAapE;;;;;;;OAOG;IACG,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAY1C;;;;;;;;;;;;;;;;;;;;OAoBG;IACG,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAoBvD;;;;;;;;;;;;;;;OAeG;IACG,mBAAmB,IAAI,OAAO,CAAC,MAAM,CAAC;IAiB5C;;;;;;;;;;OAUG;IACG,WAAW,IAAI,OAAO,CAAC,SAAS,gBAAgB,EAAE,CAAC;IASzD;;;;;;;;;;;;;;OAcG;YACW,uBAAuB;IAmBrC;;;;;;;;;;;;OAYG;YACW,eAAe;IAiC7B;;;;;;;;;;;;OAYG;YACW,wBAAwB;IA0DtC;;;;;;;;;;OAUG;IACH,OAAO,CAAC,cAAc;IAKtB;;;;;;;;;;;;OAYG;IACH,OAAO,CAAC,eAAe;IAgBvB;;;;;;;;OAQG;IACH,OAAO,CAAC,cAAc;CAWvB;AA4BD;;;;;;;;GAQG;AACH,eAAO,MAAM,sBAAsB,QAAa,CAAC;AAEjD;;;;;;;GAOG;AACH,MAAM,WAAW,YAAY;IAC3B,iDAAiD;IACjD,QAAQ,EAAE,MAAM,CAAC;IACjB,qDAAqD;IACrD,QAAQ,EAAE,MAAM,CAAC;IACjB,4EAA4E;IAC5E,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,6CAA6C;IAC7C,UAAU,EAAE,IAAI,GAAG,QAAQ,GAAG,iBAAiB,GAAG,oBAAoB,CAAC;IACvE,+DAA+D;IAC/D,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,oDAAoD;IACpD,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;;;GAIG;AACH,MAAM,WAAW,cAAc;IAC7B,kEAAkE;IAClE,KAAK,EAAE,MAAM,CAAC;IACd,2DAA2D;IAC3D,MAAM,EAAE,MAAM,CAAC;IACf,sEAAsE;IACtE,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,sBAAsB;IACrC,6CAA6C;IAC7C,QAAQ,CAAC,EAAE,wBAAwB,CAAC;IACpC,oEAAoE;IACpE,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,4EAA4E;IAC5E,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAmBD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,qBAAa,qBAAqB;IAoB9B,OAAO,CAAC,QAAQ,CAAC,cAAc;IAnBjC,kEAAkE;IAClE,OAAO,CAAC,YAAY,CAAK;IAEzB,kEAAkE;IAClE,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAmC;IAEhE;;;;;;;;;;;OAWG;gBAEgB,cAAc,GAAE,MAAM,SAAS,gBAAgB,EACtC;IAG5B;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACG,IAAI,CAAC,OAAO,GAAE;QAAE,KAAK,CAAC,EAAE,OAAO,CAAA;KAAO,GAAG,OAAO,CAAC,cAAc,CAAC;IA8ItE;;;;;;;;;;;;;;OAcG;IACG,IAAI,CACR,QAAQ,EAAE,cAAc,EACxB,OAAO,GAAE,sBAA2B,GACnC,OAAO,CAAC,gBAAgB,GAAG,IAAI,CAAC;IAUnC;;;;;;;;;OASG;IACG,IAAI,IAAI,OAAO,CAAC,SAAS,gBAAgB,EAAE,CAAC;IAIlD;;;;;;;OAOG;IACH,eAAe,IAAI,SAAS,YAAY,EAAE;IAI1C;;;;;;;;;OASG;IACH,cAAc,IAAI,IAAI;CAIvB;AAgBD;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,IAAI,qBAAqB,CAKzD;AAED;;;;;;;;GAQG;AACH,wBAAgB,qCAAqC,IAAI,IAAI,CAE5D"}

package/dist/llm/credential-pool.js

@@ -418,7 +418,7 @@ export class CredentialPool {
         const profile = await getProviderProfile(this.provider);
         const oauthCfg = profile?.oauth;
         if (oauthCfg?.mode === 'pkce') {
-            await this._refreshViaPkce(existing, oauthCfg.tokenEndpoint, oauthCfg.clientId);
+            await this._refreshViaPkce(existing, oauthCfg.tokenEndpoint, oauthCfg.clientId, oauthCfg.tokenBodyFormat);
         }
         else if (this.provider === 'kimi-code') {
             const cfg = getKimiCodeDeviceCodeConfig();
@@ -434,9 +434,11 @@ export class CredentialPool {
      * @param existing      - Credential entry to refresh.
      * @param tokenEndpoint - Provider token endpoint URL.
      * @param clientId      - OAuth client ID.
+     * @param bodyFormat    - Token request body encoding (`'json'` for Anthropic).
      * @task T9302
+     * @task T11958
      */
-    async _refreshViaPkce(existing, tokenEndpoint, clientId) {
+    async _refreshViaPkce(existing, tokenEndpoint, clientId, bodyFormat) {
         if (!existing.refreshToken)
             return;
         let tokens;
@@ -446,6 +448,7 @@ export class CredentialPool {
                 clientId,
                 refreshToken: existing.refreshToken,
                 tokenEndpoint,
+                bodyFormat,
             });
         }
         catch {