@swarmdo/cli 1.4.8

package/dist/src/swarmvector/model-prices.js

@@ -0,0 +1,72 @@
+/**
+ * model-prices.ts — Single source of truth for per-model pricing.
+ *
+ * Iter 31 — Previously the price table existed in three scripts (train-
+ * bundled-krr.mjs, auto-retrain-router.mjs, calibration-check.mjs) AND was
+ * derived from the openrouter-alts.json sidecar for the bundled list. As
+ * cost-aware features land (trajectory outcomes, cost-savings observability,
+ * cost-ceiling routing), they need ONE canonical price lookup. This module
+ * is it.
+ *
+ * Prices are blended ($/Mtok) using a 1×input + 3×output mix, reflecting
+ * the average input/output token ratio for code tasks. To compute spend
+ * for a specific call:
+ *
+ *   const usd = costUsd(modelId, inputTokens, outputTokens);
+ *
+ * Unknown model ids fall back to a conservative $1/Mtok blended estimate
+ * so callers always get a number (cost-tracking doesn't silently drop).
+ *
+ * Source: OpenRouter price page snapshot, ADR-149 bench dates.
+ *
+ * @module model-prices
+ */
+/**
+ * Curated price table. Keys are concrete model ids matching either
+ * OpenRouter slugs or Anthropic SDK ids that the cost-optimal router can
+ * choose. New models added via the registry sidecar should be reflected
+ * here AS THEY ARE ADDED (no auto-sync); see ADR-149.
+ */
+export const MODEL_PRICES = {
+    // Cheap tier
+    'inclusionai/ling-2.6-flash': { in: 0.01, out: 0.03 },
+    'google/gemini-2.5-flash-lite': { in: 0.10, out: 0.40 },
+    'meta-llama/llama-3.3-70b-instruct': { in: 0.13, out: 0.40 },
+    // Mid tier
+    'anthropic/claude-haiku-4.5': { in: 1.00, out: 5.00 },
+    'openai/gpt-4.1': { in: 2.00, out: 8.00 },
+    // Strong tier
+    'anthropic/claude-sonnet-4-6': { in: 3.00, out: 15.00 },
+    'anthropic/claude-opus-4': { in: 15.00, out: 75.00 },
+    // Tier-label fallbacks (when the trajectory only carries a coarse tier
+    // and not a concrete modelId — happens before iter 13 wiring landed).
+    haiku: { in: 1.00, out: 5.00 },
+    sonnet: { in: 3.00, out: 15.00 },
+    opus: { in: 15.00, out: 75.00 },
+    inherit: { in: 3.00, out: 15.00 },
+};
+/**
+ * Blended $/Mtok using the 1× input + 3× output ratio. Used by the KRR
+ * trainer (scripts/train-bundled-krr.mjs and others) as the cost feature
+ * the cost-optimal selector divides quality by.
+ */
+export function blendedPrice(modelId) {
+    const p = MODEL_PRICES[modelId] ?? { in: 1.0, out: 1.0 };
+    return p.in + 3 * p.out;
+}
+/**
+ * Compute USD spend for a single call. Cost = (input × $/Mtok_in +
+ * output × $/Mtok_out) / 1_000_000.
+ *
+ * Returns 0 on missing usage and falls back to a conservative blended
+ * estimate when the model is unknown — never returns undefined.
+ */
+export function costUsd(modelId, inputTokens, outputTokens) {
+    if (!inputTokens && !outputTokens)
+        return 0;
+    const p = (modelId ? MODEL_PRICES[modelId] : undefined) ?? { in: 1.0, out: 1.0 };
+    const inT = inputTokens ?? 0;
+    const outT = outputTokens ?? 0;
+    return (inT * p.in + outT * p.out) / 1_000_000;
+}
+//# sourceMappingURL=model-prices.js.map

package/dist/src/swarmvector/model-prices.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"model-prices.js","sourceRoot":"","sources":["../../../src/swarmvector/model-prices.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAQH;;;;;GAKG;AACH,MAAM,CAAC,MAAM,YAAY,GAA+B;IACtD,aAAa;IACb,4BAA4B,EAAU,EAAE,EAAE,EAAE,IAAI,EAAG,GAAG,EAAE,IAAI,EAAE;IAC9D,8BAA8B,EAAQ,EAAE,EAAE,EAAE,IAAI,EAAG,GAAG,EAAE,IAAI,EAAE;IAC9D,mCAAmC,EAAG,EAAE,EAAE,EAAE,IAAI,EAAG,GAAG,EAAE,IAAI,EAAE;IAC9D,WAAW;IACX,4BAA4B,EAAU,EAAE,EAAE,EAAE,IAAI,EAAG,GAAG,EAAE,IAAI,EAAE;IAC9D,gBAAgB,EAAsB,EAAE,EAAE,EAAE,IAAI,EAAG,GAAG,EAAE,IAAI,EAAE;IAC9D,cAAc;IACd,6BAA6B,EAAS,EAAE,EAAE,EAAE,IAAI,EAAG,GAAG,EAAE,KAAK,EAAE;IAC/D,yBAAyB,EAAa,EAAE,EAAE,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK,EAAE;IAC/D,uEAAuE;IACvE,sEAAsE;IACtE,KAAK,EAAI,EAAE,EAAE,EAAE,IAAI,EAAG,GAAG,EAAE,IAAI,EAAE;IACjC,MAAM,EAAG,EAAE,EAAE,EAAE,IAAI,EAAG,GAAG,EAAE,KAAK,EAAE;IAClC,IAAI,EAAK,EAAE,EAAE,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK,EAAE;IAClC,OAAO,EAAE,EAAE,EAAE,EAAE,IAAI,EAAG,GAAG,EAAE,KAAK,EAAE;CACnC,CAAC;AAEF;;;;GAIG;AACH,MAAM,UAAU,YAAY,CAAC,OAAe;IAC1C,MAAM,CAAC,GAAG,YAAY,CAAC,OAAO,CAAC,IAAI,EAAE,EAAE,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC;IACzD,OAAO,CAAC,CAAC,EAAE,GAAG,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC;AAC1B,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,OAAO,CACrB,OAA2B,EAC3B,WAA+B,EAC/B,YAAgC;IAEhC,IAAI,CAAC,WAAW,IAAI,CAAC,YAAY;QAAE,OAAO,CAAC,CAAC;IAC5C,MAAM,CAAC,GAAe,CAAC,OAAO,CAAC,CAAC,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,IAAI,EAAE,EAAE,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC;IAC7F,MAAM,GAAG,GAAG,WAAW,IAAI,CAAC,CAAC;IAC7B,MAAM,IAAI,GAAG,YAAY,IAAI,CAAC,CAAC;IAC/B,OAAO,CAAC,GAAG,GAAG,CAAC,CAAC,EAAE,GAAG,IAAI,GAAG,CAAC,CAAC,GAAG,CAAC,GAAG,SAAS,CAAC;AACjD,CAAC"}

package/dist/src/swarmvector/model-router.d.ts

@@ -0,0 +1,408 @@
+/**
+ * Intelligent Model Router — lexical complexity heuristic + Thompson bandit
+ *
+ * Dynamically routes requests to the optimal Claude model (haiku/sonnet/opus)
+ * based on task complexity, uncertainty, and online-learned routing outcomes.
+ *
+ * Mechanism (shipped):
+ * - Complexity score = blend of lexical, semantic-depth, task-scope, and
+ *   uncertainty heuristics (see `computeLexicalComplexity` and friends).
+ *   Pure JS arithmetic — no model load, no tensor math.
+ * - Model selection = Thompson-sampling Beta-Bernoulli bandit with
+ *   complexity-bucketed Beta(α,β) priors, persisted to
+ *   `.swarm/model-router-state.json` and updated by `recordOutcome` after
+ *   each routing decision.
+ * - Uncertainty quantification + a circuit breaker drive escalation when
+ *   the bandit's confidence is low or downstream failures are observed.
+ *
+ * Routing Strategy:
+ * - Haiku: high confidence, low complexity (fast, cheap)
+ * - Sonnet: medium confidence, moderate complexity (balanced)
+ * - Opus: low confidence, high complexity (most capable)
+ *
+ * Note (#2329): An earlier design (ADR-026 + this file's previous header)
+ * described a Tiny-Dancer / FastGRNN neural router with embedding-based
+ * complexity scoring. That path was never wired in directly.
+ *
+ * Note (ADR-148, #2334): The cost-optimal neural router is now wired as an
+ * optional, gated addition via `./neural-router.ts` (which uses
+ * `@metaharness/router`, optionally accelerated by `@swarmvector/tiny-dancer`).
+ * It is double-gated on `SWARMDO_ROUTER_NEURAL=1` + an embedding being
+ * supplied + a corpus/artifact being loadable. When any gate is closed the
+ * shipped heuristic + bandit path runs unchanged and the result carries
+ * `routedBy: 'heuristic'` (default) or `'bandit-fallback'` (neural enabled
+ * but declined). When all gates are open and a backend resolves, the result
+ * carries `routedBy: 'metaharness-knn' | 'metaharness-krr' | 'fastgrnn'`.
+ *
+ * @module model-router
+ */
+/**
+ * Available Claude models for routing
+ */
+export type ClaudeModel = 'haiku' | 'sonnet' | 'opus' | 'inherit';
+/**
+ * Model capabilities and characteristics
+ */
+export declare const MODEL_CAPABILITIES: Record<ClaudeModel, {
+    maxComplexity: number;
+    costMultiplier: number;
+    speedMultiplier: number;
+    description: string;
+}>;
+/**
+ * Complexity indicators for task classification
+ */
+export declare const COMPLEXITY_INDICATORS: {
+    high: string[];
+    medium: string[];
+    low: string[];
+};
+/**
+ * Model router configuration
+ */
+export interface ModelRouterConfig {
+    /** Confidence threshold for model selection (default: 0.85) */
+    confidenceThreshold: number;
+    /** Maximum uncertainty before escalating (default: 0.15) */
+    maxUncertainty: number;
+    /** Enable circuit breaker (default: true) */
+    enableCircuitBreaker: boolean;
+    /** Failures before circuit opens (default: 5) */
+    circuitBreakerThreshold: number;
+    /** Path for router state persistence */
+    statePath: string;
+    /** Auto-save interval in decisions (default: 20) */
+    autoSaveInterval: number;
+    /** Enable cost optimization (default: true) */
+    enableCostOptimization: boolean;
+    /** Prefer faster models when confidence is high (default: true) */
+    preferSpeed: boolean;
+}
+/**
+ * Routing decision result
+ */
+export interface ModelRoutingResult {
+    /** Selected model */
+    model: ClaudeModel;
+    /** Confidence in the decision (0-1) */
+    confidence: number;
+    /** Uncertainty estimate (0-1) */
+    uncertainty: number;
+    /** Computed complexity score (0-1) */
+    complexity: number;
+    /** Reasoning for the selection */
+    reasoning: string;
+    /** Alternative models considered */
+    alternatives: Array<{
+        model: ClaudeModel;
+        score: number;
+    }>;
+    /** Inference time in microseconds */
+    inferenceTimeUs: number;
+    /** Estimated cost multiplier */
+    costMultiplier: number;
+    /**
+     * Which decision mechanism produced this result (ADR-148 / ADR-074 —
+     * observable, not inferred). Always one of:
+     *   'heuristic'        — neural disabled (default). Pure Thompson bandit.
+     *   'bandit-fallback'  — neural enabled but returned no decision (load fail).
+     *   'hybrid'           — neural enabled AND returned predictions; the
+     *                        bandit's Beta(α,β) priors were perturbed by the
+     *                        neural's predicted quality before sampling.
+     */
+    routedBy: 'hybrid' | 'bandit-fallback' | 'heuristic';
+    /**
+     * The neural backend that contributed to a `hybrid` decision, if any.
+     * Absent on `heuristic` and `bandit-fallback`. Tracked separately from
+     * `routedBy` so the decision mechanism and the model identity remain
+     * distinct observable surfaces.
+     */
+    neuralBackend?: 'metaharness-knn' | 'metaharness-krr' | 'fastgrnn';
+    /**
+     * Execution provider hint (ADR-148 phase 2). 'anthropic' = default
+     * Anthropic API path (MODEL_MAP). 'openrouter' = call through
+     * OpenRouter using `openrouterModel`. Resolved per-call from
+     * `SWARMDO_ROUTER_PROVIDER` / `OPENROUTER_API_KEY`.
+     */
+    provider?: 'anthropic' | 'openrouter';
+    /**
+     * Concrete OpenRouter model slug for this tier when `provider==='openrouter'`,
+     * loaded from `assets/model-router/openrouter-alts.json` (overridable via
+     * `SWARMDO_ROUTER_OPENROUTER_ALTS=<path>`). Downstream consumers can
+     * use this to override the default MODEL_MAP-derived Anthropic slug.
+     */
+    openrouterModel?: string;
+    /**
+     * ADR-149 — concrete picked model id (e.g. `openai/gpt-4.1`,
+     * `inclusionai/ling-2.6-flash`, `anthropic/claude-sonnet-4-6`). Set when
+     * the neural backend returned a per-model pick. The `model` field above
+     * remains the tier label for back-compat with Anthropic-API consumers
+     * that map tier → MODEL_MAP id.
+     */
+    modelId?: string;
+}
+/**
+ * Complexity analysis result
+ */
+export interface ComplexityAnalysis {
+    /** Overall complexity score (0-1) */
+    score: number;
+    /** Indicators found */
+    indicators: {
+        high: string[];
+        medium: string[];
+        low: string[];
+    };
+    /** Feature breakdown */
+    features: {
+        lexicalComplexity: number;
+        semanticDepth: number;
+        taskScope: number;
+        uncertaintyLevel: number;
+    };
+}
+/**
+ * Beta(α, β) prior for Thompson sampling. Each model carries one of these;
+ * outcomes update α (successes) and β (failures) so the router auto-balances
+ * cost/quality without manual threshold tuning. See ADR-101.
+ */
+export interface BetaPrior {
+    alpha: number;
+    beta: number;
+}
+/**
+ * Router state for persistence
+ */
+/**
+ * Complexity bucket for per-task bandit priors. Bands mirror
+ * MODEL_CAPABILITIES.maxComplexity (haiku 0.4, sonnet 0.7) so the taxonomy
+ * isn't arbitrary. Keying priors by bucket fixes the global-bandit defect where
+ * failures on one task type suppressed a model for ALL task types (audit
+ * docs/reviews/intelligence-system-audit-2026-05-29.md; see ADR-142).
+ */
+export type ComplexityBucket = 'low' | 'med' | 'high';
+declare function complexityBucket(score: number): ComplexityBucket;
+type BucketedPriors = Record<ComplexityBucket, Record<ClaudeModel, BetaPrior>>;
+/**
+ * ADR-149 — per-modelId Beta priors, keyed by complexity bucket. Shadow
+ * state that accumulates from recordOutcomeByModelId() so the bandit can
+ * distinguish e.g. `inclusionai/ling-2.6-flash` from
+ * `anthropic/claude-haiku-4-5-20251001` even though both collapse to the
+ * `haiku` tier in BucketedPriors. Selection still uses BucketedPriors;
+ * a future refactor switches to BucketedPriorsById when it has enough
+ * data to be trustworthy.
+ */
+type BucketedPriorsById = Record<ComplexityBucket, Record<string, BetaPrior>>;
+/**
+ * Sample θ ~ Beta(α, β) via the identity Beta(α,β) = X / (X+Y) where
+ * X ~ Gamma(α), Y ~ Gamma(β). Returns the mean for degenerate α+β=0
+ * (shouldn't happen in practice but defensive).
+ */
+export declare function sampleBeta(alpha: number, beta: number): number;
+/**
+ * Intelligent Model Router using complexity-based routing
+ */
+export declare class ModelRouter {
+    private config;
+    private state;
+    private decisionCount;
+    private consecutiveFailures;
+    /**
+     * ADR-148 — in-memory counters surfaced via `getStats()` and read by the
+     * `hooks_intelligence_stats` MCP tool. Process-local, not persisted (these
+     * are operational metrics, not authoritative state — see ADR-074/086).
+     */
+    private routedByCounts;
+    private neuralBackendCounts;
+    private abDisagreements;
+    private abComparisons;
+    constructor(config?: Partial<ModelRouterConfig>);
+    /**
+     * Route a task to the optimal model.
+     *
+     * When `embedding` is supplied and `SWARMDO_ROUTER_NEURAL=1` is set,
+     * the cost-optimal neural backend (ADR-148) is consulted first; its
+     * decision is used when its `metBar` clears the configured quality bar
+     * and `routedBy` reflects which backend produced the decision. Otherwise
+     * the shipped heuristic + Thompson bandit path runs (byte-identical to
+     * the pre-ADR-148 behavior) and the result carries `routedBy:
+     * 'bandit-fallback'` (neural was enabled but declined) or
+     * `'heuristic'` (neural was disabled).
+     */
+    route(task: string, embedding?: number[]): Promise<ModelRoutingResult>;
+    /**
+     * Analyze task complexity
+     */
+    analyzeComplexity(task: string, embedding?: number[]): ComplexityAnalysis;
+    /**
+     * Compute lexical complexity from text features
+     */
+    private computeLexicalComplexity;
+    /**
+     * Compute semantic depth from indicators and embedding
+     */
+    private computeSemanticDepth;
+    /**
+     * Compute task scope from content analysis
+     */
+    private computeTaskScope;
+    /**
+     * Compute uncertainty level from task phrasing
+     */
+    private computeUncertaintyLevel;
+    /**
+     * Compute scores for each model
+     */
+    private computeModelScores;
+    /**
+     * Apply circuit breaker adjustments
+     */
+    private applyCircuitBreaker;
+    /**
+     * Select the best model from scores. Uses Thompson sampling (#1772):
+     * each model's deterministic complexity score is multiplied by a draw
+     * θ_m ~ Beta(α_m, β_m) from its bandit prior. Models with strong empirical
+     * track records get sampled higher; models with poor outcomes get sampled
+     * lower; the system auto-corrects against tier overuse without manual
+     * threshold tuning. Beta(1,1) = uniform on cold start so behavior matches
+     * the prior deterministic router until outcomes accumulate.
+     */
+    private selectModel;
+    /**
+     * Build human-readable reasoning
+     */
+    private buildReasoning;
+    /**
+     * Track routing decision for learning
+     */
+    private trackDecision;
+    /**
+     * Record outcome for learning
+     */
+    recordOutcome(task: string, model: ClaudeModel, outcome: 'success' | 'failure' | 'escalated'): void;
+    /**
+     * ADR-149 — record an outcome keyed by the CONCRETE model id (e.g.
+     * 'inclusionai/ling-2.6-flash') rather than the tier label. Updates the
+     * shadow `priorsById` state without affecting `priors` (tier priors).
+     *
+     * This is the per-model learning signal the bandit needs to eventually
+     * distinguish GPT-4.1 from Sonnet within the 'sonnet' tier. Selection
+     * currently still uses tier priors; this state accumulates so a future
+     * refactor can switch the selector over once there's enough data.
+     *
+     * Cost-adjusted reward semantics: cheap models get the highest reward on
+     * success (their successes are most cost-efficient). We map modelId to
+     * its closest tier for the reward table — the routing math doesn't have
+     * a per-modelId reward configuration yet.
+     */
+    recordOutcomeByModelId(task: string, modelId: string, outcome: 'success' | 'failure' | 'escalated'): void;
+    /**
+     * Get router statistics
+     */
+    getStats(): {
+        totalDecisions: number;
+        modelDistribution: Record<ClaudeModel, number>;
+        avgComplexity: number;
+        avgConfidence: number;
+        circuitBreakerTrips: number;
+        consecutiveFailures: Record<ClaudeModel, number>;
+        /** ADR-148: per-decision-mechanism counts (process-local, not persisted). */
+        routedByCounts: Record<ModelRoutingResult['routedBy'], number>;
+        /** ADR-148: per-neural-backend counts (process-local). */
+        neuralBackendCounts: Record<NonNullable<ModelRoutingResult['neuralBackend']>, number>;
+        /** ADR-148: A/B mode disagreement rate over the active process. */
+        ab: {
+            comparisons: number;
+            disagreements: number;
+            disagreementRate: number;
+        };
+        /**
+         * ADR-149: state schema version. 2 = bucketed tier priors only; 3 = also
+         * carries `priorsById` shadow state. Bumps on first recordOutcomeByModelId().
+         */
+        stateVersion: number;
+        /**
+         * ADR-149: per-modelId Beta priors per complexity bucket. Empty until
+         * recordOutcomeByModelId() fires. NOT consumed by selectModel() yet; this
+         * is shadow state for a future selection-by-modelId refactor.
+         */
+        priorsById?: BucketedPriorsById;
+    };
+    /**
+     * Load state from disk
+     */
+    private loadState;
+    /**
+     * Save state to disk
+     */
+    private saveState;
+    /**
+     * Reset router state
+     */
+    reset(): void;
+    /**
+     * Public read-only accessor for the bandit priors. Useful for tests,
+     * dashboards, and the pending hooks_intelligence_stats integration that
+     * surfaces convergence in the dashboard. Returns a copy.
+     */
+    getBanditPriors(bucket?: ComplexityBucket): Record<ClaudeModel, BetaPrior>;
+    /** All bucketed priors (copy) — for dashboards/tests. */
+    getBucketedPriors(): BucketedPriors;
+}
+/**
+ * Get or create the singleton ModelRouter instance
+ */
+export declare function getModelRouter(config?: Partial<ModelRouterConfig>): ModelRouter;
+/**
+ * Reset the singleton instance
+ */
+export declare function resetModelRouter(): void;
+/**
+ * Create a new ModelRouter instance (non-singleton)
+ */
+export declare function createModelRouter(config?: Partial<ModelRouterConfig>): ModelRouter;
+/**
+ * Quick route function for common use case
+ */
+export declare function routeToModel(task: string): Promise<ClaudeModel>;
+/**
+ * Route with full result
+ */
+export declare function routeToModelFull(task: string, embedding?: number[]): Promise<ModelRoutingResult>;
+/**
+ * Analyze task complexity without routing
+ */
+export declare function analyzeTaskComplexity(task: string): ComplexityAnalysis;
+/**
+ * Get model router statistics
+ */
+export declare function getModelRouterStats(): ReturnType<ModelRouter['getStats']>;
+/**
+ * Record routing outcome for learning
+ */
+export declare function recordModelOutcome(task: string, model: ClaudeModel, outcome: 'success' | 'failure' | 'escalated'): void;
+/**
+ * ADR-149 — record an outcome keyed by the concrete model id rather than
+ * the tier label. Updates the shadow `priorsById` state. Selection logic
+ * still uses tier priors; this data accumulates for a future per-modelId
+ * selector refactor.
+ *
+ * Safe to call alongside `recordModelOutcome` — they update independent
+ * state slices so double-counting is impossible.
+ */
+export declare function recordModelOutcomeByModelId(task: string, modelId: string, outcome: 'success' | 'failure' | 'escalated'): void;
+/**
+ * ADR-149 iter 14 — read-only access to the per-modelId Beta priors. The
+ * neural-router consumes this to apply per-model Thompson sampling on top
+ * of its predicted-quality vector when SWARMDO_ROUTER_BANDIT_PER_MODEL=1.
+ * Returns the legacy bucketed priors (`priorsById[bucket][modelId]`) when
+ * present, else null.
+ */
+export declare function getModelRouterPriorsById(): Record<ComplexityBucket, Record<string, BetaPrior>> | null;
+/**
+ * Re-export the complexity-bucket helper so the neural-router (which gets
+ * the task text via the route() call) can map a complexity score to the
+ * matching bandit bucket.
+ */
+export { complexityBucket };
+//# sourceMappingURL=model-router.d.ts.map

package/dist/src/swarmvector/model-router.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model-router.d.ts","sourceRoot":"","sources":["../../../src/swarmvector/model-router.ts"],"names":[],"mappings":"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"}