pi-smart-router 0.1.0

package/dist/domain/routing/expected-cost.js

@@ -0,0 +1,177 @@
+/**
+ * Expected-cost tier selection — SP-106, #68.
+ *
+ * E[cost_T] = P(success | T) × directCost(T)
+ *           + (1 - P(success | T)) × E[cost_escalation]
+ *
+ * Selects the tier minimizing adjusted expected cost subject to context-fit,
+ * local readiness, and pin/cache economics (FR-008).
+ */
+import { resolveFrugalityCostPer1M } from '../../infrastructure/pricing/price-broker.js';
+import { evaluateCacheEconomics, } from '../pinning/cache-economics.js';
+import { selectLowestCostModel } from '../pinning/sub-route-policy.js';
+/** Frontier-tier success probability when evaluating escalation terminal cost. */
+export const FRONTIER_P_SUCCESS = 1;
+/** Minimum per-1M-token spread required before economical tiers compete. */
+export const MIN_PRICE_DELTA_PER_1M = 0.25;
+function clamp01(value) {
+    if (value <= 0)
+        return 0;
+    if (value >= 1)
+        return 1;
+    return value;
+}
+function directCostUsd(costPer1M, estTokens) {
+    return (estTokens / 1_000_000) * costPer1M;
+}
+function resolveCheapestModelForTier(fleet, tier) {
+    return selectLowestCostModel(fleet.filter((model) => model.tier === tier));
+}
+/**
+ * Resolve representative per-1M cost for a tier using subscription-aware pricing (SP-096).
+ */
+export function resolveTierCostPer1M(tier, fleet, priceCatalog) {
+    const model = resolveCheapestModelForTier(fleet, tier);
+    if (!model) {
+        return 0;
+    }
+    return resolveFrugalityCostPer1M(model, priceCatalog);
+}
+function resolvePSuccessForTier(tier, pSuccessCheap) {
+    if (tier === 'frontier-cloud') {
+        return FRONTIER_P_SUCCESS;
+    }
+    return clamp01(pSuccessCheap);
+}
+function applyCostQualityAlpha(expectedCostUsd, pSuccess, escalationCostUsd, alpha) {
+    const riskPenalty = (1 - clamp01(alpha)) * (1 - clamp01(pSuccess)) * escalationCostUsd;
+    return expectedCostUsd + riskPenalty;
+}
+/**
+ * Compute per-tier expected routing cost under uncertainty.
+ *
+ * `priceCatalog` drives subscription virtual cost resolution; pass `costPer1M`
+ * via options when the caller already resolved tier pricing.
+ */
+export function computeExpectedCost(tier, pSuccess, priceCatalog, estTokens, escalationCostUsd, options) {
+    const alpha = options?.alpha ?? 1;
+    const fleet = options?.fleet ?? [];
+    const costPer1M = options?.costPer1M ?? resolveTierCostPer1M(tier, fleet, priceCatalog);
+    const direct = directCostUsd(costPer1M, estTokens);
+    const boundedPSuccess = resolvePSuccessForTier(tier, pSuccess);
+    const expectedCostUsd = boundedPSuccess * direct + (1 - boundedPSuccess) * escalationCostUsd;
+    const adjustedExpectedCostUsd = applyCostQualityAlpha(expectedCostUsd, boundedPSuccess, escalationCostUsd, alpha);
+    return {
+        tier,
+        pSuccess: boundedPSuccess,
+        costPer1M,
+        directCostUsd: direct,
+        escalationCostUsd,
+        expectedCostUsd,
+        adjustedExpectedCostUsd,
+    };
+}
+function listViableTiers(fleet, localZeroReady) {
+    const tiers = new Set();
+    for (const model of fleet) {
+        if (model.healthy === false) {
+            continue;
+        }
+        if (model.tier === 'zero-tier' && !localZeroReady) {
+            continue;
+        }
+        tiers.add(model.tier);
+    }
+    return [...tiers];
+}
+function buildEscalationCostUsd(tier, cheapDirectUsd, frontierDirectUsd) {
+    if (tier === 'frontier-cloud') {
+        return 0;
+    }
+    return cheapDirectUsd + frontierDirectUsd;
+}
+function hasSignificantPriceDelta(economicalCostPer1M, frontierCostPer1M) {
+    return frontierCostPer1M - economicalCostPer1M >= MIN_PRICE_DELTA_PER_1M;
+}
+function pickCheaperTierModel(fleet, tier) {
+    return resolveCheapestModelForTier(fleet, tier);
+}
+function shouldKeepPinnedTier(input, selectedTier) {
+    const pinnedModel = input.pinnedModel;
+    const sessionPin = input.sessionPin;
+    if (!pinnedModel || !sessionPin) {
+        return false;
+    }
+    const candidate = pickCheaperTierModel(input.fleet, selectedTier);
+    if (!candidate || candidate.id === pinnedModel.id) {
+        return false;
+    }
+    const economics = evaluateCacheEconomics(sessionPin, pinnedModel, candidate, input.estTokens, input.cacheEconomicsConfig);
+    return !economics.shouldSwitch;
+}
+/**
+ * Compare expected cost across context-fit-viable tiers and return argmin tier hint.
+ */
+export function selectTierByExpectedCost(input) {
+    const viableTiers = listViableTiers(input.fleet, input.localZeroReady);
+    const frontierCostPer1M = resolveTierCostPer1M('frontier-cloud', input.fleet, input.priceCatalog);
+    const economicalCostPer1M = Math.min(resolveTierCostPer1M('economical-cloud', input.fleet, input.priceCatalog), resolveTierCostPer1M('zero-tier', input.fleet, input.priceCatalog) || Infinity);
+    const frontierDirectUsd = directCostUsd(frontierCostPer1M, input.estTokens);
+    const priceDeltaSignificant = hasSignificantPriceDelta(economicalCostPer1M, frontierCostPer1M);
+    const tierCosts = viableTiers.map((tier) => {
+        const costPer1M = resolveTierCostPer1M(tier, input.fleet, input.priceCatalog);
+        const direct = directCostUsd(costPer1M, input.estTokens);
+        const escalationCostUsd = buildEscalationCostUsd(tier, direct, frontierDirectUsd);
+        return computeExpectedCost(tier, input.pSuccessCheap, input.priceCatalog, input.estTokens, escalationCostUsd, {
+            alpha: input.alpha,
+            costPer1M,
+            fleet: input.fleet,
+        });
+    });
+    if (tierCosts.length === 0) {
+        return {
+            tierHint: null,
+            reasonCode: 'expected_cost_no_viable_tier',
+            tierCosts,
+            rationale: 'No viable tiers after context-fit and local readiness filters',
+            blockedByPinEconomics: false,
+        };
+    }
+    let best = tierCosts[0];
+    for (const candidate of tierCosts.slice(1)) {
+        if (candidate.adjustedExpectedCostUsd < best.adjustedExpectedCostUsd) {
+            best = candidate;
+        }
+    }
+    if ((best.tier === 'economical-cloud' || best.tier === 'zero-tier') &&
+        !priceDeltaSignificant) {
+        return {
+            tierHint: null,
+            reasonCode: 'expected_cost_price_delta_insufficient',
+            tierCosts,
+            rationale: 'Economical tier expected cost is lowest but frontier–economical price delta is below threshold',
+            blockedByPinEconomics: false,
+        };
+    }
+    if (shouldKeepPinnedTier(input, best.tier)) {
+        const pinnedTier = input.pinnedModel.tier;
+        return {
+            tierHint: pinnedTier,
+            reasonCode: 'expected_cost_pin_cache_economics',
+            tierCosts,
+            rationale: 'Expected-cost tier switch blocked because cache reprime exceeds projected savings (FR-008)',
+            blockedByPinEconomics: true,
+        };
+    }
+    const rationale = best.tier === 'frontier-cloud'
+        ? `Frontier minimizes E[cost]=${best.adjustedExpectedCostUsd.toFixed(6)} with P(success)=${best.pSuccess.toFixed(3)}`
+        : `Economical tier minimizes E[cost]=${best.adjustedExpectedCostUsd.toFixed(6)} with P(success)=${best.pSuccess.toFixed(3)}`;
+    return {
+        tierHint: best.tier,
+        reasonCode: `expected_cost_${best.tier.replace('-', '_')}`,
+        tierCosts,
+        rationale,
+        blockedByPinEconomics: false,
+    };
+}
+//# sourceMappingURL=expected-cost.js.map

package/dist/domain/routing/expected-cost.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"expected-cost.js","sourceRoot":"","sources":["../../../src/domain/routing/expected-cost.ts"],"names":[],"mappings":"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"}

package/dist/domain/routing/p-success-classifier.d.ts

@@ -0,0 +1,130 @@
+/**
+ * Baseline P(success) classifier for economical-tier routing (SP-104).
+ *
+ * Trains a lightweight logistic scorer from privacy-safe dataset export rows
+ * joined with behavioral outcome labels. No heavy ML dependencies.
+ */
+import { z } from 'zod';
+import type { TierFeatureVector } from './tier-features.js';
+import type { OutcomeSignalType, RoutingDatasetRecord, RoutingOutcomeRecord } from '../types/index.js';
+/** Minimum labeled samples required before predictions deviate from neutral. */
+export declare const MIN_TRAINING_SAMPLES = 30;
+/** Neutral probability when training data is insufficient or artifact missing. */
+export declare const NEUTRAL_P_SUCCESS = 0.5;
+/** Outcome signals that mark a routing attempt as unsuccessful for cheap-tier training. */
+export declare const FAILURE_OUTCOME_SIGNALS: readonly OutcomeSignalType[];
+/** Outcome signals reserved for future execution telemetry (failover, length, infra). */
+export declare const FUTURE_FAILURE_SIGNALS: readonly ["provider_failover", "stop_reason_length", "infra_error"];
+export declare const P_SUCCESS_FEATURE_NAMES: readonly ["prompt_length_norm", "estimated_input_tokens_norm", "triage_cyclomatic_score", "requirement_reasoning", "requirement_code_gen", "requirement_tool_use", "has_tool_context", "compaction_flag", "routing_latency_norm", "economical_tier"];
+export type PSuccessFeatureName = (typeof P_SUCCESS_FEATURE_NAMES)[number];
+export interface PSuccessFeatures {
+    readonly prompt_length_norm: number;
+    readonly estimated_input_tokens_norm: number;
+    readonly triage_cyclomatic_score: number;
+    readonly requirement_reasoning: number;
+    readonly requirement_code_gen: number;
+    readonly requirement_tool_use: number;
+    readonly has_tool_context: number;
+    readonly compaction_flag: number;
+    readonly routing_latency_norm: number;
+    readonly economical_tier: number;
+}
+/** Online inference latency budget (SP-105). */
+export declare const P_SUCCESS_INFERENCE_BUDGET_MS = 5;
+export declare const PSuccessWeightsSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    min_training_samples: z.ZodNumber;
+    feature_names: z.ZodArray<z.ZodEnum<{
+        compaction_flag: "compaction_flag";
+        has_tool_context: "has_tool_context";
+        triage_cyclomatic_score: "triage_cyclomatic_score";
+        requirement_reasoning: "requirement_reasoning";
+        requirement_code_gen: "requirement_code_gen";
+        requirement_tool_use: "requirement_tool_use";
+        prompt_length_norm: "prompt_length_norm";
+        estimated_input_tokens_norm: "estimated_input_tokens_norm";
+        routing_latency_norm: "routing_latency_norm";
+        economical_tier: "economical_tier";
+    }>>;
+    intercept: z.ZodNumber;
+    coefficients: z.ZodArray<z.ZodNumber>;
+    trained_sample_count: z.ZodNumber;
+}, z.core.$strip>;
+export interface PSuccessWeights {
+    readonly version: 1;
+    readonly min_training_samples: number;
+    readonly feature_names: readonly PSuccessFeatureName[];
+    readonly intercept: number;
+    readonly coefficients: readonly number[];
+    readonly trained_sample_count: number;
+}
+export interface PSuccessPredictionResult {
+    readonly probability: number;
+    readonly elapsed_ms: number;
+    readonly within_budget: boolean;
+    readonly feature_importances: Readonly<Record<PSuccessFeatureName, number>>;
+}
+export interface LoadPSuccessWeightsOptions {
+    readonly filePath?: string;
+}
+export declare class PSuccessWeightsLoaderError extends Error {
+    readonly name = "PSuccessWeightsLoaderError";
+    constructor(message: string, options?: ErrorOptions);
+}
+export interface LabeledTrainingSample {
+    readonly request_id: string;
+    readonly features: PSuccessFeatures;
+    readonly success: boolean;
+    readonly outcome_signals: readonly OutcomeSignalType[];
+}
+export interface DatasetExportJoinRow extends Record<string, unknown> {
+    readonly request_id: string;
+    readonly success_label: boolean | null;
+    readonly outcome_signals: readonly OutcomeSignalType[];
+}
+/** Map a dataset row to a normalized feature vector for training or inference. */
+export declare function extractPSuccessFeatures(record: Pick<RoutingDatasetRecord, 'prompt_length_chars' | 'estimated_input_tokens' | 'triage_cyclomatic_score' | 'requirement_reasoning' | 'requirement_code_gen' | 'requirement_tool_use' | 'has_tool_context' | 'compaction_flag' | 'routing_latency_ms' | 'tier'>): PSuccessFeatures;
+export declare function featuresToVector(features: PSuccessFeatures): number[];
+/** Derive success label from outcome signals keyed to a request. */
+export declare function deriveSuccessLabel(outcomes: readonly RoutingOutcomeRecord[]): {
+    success: boolean | null;
+    outcome_signals: readonly OutcomeSignalType[];
+};
+/** Group outcomes by request_id for export joins. */
+export declare function indexOutcomesByRequestId(outcomes: readonly RoutingOutcomeRecord[]): Map<string, RoutingOutcomeRecord[]>;
+/** Join dataset rows with outcome labels for training export. */
+export declare function joinDatasetWithOutcomes(datasetRecords: readonly RoutingDatasetRecord[], outcomeRecords: readonly RoutingOutcomeRecord[]): LabeledTrainingSample[];
+/** Attach join labels to a privacy-safe export object. */
+export declare function attachOutcomeLabelsToExport(exportRecord: Record<string, unknown>, outcomes: readonly RoutingOutcomeRecord[]): DatasetExportJoinRow;
+/** Train logistic weights from labeled samples via batch gradient descent. */
+export declare function trainFromLabeledSamples(samples: readonly LabeledTrainingSample[], options?: {
+    readonly learningRate?: number;
+    readonly epochs?: number;
+}): PSuccessWeights;
+/** Parse one JSONL export line into a labeled training sample. */
+export declare function parseTrainingExportLine(line: string): LabeledTrainingSample | null;
+/** Train weights from privacy-safe labeled JSONL export content. */
+export declare function trainFromExportJsonl(jsonl: string): PSuccessWeights;
+/** Predict P_success_cheap in [0, 1]; returns neutral when under-trained. */
+export declare function predictPSuccessCheap(features: PSuccessFeatures, weights: PSuccessWeights): number;
+/** Default untrained weights artifact for operators to replace after export training. */
+export declare function createDefaultPSuccessWeights(): PSuccessWeights;
+/** Parse and validate a P(success) weights artifact from JSON text. */
+export declare function parsePSuccessWeightsJson(raw: string): PSuccessWeights;
+/**
+ * Load P(success) weights from disk. Returns null when the artifact is missing;
+ * throws only when the file exists but is invalid.
+ */
+export declare function loadPSuccessWeights(options?: LoadPSuccessWeightsOptions): PSuccessWeights | null;
+/** Resolve weights for online inference — missing or invalid artifacts fall back safely. */
+export declare function resolvePSuccessWeights(options?: LoadPSuccessWeightsOptions): PSuccessWeights;
+/** Map live tier features to the P(success) feature vector (no prompt text). */
+export declare function tierFeaturesToPSuccessFeatures(tierFeatures: TierFeatureVector, options?: {
+    readonly routingLatencyMs?: number;
+    readonly economicalTier?: boolean;
+}): PSuccessFeatures;
+/** Signed coefficient × feature contributions for operator explainability. */
+export declare function computePSuccessFeatureImportances(features: PSuccessFeatures, weights: PSuccessWeights): Readonly<Record<PSuccessFeatureName, number>>;
+/** Predict P_success_cheap with elapsed timing guard for the online routing budget. */
+export declare function predictPSuccessCheapTimed(features: PSuccessFeatures, weights: PSuccessWeights, budgetMs?: number): PSuccessPredictionResult;
+//# sourceMappingURL=p-success-classifier.d.ts.map

package/dist/domain/routing/p-success-classifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"p-success-classifier.d.ts","sourceRoot":"","sources":["../../../src/domain/routing/p-success-classifier.ts"],"names":[],"mappings":"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"}

package/dist/domain/routing/p-success-classifier.js

@@ -0,0 +1,350 @@
+/**
+ * Baseline P(success) classifier for economical-tier routing (SP-104).
+ *
+ * Trains a lightweight logistic scorer from privacy-safe dataset export rows
+ * joined with behavioral outcome labels. No heavy ML dependencies.
+ */
+import { existsSync, readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { z } from 'zod';
+/** Minimum labeled samples required before predictions deviate from neutral. */
+export const MIN_TRAINING_SAMPLES = 30;
+/** Neutral probability when training data is insufficient or artifact missing. */
+export const NEUTRAL_P_SUCCESS = 0.5;
+/** Outcome signals that mark a routing attempt as unsuccessful for cheap-tier training. */
+export const FAILURE_OUTCOME_SIGNALS = [
+    'model_override',
+    'feedback_bad',
+];
+/** Outcome signals reserved for future execution telemetry (failover, length, infra). */
+export const FUTURE_FAILURE_SIGNALS = [
+    'provider_failover',
+    'stop_reason_length',
+    'infra_error',
+];
+export const P_SUCCESS_FEATURE_NAMES = [
+    'prompt_length_norm',
+    'estimated_input_tokens_norm',
+    'triage_cyclomatic_score',
+    'requirement_reasoning',
+    'requirement_code_gen',
+    'requirement_tool_use',
+    'has_tool_context',
+    'compaction_flag',
+    'routing_latency_norm',
+    'economical_tier',
+];
+/** Online inference latency budget (SP-105). */
+export const P_SUCCESS_INFERENCE_BUDGET_MS = 5;
+export const PSuccessWeightsSchema = z.object({
+    version: z.literal(1),
+    min_training_samples: z.number().int().min(0),
+    feature_names: z.array(z.enum(P_SUCCESS_FEATURE_NAMES)).length(P_SUCCESS_FEATURE_NAMES.length),
+    intercept: z.number(),
+    coefficients: z.array(z.number()).length(P_SUCCESS_FEATURE_NAMES.length),
+    trained_sample_count: z.number().int().min(0),
+});
+export class PSuccessWeightsLoaderError extends Error {
+    name = 'PSuccessWeightsLoaderError';
+    constructor(message, options) {
+        super(message, options);
+    }
+}
+const PROMPT_LENGTH_NORM = 8_000;
+const TOKEN_NORM = 2_000;
+const LATENCY_NORM_MS = 500;
+function clamp01(value) {
+    if (value <= 0)
+        return 0;
+    if (value >= 1)
+        return 1;
+    return value;
+}
+function sigmoid(z) {
+    if (z >= 0) {
+        const expNeg = Math.exp(-z);
+        return 1 / (1 + expNeg);
+    }
+    const expPos = Math.exp(z);
+    return expPos / (1 + expPos);
+}
+function numOrZero(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : 0;
+}
+function boolToNum(value) {
+    return value === true ? 1 : 0;
+}
+/** Map a dataset row to a normalized feature vector for training or inference. */
+export function extractPSuccessFeatures(record) {
+    const promptLength = numOrZero(record.prompt_length_chars);
+    const tokens = numOrZero(record.estimated_input_tokens ?? promptLength / 4);
+    return {
+        prompt_length_norm: clamp01(promptLength / PROMPT_LENGTH_NORM),
+        estimated_input_tokens_norm: clamp01(tokens / TOKEN_NORM),
+        triage_cyclomatic_score: clamp01(numOrZero(record.triage_cyclomatic_score)),
+        requirement_reasoning: clamp01(numOrZero(record.requirement_reasoning)),
+        requirement_code_gen: clamp01(numOrZero(record.requirement_code_gen)),
+        requirement_tool_use: clamp01(numOrZero(record.requirement_tool_use)),
+        has_tool_context: boolToNum(record.has_tool_context),
+        compaction_flag: boolToNum(record.compaction_flag),
+        routing_latency_norm: clamp01(numOrZero(record.routing_latency_ms) / LATENCY_NORM_MS),
+        economical_tier: record.tier === 'economical-cloud' || record.tier === 'zero-tier' ? 1 : 0,
+    };
+}
+export function featuresToVector(features) {
+    return P_SUCCESS_FEATURE_NAMES.map((name) => features[name]);
+}
+/** Derive success label from outcome signals keyed to a request. */
+export function deriveSuccessLabel(outcomes) {
+    const signals = [...new Set(outcomes.map((entry) => entry.signal_type))];
+    if (signals.some((signal) => FAILURE_OUTCOME_SIGNALS.includes(signal))) {
+        return { success: false, outcome_signals: signals };
+    }
+    if (signals.includes('feedback_good')) {
+        return { success: true, outcome_signals: signals };
+    }
+    if (signals.length === 0) {
+        return { success: null, outcome_signals: signals };
+    }
+    // compaction_pin_break and other neutral signals — treat as unlabeled success.
+    return { success: true, outcome_signals: signals };
+}
+/** Group outcomes by request_id for export joins. */
+export function indexOutcomesByRequestId(outcomes) {
+    const byRequest = new Map();
+    for (const outcome of outcomes) {
+        const existing = byRequest.get(outcome.request_id) ?? [];
+        existing.push(outcome);
+        byRequest.set(outcome.request_id, existing);
+    }
+    return byRequest;
+}
+/** Join dataset rows with outcome labels for training export. */
+export function joinDatasetWithOutcomes(datasetRecords, outcomeRecords) {
+    const outcomesByRequest = indexOutcomesByRequestId(outcomeRecords);
+    return datasetRecords.map((record) => {
+        const linked = outcomesByRequest.get(record.request_id) ?? [];
+        const { success, outcome_signals } = deriveSuccessLabel(linked);
+        return {
+            request_id: record.request_id,
+            features: extractPSuccessFeatures(record),
+            success: success ?? true,
+            outcome_signals,
+        };
+    });
+}
+/** Attach join labels to a privacy-safe export object. */
+export function attachOutcomeLabelsToExport(exportRecord, outcomes) {
+    const { success, outcome_signals } = deriveSuccessLabel(outcomes);
+    return {
+        ...exportRecord,
+        request_id: String(exportRecord.request_id ?? ''),
+        success_label: success,
+        outcome_signals,
+    };
+}
+function dot(a, b) {
+    let sum = 0;
+    for (let i = 0; i < a.length; i++) {
+        sum += a[i] * b[i];
+    }
+    return sum;
+}
+/** Train logistic weights from labeled samples via batch gradient descent. */
+export function trainFromLabeledSamples(samples, options) {
+    const featureDim = P_SUCCESS_FEATURE_NAMES.length;
+    const coefficients = Array.from({ length: featureDim }, () => 0);
+    let intercept = 0;
+    if (samples.length === 0) {
+        return {
+            version: 1,
+            min_training_samples: MIN_TRAINING_SAMPLES,
+            feature_names: P_SUCCESS_FEATURE_NAMES,
+            intercept: 0,
+            coefficients,
+            trained_sample_count: 0,
+        };
+    }
+    const learningRate = options?.learningRate ?? 0.1;
+    const epochs = options?.epochs ?? 200;
+    const xs = samples.map((sample) => featuresToVector(sample.features));
+    const ys = samples.map((sample) => (sample.success ? 1 : 0));
+    for (let epoch = 0; epoch < epochs; epoch++) {
+        for (let i = 0; i < xs.length; i++) {
+            const x = xs[i];
+            const y = ys[i];
+            const z = intercept + dot(coefficients, x);
+            const prediction = sigmoid(z);
+            const error = prediction - y;
+            intercept -= learningRate * error;
+            for (let j = 0; j < coefficients.length; j++) {
+                coefficients[j] -= learningRate * error * x[j];
+            }
+        }
+    }
+    return {
+        version: 1,
+        min_training_samples: MIN_TRAINING_SAMPLES,
+        feature_names: P_SUCCESS_FEATURE_NAMES,
+        intercept,
+        coefficients,
+        trained_sample_count: samples.length,
+    };
+}
+/** Parse one JSONL export line into a labeled training sample. */
+export function parseTrainingExportLine(line) {
+    const trimmed = line.trim();
+    if (trimmed.length === 0) {
+        return null;
+    }
+    const parsed = JSON.parse(trimmed);
+    const requestId = parsed.request_id;
+    if (typeof requestId !== 'string' || requestId.length === 0) {
+        return null;
+    }
+    const successLabel = parsed.success_label;
+    let success = true;
+    if (typeof successLabel === 'boolean') {
+        success = successLabel;
+    }
+    const rawSignals = parsed.outcome_signals;
+    const outcome_signals = Array.isArray(rawSignals)
+        ? rawSignals.filter((value) => typeof value === 'string')
+        : [];
+    const record = parsed;
+    return {
+        request_id: requestId,
+        features: extractPSuccessFeatures(record),
+        success: success === false ? false : true,
+        outcome_signals,
+    };
+}
+/** Train weights from privacy-safe labeled JSONL export content. */
+export function trainFromExportJsonl(jsonl) {
+    const samples = jsonl
+        .split('\n')
+        .map((line) => parseTrainingExportLine(line))
+        .filter((sample) => sample !== null);
+    return trainFromLabeledSamples(samples);
+}
+/** Predict P_success_cheap in [0, 1]; returns neutral when under-trained. */
+export function predictPSuccessCheap(features, weights) {
+    if (weights.trained_sample_count < weights.min_training_samples) {
+        return NEUTRAL_P_SUCCESS;
+    }
+    const vector = featuresToVector(features);
+    if (vector.length !== weights.coefficients.length) {
+        return NEUTRAL_P_SUCCESS;
+    }
+    const z = weights.intercept + dot(weights.coefficients, vector);
+    return clamp01(sigmoid(z));
+}
+/** Default untrained weights artifact for operators to replace after export training. */
+export function createDefaultPSuccessWeights() {
+    return {
+        version: 1,
+        min_training_samples: MIN_TRAINING_SAMPLES,
+        feature_names: P_SUCCESS_FEATURE_NAMES,
+        intercept: 0,
+        coefficients: P_SUCCESS_FEATURE_NAMES.map(() => 0),
+        trained_sample_count: 0,
+    };
+}
+function formatZodIssues(error) {
+    return error.issues
+        .map((issue) => `  - ${issue.path.join('.')}: ${issue.message}`)
+        .join('\n');
+}
+/** Parse and validate a P(success) weights artifact from JSON text. */
+export function parsePSuccessWeightsJson(raw) {
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        throw new PSuccessWeightsLoaderError(`Failed to parse JSON: ${message}`, { cause: err });
+    }
+    const result = PSuccessWeightsSchema.safeParse(parsed);
+    if (!result.success) {
+        throw new PSuccessWeightsLoaderError(`Invalid P(success) weights artifact:\n${formatZodIssues(result.error)}`, { cause: result.error });
+    }
+    return result.data;
+}
+/**
+ * Load P(success) weights from disk. Returns null when the artifact is missing;
+ * throws only when the file exists but is invalid.
+ */
+export function loadPSuccessWeights(options) {
+    const filePath = options?.filePath ?? resolve('config', 'p-success-weights.json');
+    if (!existsSync(filePath)) {
+        return null;
+    }
+    let raw;
+    try {
+        raw = readFileSync(filePath, 'utf8');
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        throw new PSuccessWeightsLoaderError(`Failed to read weights file: ${message}`, { cause: err });
+    }
+    return parsePSuccessWeightsJson(raw);
+}
+/** Resolve weights for online inference — missing or invalid artifacts fall back safely. */
+export function resolvePSuccessWeights(options) {
+    try {
+        return loadPSuccessWeights(options) ?? createDefaultPSuccessWeights();
+    }
+    catch (err) {
+        console.warn('P(success) weights artifact invalid; using neutral fallback', {
+            error: err instanceof Error ? err.message : String(err),
+        });
+        return createDefaultPSuccessWeights();
+    }
+}
+/** Map live tier features to the P(success) feature vector (no prompt text). */
+export function tierFeaturesToPSuccessFeatures(tierFeatures, options) {
+    const routingLatencyMs = options?.routingLatencyMs ?? 0;
+    const economicalTier = options?.economicalTier ?? true;
+    return extractPSuccessFeatures({
+        prompt_length_chars: tierFeatures.prompt_length_chars,
+        estimated_input_tokens: tierFeatures.estimated_input_tokens,
+        triage_cyclomatic_score: tierFeatures.cyclomatic_score,
+        requirement_reasoning: tierFeatures.requirement_reasoning,
+        requirement_code_gen: tierFeatures.requirement_code_gen,
+        requirement_tool_use: tierFeatures.requirement_tool_use,
+        has_tool_context: tierFeatures.has_tool_context,
+        compaction_flag: false,
+        routing_latency_ms: routingLatencyMs,
+        tier: economicalTier ? 'economical-cloud' : 'frontier-cloud',
+    });
+}
+/** Signed coefficient × feature contributions for operator explainability. */
+export function computePSuccessFeatureImportances(features, weights) {
+    const importances = {};
+    for (let i = 0; i < P_SUCCESS_FEATURE_NAMES.length; i++) {
+        const name = P_SUCCESS_FEATURE_NAMES[i];
+        importances[name] = weights.coefficients[i] * features[name];
+    }
+    return importances;
+}
+/** Predict P_success_cheap with elapsed timing guard for the online routing budget. */
+export function predictPSuccessCheapTimed(features, weights, budgetMs = P_SUCCESS_INFERENCE_BUDGET_MS) {
+    const start = performance.now();
+    const probability = predictPSuccessCheap(features, weights);
+    const elapsed_ms = performance.now() - start;
+    const feature_importances = computePSuccessFeatureImportances(features, weights);
+    if (elapsed_ms > budgetMs) {
+        console.warn('P(success) inference exceeded latency budget', {
+            elapsed_ms,
+            budget_ms: budgetMs,
+        });
+    }
+    return {
+        probability,
+        elapsed_ms,
+        within_budget: elapsed_ms <= budgetMs,
+        feature_importances,
+    };
+}
+//# sourceMappingURL=p-success-classifier.js.map