martin-loop 0.1.5 → 1.3.0

package/dist/vendor/core/red-blue/red-phase.js

@@ -0,0 +1,141 @@
+import { PROBE_COUNTS, RED_PHASE_MODEL, resolveRedBudgetPolicy } from "./risk-tiers.js";
+// ─── Programmatic probes ──────────────────────────────────────────────────────
+/**
+ * Runs programmatic adversarial probes against a patch diff.
+ * These are deterministic checks — no model call.
+ */
+function runProgrammaticProbes(patch, paranoid) {
+    const findings = [];
+    // Probe 1: assertion deletion
+    if (/^\-.*expect\(.*\)\.to/m.test(patch.diff)) {
+        findings.push({
+            trapId: "T01",
+            severity: "warn",
+            description: "Patch removes test assertions — possible weak-test false green."
+        });
+    }
+    // Probe 2: grounding evasion pragma
+    if (/@martin-ignore|@ts-nocheck|eslint-disable/i.test(patch.diff)) {
+        findings.push({
+            trapId: "T11",
+            severity: "block",
+            description: "Grounding evasion pragma detected in patch."
+        });
+    }
+    // Probe 3: context poisoning
+    if (/\.martin\/|\.claude\//.test(patch.diff)) {
+        findings.push({
+            trapId: "T07",
+            severity: "block",
+            description: "Patch writes to agent context directory (.martin/ or .claude/)."
+        });
+    }
+    // Probe 4: budget self-report
+    if (/budgetSource.*model_reported|model_reported.*budget/i.test(patch.diff)) {
+        findings.push({
+            trapId: "T10",
+            severity: "block",
+            description: "Patch introduces model-reported budget sourcing."
+        });
+    }
+    if (paranoid) {
+        // Probe 5: scope creep — manifest changes
+        if (/^\+.*"[^"]+"\s*:\s*"[^"]+".*$/m.test(patch.diff) &&
+            /package\.json|Cargo\.toml|go\.mod/i.test(patch.changedFiles.join(","))) {
+            findings.push({
+                trapId: "T03",
+                severity: "warn",
+                description: "Paranoid scan: substantive manifest change detected."
+            });
+        }
+        // Probe 6: silent revert — removal of recently added symbols
+        const removedExportPattern = /^\-.*export\s+(function|const|class)\s+\w+/m;
+        if (removedExportPattern.test(patch.diff)) {
+            findings.push({
+                trapId: "T02",
+                severity: "warn",
+                description: "Paranoid scan: exported symbol removed — potential silent revert."
+            });
+        }
+    }
+    return findings;
+}
+// ─── Red phase runner ─────────────────────────────────────────────────────────
+/**
+ * Runs the Red phase for a given patch and risk tier.
+ *
+ * - baseline: programmatic probes only, no model call
+ * - high_risk: paranoid programmatic scan, no model call
+ * - release_critical: paranoid scan + one Haiku model call
+ */
+export async function runRedPhase(patch, tier, blueBudgetUsd, options = {}) {
+    const policy = resolveRedBudgetPolicy(tier, blueBudgetUsd);
+    const paranoid = tier !== "baseline";
+    let findings = runProgrammaticProbes(patch, paranoid);
+    let modelCallMade = false;
+    let modelUsed;
+    let budgetUsedUsd = 0;
+    const probesRun = PROBE_COUNTS[tier];
+    if (policy.modelCallAllowed && options.modelClient) {
+        const prompt = buildRedPhasePrompt(patch, findings);
+        const result = await options.modelClient.complete(prompt);
+        findings = [...findings, ...result.findings];
+        modelCallMade = true;
+        modelUsed = RED_PHASE_MODEL;
+        budgetUsedUsd += result.costUsd;
+    }
+    const result = {
+        riskTier: tier,
+        probesRun,
+        findingsCount: findings.length,
+        findings,
+        modelCallMade,
+        ...(modelUsed !== undefined ? { modelUsed } : {}),
+        budgetUsedUsd
+    };
+    // Emit ledger event
+    options.onLedgerEvent?.({
+        type: "red_phase_findings",
+        riskTier: tier,
+        probesRun,
+        findingsCount: findings.length,
+        modelCallMade,
+        timestamp: new Date().toISOString()
+    });
+    return result;
+}
+// ─── Policy helpers ───────────────────────────────────────────────────────────
+/**
+ * Returns true only if the findings contain zero block-severity entries.
+ * A single block finding rejects the patch regardless of warn count.
+ */
+export function shouldAcceptPatch(findings) {
+    return !findings.findings.some((f) => f.severity === "block");
+}
+/**
+ * Convenience builder for RedFindings — useful in tests and policy engine.
+ */
+export function buildRedFindings(input) {
+    return {
+        riskTier: input.riskTier,
+        probesRun: input.probesRun ?? PROBE_COUNTS[input.riskTier],
+        findingsCount: input.findings.length,
+        findings: input.findings,
+        modelCallMade: input.modelCallMade ?? false,
+        ...(input.modelUsed !== undefined ? { modelUsed: input.modelUsed } : {}),
+        budgetUsedUsd: input.budgetUsedUsd ?? 0
+    };
+}
+// ─── Internal helpers ─────────────────────────────────────────────────────────
+function buildRedPhasePrompt(patch, existingFindings) {
+    return [
+        "You are a security-focused code reviewer running adversarial analysis.",
+        "Analyze this patch for adversarial patterns not caught by programmatic probes.",
+        "Return JSON array of findings with: trapId, severity (warn|block), description.",
+        `Already detected: ${JSON.stringify(existingFindings.map(f => f.trapId))}`,
+        `Changed files: ${patch.changedFiles.join(", ")}`,
+        "Diff (truncated to 2000 chars):",
+        patch.diff.slice(0, 2000)
+    ].join("\n");
+}
+//# sourceMappingURL=red-phase.js.map

package/dist/vendor/core/red-blue/risk-tiers.d.ts

@@ -0,0 +1,22 @@
+export type RiskTier = "baseline" | "high_risk" | "release_critical";
+export interface RedBudgetPolicy {
+    riskTier: RiskTier;
+    blueBudgetUsd: number;
+    /** Cap on Red phase spend: 30% / 100% / 150% of Blue */
+    redBudgetCapUsd: number;
+    /** Only release_critical permits a Haiku model call */
+    modelCallAllowed: boolean;
+}
+/**
+ * Returns the Red phase budget policy for a given risk tier and Blue budget.
+ */
+export declare function resolveRedBudgetPolicy(tier: RiskTier, blueBudgetUsd: number): RedBudgetPolicy;
+/**
+ * Probe counts per tier.
+ * baseline = standard 6-probe sweep
+ * high_risk = paranoid 12-probe sweep
+ * release_critical = paranoid 12-probe sweep + model
+ */
+export declare const PROBE_COUNTS: Record<RiskTier, number>;
+/** The only model ever permitted in the Red phase. */
+export declare const RED_PHASE_MODEL: "claude-haiku-4-5-20251001";

package/dist/vendor/core/red-blue/risk-tiers.js

@@ -0,0 +1,33 @@
+// ─── Risk Tier Definitions ────────────────────────────────────────────────────
+// Governs how aggressively Red phase probes a patch and whether a model call
+// is permitted. Budget caps are expressed as fractions of the Blue phase budget.
+const BUDGET_MULTIPLIERS = {
+    baseline: 0.30,
+    high_risk: 1.00,
+    release_critical: 1.50
+};
+/**
+ * Returns the Red phase budget policy for a given risk tier and Blue budget.
+ */
+export function resolveRedBudgetPolicy(tier, blueBudgetUsd) {
+    return {
+        riskTier: tier,
+        blueBudgetUsd,
+        redBudgetCapUsd: blueBudgetUsd * BUDGET_MULTIPLIERS[tier],
+        modelCallAllowed: tier === "release_critical"
+    };
+}
+/**
+ * Probe counts per tier.
+ * baseline = standard 6-probe sweep
+ * high_risk = paranoid 12-probe sweep
+ * release_critical = paranoid 12-probe sweep + model
+ */
+export const PROBE_COUNTS = {
+    baseline: 6,
+    high_risk: 12,
+    release_critical: 12
+};
+/** The only model ever permitted in the Red phase. */
+export const RED_PHASE_MODEL = "claude-haiku-4-5-20251001";
+//# sourceMappingURL=risk-tiers.js.map

package/dist/vendor/core/replay/replay.d.ts

@@ -0,0 +1,85 @@
+/**
+ * replay.ts — SLICE-10
+ *
+ * Reproducibility seal: re-runs the decision pipeline over stored attempt
+ * artifacts (no model calls) and confirms every gate decision still matches.
+ *
+ * Any deterministic mismatch is a P0 defect in the decision pipeline.
+ */
+export interface StoredAttemptArtifact {
+    attemptId: string;
+    loopId: string;
+    /** The diff that was evaluated */
+    diff: string;
+    /** The objective at time of evaluation */
+    objective: string;
+    /** Decisions recorded during the original run */
+    decisions: {
+        leash: {
+            blocked: boolean;
+            matchedPattern?: string;
+        };
+        grounding: {
+            contradictions: number;
+        };
+        proof: {
+            grade: "A" | "B" | "C";
+            passed: boolean;
+        };
+        finalVerdict: "ACCEPTED" | "REJECTED";
+    };
+    /** ISO timestamp of original run */
+    recordedAt: string;
+}
+export interface ReplayDecisions {
+    leash: {
+        blocked: boolean;
+        matchedPattern?: string;
+    };
+    grounding: {
+        contradictions: number;
+    };
+    proof: {
+        grade: "A" | "B" | "C";
+        passed: boolean;
+    };
+    finalVerdict: "ACCEPTED" | "REJECTED";
+}
+export interface ReplayMismatch {
+    gate: "leash" | "grounding" | "proof" | "finalVerdict";
+    original: unknown;
+    replayed: unknown;
+    severity: "P0" | "P1";
+}
+export interface ReplayReport {
+    loopId: string;
+    attemptId: string;
+    match: boolean;
+    mismatches: ReplayMismatch[];
+    replayedAt: string;
+    /** SHA-256 over (loopId + attemptId + replayedAt + match) */
+    replayHash: string;
+}
+/**
+ * Re-runs the leash check over a stored diff.
+ * Uses the same BLOCKED_PATTERNS from leash.ts — but as a lightweight
+ * re-implementation to avoid circular deps in the replay layer.
+ */
+export declare function replayLeashCheck(diff: string): {
+    blocked: boolean;
+    matchedPattern?: string;
+};
+/**
+ * Re-evaluates the proof grade from stored inputs.
+ * Grade is deterministic from the verifier result string.
+ */
+export declare function replayProofGrade(verifierResult: string, objective: string): {
+    grade: "A" | "B" | "C";
+    passed: boolean;
+};
+export declare function replayAttempt(artifact: StoredAttemptArtifact, verifierResult?: string): ReplayReport;
+export declare function replayLoop(artifacts: StoredAttemptArtifact[], verifierResults?: Map<string, string>): {
+    reports: ReplayReport[];
+    allMatch: boolean;
+    p0Count: number;
+};

package/dist/vendor/core/replay/replay.js

@@ -0,0 +1,109 @@
+/**
+ * replay.ts — SLICE-10
+ *
+ * Reproducibility seal: re-runs the decision pipeline over stored attempt
+ * artifacts (no model calls) and confirms every gate decision still matches.
+ *
+ * Any deterministic mismatch is a P0 defect in the decision pipeline.
+ */
+import { createHash } from "node:crypto";
+// ---------------------------------------------------------------------------
+// Pipeline re-runners (deterministic, no model calls)
+// ---------------------------------------------------------------------------
+/**
+ * Re-runs the leash check over a stored diff.
+ * Uses the same BLOCKED_PATTERNS from leash.ts — but as a lightweight
+ * re-implementation to avoid circular deps in the replay layer.
+ */
+export function replayLeashCheck(diff) {
+    const DANGEROUS_PATTERNS = [
+        { name: "SHELL_RM_RF", re: /rm\s+-rf?\b/ },
+        { name: "SHELL_PIPE_EVAL", re: /curl.*\|\s*(?:ba)?sh|wget.*\|\s*(?:ba)?sh/ },
+        { name: "GIT_FORCE_PUSH", re: /git\s+push\s+.*--force/ },
+        { name: "GIT_RESET_HARD", re: /git\s+reset\s+--hard/ },
+        { name: "FORK_BOMB", re: /:\s*\(\s*\)\s*\{.*:.*\|.*:.*\}/ },
+        { name: "SHELL_CHMOD_777", re: /chmod\s+(?:a\+rwx|777)/ },
+        { name: "NODE_EXEC_EVAL", re: /eval\s*\(/ },
+        { name: "SUDO_ESCALATION", re: /sudo\s+/ },
+    ];
+    for (const { name, re } of DANGEROUS_PATTERNS) {
+        if (re.test(diff))
+            return { blocked: true, matchedPattern: name };
+    }
+    return { blocked: false };
+}
+/**
+ * Re-evaluates the proof grade from stored inputs.
+ * Grade is deterministic from the verifier result string.
+ */
+export function replayProofGrade(verifierResult, objective) {
+    const lower = verifierResult.toLowerCase();
+    const hasPass = lower.includes("pass") || lower.includes("ok") || lower.includes("✓");
+    const hasFail = lower.includes("fail") || lower.includes("error") || lower.includes("✗");
+    if (hasPass && !hasFail)
+        return { grade: "A", passed: true };
+    if (hasPass && hasFail)
+        return { grade: "B", passed: false };
+    return { grade: "C", passed: false };
+}
+// ---------------------------------------------------------------------------
+// Core replay function
+// ---------------------------------------------------------------------------
+export function replayAttempt(artifact, verifierResult) {
+    const replayedAt = new Date().toISOString();
+    const mismatches = [];
+    // Re-run leash
+    const replayLeash = replayLeashCheck(artifact.diff);
+    if (replayLeash.blocked !== artifact.decisions.leash.blocked) {
+        mismatches.push({
+            gate: "leash",
+            original: artifact.decisions.leash,
+            replayed: replayLeash,
+            severity: "P0"
+        });
+    }
+    // Re-run proof grade (if verifier result provided)
+    if (verifierResult !== undefined) {
+        const replayProof = replayProofGrade(verifierResult, artifact.objective);
+        if (replayProof.grade !== artifact.decisions.proof.grade) {
+            mismatches.push({
+                gate: "proof",
+                original: artifact.decisions.proof,
+                replayed: replayProof,
+                severity: "P0"
+            });
+        }
+    }
+    // Final verdict: derive from replayed decisions
+    const replayedVerdict = (!replayLeash.blocked && (verifierResult === undefined || artifact.decisions.proof.passed)) ? "ACCEPTED" : "REJECTED";
+    if (replayedVerdict !== artifact.decisions.finalVerdict) {
+        mismatches.push({
+            gate: "finalVerdict",
+            original: artifact.decisions.finalVerdict,
+            replayed: replayedVerdict,
+            severity: "P0"
+        });
+    }
+    const match = mismatches.length === 0;
+    const replayHash = createHash("sha256")
+        .update(`${artifact.loopId}:${artifact.attemptId}:${replayedAt}:${match}`)
+        .digest("hex");
+    return {
+        loopId: artifact.loopId,
+        attemptId: artifact.attemptId,
+        match,
+        mismatches,
+        replayedAt,
+        replayHash
+    };
+}
+// ---------------------------------------------------------------------------
+// Replay runner: multiple attempts
+// ---------------------------------------------------------------------------
+export function replayLoop(artifacts, verifierResults) {
+    const reports = artifacts.map(a => replayAttempt(a, verifierResults?.get(a.attemptId)));
+    const allMatch = reports.every(r => r.match);
+    const p0Count = reports.reduce((n, r) => n + r.mismatches.filter(m => m.severity === "P0").length, 0);
+    return { reports, allMatch, p0Count };
+}
+//# sourceMappingURL=replay.js.map

package/dist/vendor/core/router/engine.d.ts

@@ -0,0 +1,54 @@
+import type { LoopTask, FailureClass } from "../../contracts/index.js";
+import type { CostGovernorState } from "../policy.js";
+import { type ModelTrustProfile } from "./trust-calibration.js";
+/**
+ * Minimal structural interface for what the router requires from an adapter.
+ * Any MartinAdapter from @martin/core is structurally compatible with this.
+ */
+export interface RouterAdapterRef {
+    metadata: {
+        model: string;
+        provider?: string;
+    };
+}
+export interface RouteConfig {
+    adapter: RouterAdapterRef;
+    baseCostUsdPer1kTcs: number;
+    maxLatencyMs?: number;
+    trustTier: "high" | "medium" | "low";
+}
+export interface RouteEvaluationContext {
+    task: LoopTask;
+    costState: CostGovernorState;
+    currentFailure?: FailureClass;
+    complexityScore: number;
+    /**
+     * Estimated blast radius of the planned action on a 0–100 scale.
+     * Exposed in run summary and OTel span.
+     * When > 70, forces high-trust route regardless of other heuristics.
+     */
+    blastRadius?: number;
+    /**
+     * Trust profiles derived from historical run data by the Trust Calibration Engine.
+     * When present, the router uses these to auto-downgrade to cheaper models that
+     * have proven reliability and to deprioritize models with poor track records.
+     */
+    trustProfiles?: ModelTrustProfile[];
+}
+export interface RouteDecision {
+    adapter: RouterAdapterRef;
+    rationale: string;
+    /** Estimated cost per 1k tokens for the selected route — exposed in run summary and OTel span */
+    selectedCostPer1kTcs: number;
+    /** Trust tier of the selected route */
+    selectedTrustTier: "high" | "medium" | "low";
+}
+export declare class MartinRouter {
+    private readonly availableRoutes;
+    constructor(availableRoutes: RouteConfig[]);
+    /**
+     * Dynamically selects the optimal provider/model adapter for the next attempt.
+     * Balances the necessity for intelligence (trustTier, complexity) against budget constraints.
+     */
+    evaluateRoute(context: RouteEvaluationContext): RouteDecision;
+}

package/dist/vendor/core/router/engine.js

@@ -0,0 +1,131 @@
+import { getTracer } from "../otel/tracer.js";
+import { shouldDeprioritize } from "./trust-calibration.js";
+export class MartinRouter {
+    availableRoutes;
+    constructor(availableRoutes) {
+        this.availableRoutes = availableRoutes;
+    }
+    /**
+     * Dynamically selects the optimal provider/model adapter for the next attempt.
+     * Balances the necessity for intelligence (trustTier, complexity) against budget constraints.
+     */
+    evaluateRoute(context) {
+        if (this.availableRoutes.length === 0) {
+            throw new Error("MartinRouter has no available routes configured.");
+        }
+        const { costState, currentFailure, complexityScore, blastRadius, trustProfiles } = context;
+        const tracer = getTracer();
+        const span = tracer.startSpan("martin.router_decision", {
+            "router.pressure": costState.pressure,
+            "router.remaining_budget_usd": costState.remainingBudgetUsd,
+            "router.complexity_score": complexityScore,
+            ...(currentFailure ? { "router.failure_class": currentFailure } : {}),
+            ...(blastRadius !== undefined ? { "router.blast_radius": blastRadius } : {})
+        });
+        const emit = (selected, rationale) => {
+            span.attributes["router.selected_model"] = selected.adapter.metadata.model;
+            span.attributes["router.selected_trust_tier"] = selected.trustTier;
+            span.attributes["router.selected_cost_per_1k_tcs"] = selected.baseCostUsdPer1kTcs;
+            span.attributes["router.rationale"] = rationale;
+            tracer.endSpan(span, "OK");
+            return {
+                adapter: selected.adapter,
+                rationale,
+                selectedCostPer1kTcs: selected.baseCostUsdPer1kTcs,
+                selectedTrustTier: selected.trustTier
+            };
+        };
+        // Filter out adapters that would aggressively violate remaining budget estimations
+        const budgetFilteredRoutes = this.availableRoutes.filter((route) => {
+            const estimatedCost = route.baseCostUsdPer1kTcs * 15;
+            return estimatedCost <= costState.remainingBudgetUsd;
+        });
+        const routes = budgetFilteredRoutes.length > 0 ? budgetFilteredRoutes : this.availableRoutes;
+        // High blast radius: force a high-trust route to reduce regression risk
+        if (blastRadius !== undefined && blastRadius > 70) {
+            const highTrust = routes.filter((r) => r.trustTier === "high");
+            if (highTrust.length > 0) {
+                const safest = highTrust.reduce((min, r) => r.baseCostUsdPer1kTcs < min.baseCostUsdPer1kTcs ? r : min);
+                return emit(safest, `Forced high-trust route ${safest.adapter.metadata.model} due to blast radius ${blastRadius}/100.`);
+            }
+        }
+        // Trust calibration: deprioritize models with proven poor track records
+        // and prefer cheaper models with proven high efficiency when data warrants it
+        let calibratedRoutes = routes;
+        if (trustProfiles && trustProfiles.length > 0) {
+            // Remove routes whose model has been deprioritized by evidence
+            const evidenceBacked = routes.filter((r) => {
+                const profile = trustProfiles.find((p) => profileMatchesRoute(p, r));
+                return profile === undefined || !shouldDeprioritize(profile);
+            });
+            if (evidenceBacked.length > 0)
+                calibratedRoutes = evidenceBacked;
+            const trustedRoutes = calibratedRoutes
+                .map((route) => ({
+                route,
+                profile: trustProfiles.find((profile) => profileMatchesRoute(profile, route))
+            }))
+                .filter((item) => {
+                const profile = item.profile;
+                return (profile !== undefined &&
+                    profile.efficiencyScore > 0.85 &&
+                    profile.runsObserved >= 3);
+            })
+                .sort((a, b) => a.route.baseCostUsdPer1kTcs - b.route.baseCostUsdPer1kTcs);
+            const trustedRoute = trustedRoutes[0];
+            const defaultRoute = routes[0];
+            if (trustedRoute &&
+                defaultRoute &&
+                trustedRoute.route.baseCostUsdPer1kTcs < defaultRoute.baseCostUsdPer1kTcs) {
+                return emit(trustedRoute.route, `Auto-selected ${trustedRoute.route.adapter.metadata.model} based on ${String(trustedRoute.profile.runsObserved)} historical runs (efficiency: ${String(Math.round(trustedRoute.profile.efficiencyScore * 100))}%, completion: ${String(Math.round(trustedRoute.profile.completionRate * 100))}%).`);
+            }
+        }
+        const effectiveRoutes = calibratedRoutes;
+        // Default to cheapest route when budget is at the hard ceiling
+        if (costState.pressure === "hard_limit") {
+            const cheapest = effectiveRoutes.reduce((min, r) => r.baseCostUsdPer1kTcs < min.baseCostUsdPer1kTcs ? r : min);
+            return emit(cheapest, `Selected ${cheapest.adapter.metadata.model} due to severe budget pressure (hard_limit).`);
+        }
+        // If we're failing on reasoning or grounding, escalate to a high-trust model immediately
+        if (currentFailure === "verification_failure" ||
+            currentFailure === "repo_grounding_failure" ||
+            complexityScore > 0.7) {
+            const highTrust = effectiveRoutes.filter((r) => r.trustTier === "high");
+            if (highTrust.length > 0) {
+                const best = highTrust.reduce((min, r) => r.baseCostUsdPer1kTcs < min.baseCostUsdPer1kTcs ? r : min);
+                return emit(best, `Escalated to ${best.adapter.metadata.model} (high-trust) due to failure profile '${currentFailure ?? "complex_task"}'.`);
+            }
+        }
+        // Prefer economical route for simple or trivially-classified errors
+        if (currentFailure === "syntax_error" ||
+            currentFailure === "repo_grounding_failure" ||
+            complexityScore < 0.3) {
+            const economical = effectiveRoutes.filter((r) => r.trustTier !== "high");
+            if (economical.length > 0) {
+                const best = economical.reduce((min, r) => r.baseCostUsdPer1kTcs < min.baseCostUsdPer1kTcs ? r : min);
+                return emit(best, `Selected ${best.adapter.metadata.model} to preserve budget on low-complexity task recovery.`);
+            }
+        }
+        // Default to a balanced medium-tier route if no strict heuristic applies
+        const mediumTrust = effectiveRoutes.filter((r) => r.trustTier === "medium");
+        if (mediumTrust.length > 0) {
+            const best = mediumTrust.reduce((min, r) => Math.abs(r.maxLatencyMs ?? 5000) < Math.abs(min.maxLatencyMs ?? 5000) ? r : min);
+            return emit(best, `Selected balanced route ${best.adapter.metadata.model} for nominal execution.`);
+        }
+        // Ultimate fallback — effectiveRoutes is non-empty (guaranteed by the guard above)
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const bestRoute = effectiveRoutes[0];
+        return emit(bestRoute, `Fallback route ${bestRoute.adapter.metadata.model} selected as default.`);
+    }
+}
+function profileMatchesRoute(profile, route) {
+    const model = normalizeModelKey(route.adapter.metadata.model);
+    const profileModel = normalizeModelKey(profile.model);
+    return (model === profileModel ||
+        model.includes(profileModel) ||
+        profileModel.includes(model));
+}
+function normalizeModelKey(value) {
+    return value.toLowerCase().replace(/[^a-z0-9]+/g, "-");
+}
+//# sourceMappingURL=engine.js.map

package/dist/vendor/core/router/index.d.ts

@@ -0,0 +1 @@
+export * from "./engine.js";

package/dist/vendor/core/router/index.js

@@ -0,0 +1,2 @@
+export * from "./engine.js";
+//# sourceMappingURL=index.js.map

package/dist/vendor/core/router/trust-calibration.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Trust Calibration Engine — the self-improvement loop.
+ *
+ * Reads historical run records from ~/.martin/runs/ and computes a reliability
+ * profile for each model that has been used. The router uses these profiles to
+ * automatically downgrade to cheaper models when evidence shows they perform
+ * as well as more expensive ones, and to deprioritize models with poor track records.
+ *
+ * This closes the feedback loop that was missing: every completed run writes
+ * evidence to disk; this module reads it back into routing decisions.
+ */
+export interface ModelTrustProfile {
+    /** Model identifier as recorded in attempt records (e.g. "claude-sonnet-4-6") */
+    model: string;
+    /** Total runs where this model was used for at least one attempt */
+    runsObserved: number;
+    /** Fraction of observed runs that completed successfully (0–1) */
+    completionRate: number;
+    /** Average USD cost per iteration (attempt) */
+    avgCostPerIteration: number;
+    /** Average iterations used vs budget.maxIterations (lower = more efficient) */
+    avgIterationEfficiency: number;
+    /**
+     * Composite score 0–1: completionRate * (1 - avgIterationEfficiency).
+     * High score = completes well AND uses fewer iterations than the budget allows.
+     */
+    efficiencyScore: number;
+    /** ISO timestamp of the most recent run that informed this profile */
+    lastUpdated: string;
+}
+export interface TrustCalibrationResult {
+    /** Per-model reliability profiles, sorted by efficiencyScore descending */
+    profiles: ModelTrustProfile[];
+    /**
+     * The model with the best efficiencyScore that also meets minRuns threshold.
+     * Null if insufficient data exists yet.
+     */
+    recommendedModel: string | null;
+    /** Total number of runs analyzed to produce this result */
+    calibrationBasis: number;
+}
+/**
+ * Reads historical loop records and computes a trust profile for each model.
+ *
+ * @param runsDir - Override the default ~/.martin/runs path (useful for testing)
+ * @param minRuns - Minimum observations required before a profile is considered
+ *   reliable enough to influence routing. Default: 3.
+ * @param efficiencyThreshold - Minimum efficiencyScore for a model to be
+ *   eligible for auto-recommendation. Default: 0.75.
+ */
+export declare function calibrateTrust(runsDir?: string, minRuns?: number, efficiencyThreshold?: number): Promise<TrustCalibrationResult>;
+/**
+ * Returns true if a model should be deprioritized based on its trust profile.
+ * A model is deprioritized when it has enough observations to be confident
+ * it performs poorly (low completion rate).
+ */
+export declare function shouldDeprioritize(profile: ModelTrustProfile, minRuns?: number, minCompletionRate?: number): boolean;