@martinloop/mcp 0.3.9 → 0.5.1

package/dist/vendor/core/persistence/mission-store.js

@@ -0,0 +1,281 @@
+/**
+ * Mission Store — C2 durable persistence.
+ *
+ * Layout under <runsRoot>/missions/<missionId>/:
+ *   mission.json      — rebuildable snapshot/cache (NOT the authority)
+ *   ledger.jsonl      — append-only, SHA-256 hash-chained event log (authority)
+ *   ledger-chain.json — chain head hash for tamper detection
+ *   .lock             — cross-process exclusive lock (created with O_EXCL)
+ *
+ * Rules:
+ *   - Ledger is always written before mission.json is updated.
+ *   - mission.json is written atomically (temp file → rename).
+ *   - Cross-process lock is held during every write; stale locks (>8s) are removed.
+ *   - CAS revision must match before any write is accepted.
+ *   - Corrupt or unverifiable ledger data fails closed.
+ *   - Workspace isolation: all paths are under caller-supplied runsRoot.
+ */
+import { createHash } from "node:crypto";
+import { constants, open } from "node:fs/promises";
+import { appendFile, mkdir, readFile, rename, rm, stat, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { MISSION_SCHEMA_VERSION, isMissionTransitionAllowed } from "../../contracts/index.js";
+// ─── Paths ────────────────────────────────────────────────────────────────────
+export function missionDir(runsRoot, missionId) {
+    return join(runsRoot, "missions", missionId);
+}
+function missionJsonPath(runsRoot, missionId) {
+    return join(missionDir(runsRoot, missionId), "mission.json");
+}
+function ledgerPath(runsRoot, missionId) {
+    return join(missionDir(runsRoot, missionId), "ledger.jsonl");
+}
+function chainPath(runsRoot, missionId) {
+    return join(missionDir(runsRoot, missionId), "ledger-chain.json");
+}
+function lockPath(runsRoot, missionId) {
+    return join(missionDir(runsRoot, missionId), ".lock");
+}
+// ─── Hash chain ───────────────────────────────────────────────────────────────
+function sha256(value) {
+    return createHash("sha256").update(value, "utf8").digest("hex");
+}
+async function readChainHead(runsRoot, missionId) {
+    const raw = await readFile(chainPath(runsRoot, missionId), "utf8").catch(() => null);
+    if (raw === null)
+        return { headHash: "root", entryCount: 0 };
+    return JSON.parse(raw);
+}
+async function appendLedgerEntry(runsRoot, missionId, event) {
+    const line = JSON.stringify(event);
+    const head = await readChainHead(runsRoot, missionId);
+    const newHash = sha256(`${head.headHash}\n${line}`);
+    const newHead = { headHash: newHash, entryCount: head.entryCount + 1 };
+    // Append event first, then update chain head
+    await appendFile(ledgerPath(runsRoot, missionId), `${line}\n`, "utf8");
+    await atomicWrite(chainPath(runsRoot, missionId), JSON.stringify(newHead, null, 2));
+}
+// ─── Atomic write ─────────────────────────────────────────────────────────────
+async function atomicWrite(filePath, content) {
+    const tmp = `${filePath}.tmp`;
+    await writeFile(tmp, content, "utf8");
+    await rename(tmp, filePath);
+}
+// ─── Cross-process lock ───────────────────────────────────────────────────────
+const LOCK_STALE_MS = 8_000;
+const LOCK_RETRY_INTERVAL_MS = 50;
+const LOCK_MAX_RETRIES = 60; // 3s total
+async function acquireLock(runsRoot, missionId) {
+    const lp = lockPath(runsRoot, missionId);
+    for (let attempt = 0; attempt < LOCK_MAX_RETRIES; attempt++) {
+        try {
+            // O_EXCL — fails if file exists (atomic on all POSIX and Windows NTFS)
+            const fh = await open(lp, constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY);
+            await fh.write(String(Date.now()));
+            await fh.close();
+            return;
+        }
+        catch {
+            // Lock exists — check if stale
+            try {
+                const st = await stat(lp);
+                const ageMs = Date.now() - st.mtimeMs;
+                if (ageMs > LOCK_STALE_MS) {
+                    await rm(lp, { force: true });
+                    continue; // retry immediately after removing stale lock
+                }
+            }
+            catch {
+                // Lock disappeared between check and stat — retry
+                continue;
+            }
+            await new Promise((r) => setTimeout(r, LOCK_RETRY_INTERVAL_MS));
+        }
+    }
+    throw new Error(`mission-store: could not acquire lock for ${missionId} after ${LOCK_MAX_RETRIES} retries`);
+}
+async function releaseLock(runsRoot, missionId) {
+    await rm(lockPath(runsRoot, missionId), { force: true });
+}
+async function withLock(runsRoot, missionId, fn) {
+    await acquireLock(runsRoot, missionId);
+    try {
+        return await fn();
+    }
+    finally {
+        await releaseLock(runsRoot, missionId);
+    }
+}
+// ─── Event ID factory ─────────────────────────────────────────────────────────
+let _seq = 0;
+function makeEventId(missionId) {
+    return `evt_${missionId.slice(0, 8)}_${Date.now()}_${(_seq++).toString().padStart(4, "0")}`;
+}
+// ─── Read mission ─────────────────────────────────────────────────────────────
+/**
+ * Read the current mission snapshot.
+ * Returns null when no mission exists at this path.
+ * Fails closed when the snapshot schema version is not recognised.
+ */
+export async function readMission(runsRoot, missionId) {
+    const raw = await readFile(missionJsonPath(runsRoot, missionId), "utf8").catch(() => null);
+    if (raw === null)
+        return null;
+    const record = JSON.parse(raw);
+    if (record.schemaVersion !== MISSION_SCHEMA_VERSION) {
+        throw new Error(`mission-store: unsupported schema "${record.schemaVersion}" for mission ${missionId}`);
+    }
+    return record;
+}
+// ─── Read ledger ──────────────────────────────────────────────────────────────
+export async function readMissionLedger(runsRoot, missionId) {
+    const raw = await readFile(ledgerPath(runsRoot, missionId), "utf8").catch(() => "");
+    return raw
+        .split(/\r?\n/u)
+        .map((l) => l.trim())
+        .filter(Boolean)
+        .map((l) => JSON.parse(l));
+}
+/**
+ * Verify the stored chain head matches a full replay of the ledger.
+ * Returns ok=false when the ledger has been tampered with or entries are missing.
+ */
+export async function verifyMissionLedger(runsRoot, missionId) {
+    const events = await readMissionLedger(runsRoot, missionId);
+    const stored = await readChainHead(runsRoot, missionId);
+    let hash = "root";
+    for (const event of events) {
+        hash = sha256(`${hash}\n${JSON.stringify(event)}`);
+    }
+    if (hash !== stored.headHash) {
+        return {
+            ok: false,
+            reason: `chain_mismatch: expected ${stored.headHash}, replayed ${hash}`,
+            entryCount: events.length
+        };
+    }
+    if (events.length !== stored.entryCount) {
+        return {
+            ok: false,
+            reason: `count_mismatch: stored ${stored.entryCount}, actual ${events.length}`,
+            entryCount: events.length
+        };
+    }
+    return { ok: true, entryCount: events.length };
+}
+// ─── Create mission ───────────────────────────────────────────────────────────
+export async function createMission(runsRoot, mission) {
+    const dir = missionDir(runsRoot, mission.missionId);
+    await mkdir(dir, { recursive: true });
+    await withLock(runsRoot, mission.missionId, async () => {
+        // Fail if already exists
+        const existing = await readMission(runsRoot, mission.missionId);
+        if (existing !== null) {
+            throw new Error(`mission-store: mission ${mission.missionId} already exists`);
+        }
+        const event = {
+            eventId: makeEventId(mission.missionId),
+            kind: "mission.created",
+            missionId: mission.missionId,
+            timestamp: mission.createdAt,
+            payload: { status: mission.status, ownerId: mission.ownerId }
+        };
+        await appendLedgerEntry(runsRoot, mission.missionId, event);
+        await atomicWrite(missionJsonPath(runsRoot, mission.missionId), JSON.stringify(mission, null, 2));
+    });
+}
+export async function attachRun(runsRoot, missionId, options) {
+    return withLock(runsRoot, missionId, async () => {
+        const mission = await readMission(runsRoot, missionId);
+        if (mission === null)
+            throw new Error(`mission-store: mission ${missionId} not found`);
+        if (mission.revision !== options.expectedRevision) {
+            throw new Error(`mission-store: CAS revision mismatch for ${missionId}: ` +
+                `expected ${options.expectedRevision}, found ${mission.revision}`);
+        }
+        const ts = options.now ? options.now() : new Date().toISOString();
+        const link = {
+            loopId: options.loopId,
+            role: options.role,
+            attachedAt: ts,
+            ...(options.verifiedOutcome !== undefined ? { verifiedOutcome: options.verifiedOutcome } : {}),
+            ...(options.actualUsd !== undefined ? { actualUsd: options.actualUsd } : {})
+        };
+        const newCost = {
+            totalActualUsd: mission.cost.totalActualUsd + (options.actualUsd ?? 0),
+            verifiedOutcomeCount: mission.cost.verifiedOutcomeCount + (options.verifiedOutcome === true ? 1 : 0),
+            totalRunCount: mission.cost.totalRunCount + 1
+        };
+        const updated = {
+            ...mission,
+            revision: mission.revision + 1,
+            runLinks: [...mission.runLinks, link],
+            cost: newCost,
+            updatedAt: ts
+        };
+        const event = {
+            eventId: makeEventId(missionId),
+            kind: "mission.run_attached",
+            missionId,
+            timestamp: ts,
+            payload: {
+                loopId: options.loopId,
+                role: options.role,
+                verifiedOutcome: options.verifiedOutcome,
+                actualUsd: options.actualUsd
+            }
+        };
+        await appendLedgerEntry(runsRoot, missionId, event);
+        await atomicWrite(missionJsonPath(runsRoot, missionId), JSON.stringify(updated, null, 2));
+        return updated;
+    });
+}
+export async function changeMissionStatus(runsRoot, missionId, options) {
+    return withLock(runsRoot, missionId, async () => {
+        const mission = await readMission(runsRoot, missionId);
+        if (mission === null)
+            throw new Error(`mission-store: mission ${missionId} not found`);
+        if (mission.revision !== options.expectedRevision) {
+            throw new Error(`mission-store: CAS revision mismatch for ${missionId}: ` +
+                `expected ${options.expectedRevision}, found ${mission.revision}`);
+        }
+        if (!isMissionTransitionAllowed(mission.status, options.toStatus)) {
+            throw new Error(`mission-store: transition ${mission.status} → ${options.toStatus} is not allowed`);
+        }
+        const ts = options.now ? options.now() : new Date().toISOString();
+        const updated = {
+            ...mission,
+            revision: mission.revision + 1,
+            status: options.toStatus,
+            updatedAt: ts,
+            ...(options.decision && options.decidedBy
+                ? {
+                    outcome: {
+                        decision: options.decision,
+                        decidedAt: ts,
+                        decidedBy: options.decidedBy,
+                        ...(options.note ? { note: options.note } : {})
+                    }
+                }
+                : {})
+        };
+        const eventKind = options.toStatus === "shipped" || options.toStatus === "killed" || options.toStatus === "rolled_back"
+            ? "mission.closed"
+            : "mission.status_changed";
+        const event = {
+            eventId: makeEventId(missionId),
+            kind: eventKind,
+            missionId,
+            timestamp: ts,
+            payload: {
+                from: mission.status,
+                to: options.toStatus,
+                decision: options.decision,
+                decidedBy: options.decidedBy
+            }
+        };
+        await appendLedgerEntry(runsRoot, missionId, event);
+        await atomicWrite(missionJsonPath(runsRoot, missionId), JSON.stringify(updated, null, 2));
+        return updated;
+    });
+}

package/dist/vendor/core/persistence/runs-reader.d.ts

@@ -6,6 +6,7 @@
  * - legacy root JSONL files: <runsRoot>/*.jsonl
  * - canonical run trees: <runsRoot>/<loopId>/loop-record.json
  */
+import type { CostProvenance } from "../../contracts/index.js";
 export interface LoopAttemptRecord {
     index: number;
     model?: string;
@@ -32,6 +33,7 @@ export interface LoopRunRecord {
         tokensIn: number;
         tokensOut: number;
         avoidedUsd?: number;
+        provenance?: CostProvenance;
     };
     attempts: LoopAttemptRecord[];
     task: {

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

@@ -138,6 +138,8 @@ export interface PatchDecisionInput {
     safetyViolationCount?: number;
     scopeViolationCount?: number;
     changedFileCount?: number;
+    mutationRequired?: boolean;
+    definitionOfDonePreSatisfied?: boolean;
     diffNovelty?: number;
     diffStats?: {
         filesChanged: number;

package/dist/vendor/core/policy.js

@@ -152,14 +152,14 @@ export function classifyFailure(input) {
             failureClass: "logic_error",
             rationale: "Oscillating failure pattern detected — switching strategy to break the cycle.",
             retryable: true,
-            recommendedIntervention: "change_model"
+            recommendedIntervention: "compress_context"
         };
     }
     return {
         failureClass: repeatedFailure ?? "logic_error",
         rationale: "The loop is still failing to produce a correct implementation.",
         retryable: true,
-        recommendedIntervention: repeatedFailure === "logic_error" ? "change_model" : "compress_context"
+        recommendedIntervention: "compress_context"
     };
 }
 export function evaluateCostGovernor(input) {
@@ -318,7 +318,7 @@ function mapClassHintToAssessment(classHint, attempts) {
                 failureClass: "hallucination",
                 rationale: "Structural evidence: suspiciously short or trivial agent response.",
                 retryable: true,
-                recommendedIntervention: repeatedFailure === "hallucination" ? "change_model" : "run_verifier"
+                recommendedIntervention: repeatedFailure === "hallucination" ? "compress_context" : "run_verifier"
             };
         case "verification_failure":
         case "test_regression":
@@ -333,7 +333,7 @@ function mapClassHintToAssessment(classHint, attempts) {
                 failureClass: classHint,
                 rationale: "Structural hint provided by adapter.",
                 retryable: true,
-                recommendedIntervention: repeatedFailure ? "change_model" : "compress_context"
+                recommendedIntervention: "compress_context"
             };
     }
 }
@@ -472,7 +472,7 @@ export function selectRecoveryRecipe(evidence) {
             return {
                 recipe: "strategy_swap",
                 rationale: "Very low diff novelty across repeated retries. Swap strategy.",
-                intervention: "change_model"
+                intervention: "compress_context"
             };
         }
         return {
@@ -485,7 +485,7 @@ export function selectRecoveryRecipe(evidence) {
         return {
             recipe: "downgrade_model",
             rationale: "Cost efficiency is degrading or retries are exhausted. Downgrade the model.",
-            intervention: "change_model"
+            intervention: "compress_context"
         };
     }
     return {
@@ -514,6 +514,9 @@ export function scorePatchDecision(input) {
     const safetyViolationCount = input.safetyViolationCount ?? 0;
     const changedFileEvidenceAvailable = input.changedFileCount !== undefined;
     const changedFileCount = input.changedFileCount ?? 0;
+    const auditablePreSatisfiedNoChange = input.verificationPassed &&
+        input.mutationRequired === true &&
+        input.definitionOfDonePreSatisfied === true;
     const noveltyScore = input.diffNovelty ?? (changedFileCount > 0 ? 1 : 0);
     const diffRiskScore = computeDiffRiskScore(input.diffStats);
     const costUsd = roundUsd(input.costUsd ?? 0);
@@ -527,7 +530,7 @@ export function scorePatchDecision(input) {
     if (scopeViolationCount > 0) {
         reasonCodes.push("scope_violation");
     }
-    if (changedFileEvidenceAvailable && changedFileCount === 0) {
+    if (changedFileEvidenceAvailable && changedFileCount === 0 && !auditablePreSatisfiedNoChange) {
         reasonCodes.push("no_code_change");
     }
     if (input.humanApprovalRequired) {
@@ -560,7 +563,7 @@ export function scorePatchDecision(input) {
     if (input.humanApprovalRequired) {
         score -= 0.25;
     }
-    if (changedFileEvidenceAvailable && changedFileCount === 0) {
+    if (changedFileEvidenceAvailable && changedFileCount === 0 && !auditablePreSatisfiedNoChange) {
         score -= 0.35;
     }
     if (!input.verificationPassed && noveltyScore < 0.2 && verifierDelta <= 0) {

package/dist/vendor/core/red-blue/red-phase.d.ts

@@ -20,6 +20,7 @@ export interface MockModelClient {
         findings: RedFinding[];
         tokensUsed: number;
         costUsd: number;
+        model?: string;
     }>;
 }
 export interface RunRedPhaseOptions {
@@ -47,7 +48,7 @@ export interface PatchInput {
  *
  * - baseline: programmatic probes only, no model call
  * - high_risk: paranoid programmatic scan, no model call
- * - release_critical: paranoid scan + one Haiku model call
+ * - release_critical: paranoid scan + one configured model-client call
  */
 export declare function runRedPhase(patch: PatchInput, tier: RiskTier, blueBudgetUsd: number, options?: RunRedPhaseOptions): Promise<RedFindings>;
 /**

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

@@ -1,4 +1,4 @@
-import { PROBE_COUNTS, RED_PHASE_MODEL, resolveRedBudgetPolicy } from "./risk-tiers.js";
+import { PROBE_COUNTS, resolveRedBudgetPolicy } from "./risk-tiers.js";
 // ─── Programmatic probes ──────────────────────────────────────────────────────
 function runProgrammaticProbes(patch, paranoid) {
     const findings = [];
@@ -62,7 +62,7 @@ function runProgrammaticProbes(patch, paranoid) {
  *
  * - baseline: programmatic probes only, no model call
  * - high_risk: paranoid programmatic scan, no model call
- * - release_critical: paranoid scan + one Haiku model call
+ * - release_critical: paranoid scan + one configured model-client call
  */
 export async function runRedPhase(patch, tier, blueBudgetUsd, options = {}) {
     const policy = resolveRedBudgetPolicy(tier, blueBudgetUsd);
@@ -77,7 +77,7 @@ export async function runRedPhase(patch, tier, blueBudgetUsd, options = {}) {
         const result = await options.modelClient.complete(prompt);
         findings = [...findings, ...result.findings];
         modelCallMade = true;
-        modelUsed = RED_PHASE_MODEL;
+        modelUsed = result.model;
         budgetUsedUsd += result.costUsd;
     }
     const result = {

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

@@ -4,7 +4,7 @@ export interface RedBudgetPolicy {
     blueBudgetUsd: number;
     /** Cap on Red phase spend: 30% / 100% / 150% of Blue */
     redBudgetCapUsd: number;
-    /** Only release_critical permits a Haiku model call */
+    /** Only release_critical permits an optional configured model-client call. */
     modelCallAllowed: boolean;
 }
 /**
@@ -15,8 +15,6 @@ export declare function resolveRedBudgetPolicy(tier: RiskTier, blueBudgetUsd: nu
  * Probe counts per tier.
  * baseline = standard 6-probe sweep
  * high_risk = paranoid 12-probe sweep
- * release_critical = paranoid 12-probe sweep + model
+ * release_critical = paranoid 12-probe sweep + configured model client
  */
 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

@@ -21,12 +21,10 @@ export function resolveRedBudgetPolicy(tier, blueBudgetUsd) {
  * Probe counts per tier.
  * baseline = standard 6-probe sweep
  * high_risk = paranoid 12-probe sweep
- * release_critical = paranoid 12-probe sweep + model
+ * release_critical = paranoid 12-probe sweep + configured model client
  */
 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";

package/dist/vendor/core/rollback.js

@@ -1,4 +1,5 @@
 import { spawnSync } from "node:child_process";
+import { readFileSync } from "node:fs";
 import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
 import { dirname, relative, resolve } from "node:path";
 export function listAttemptChangedFilesSinceBoundary(input) {
@@ -11,11 +12,24 @@ export function listAttemptChangedFilesSinceBoundary(input) {
     }
     const baselineTracked = new Set(input.boundary.trackedDirtyFiles);
     const baselineUntracked = new Set(input.boundary.untrackedFiles);
+    const baselineContentChanges = input.boundary.snapshots
+        .filter((snapshot) => snapshot.existed && repoFileDiffersFromSnapshot(input.repoRoot, snapshot))
+        .map((snapshot) => snapshot.path);
     return uniqueSorted([
         ...repoState.trackedDirtyFiles.filter((filePath) => !baselineTracked.has(filePath)),
-        ...repoState.untrackedFiles.filter((filePath) => !baselineUntracked.has(filePath))
+        ...repoState.untrackedFiles.filter((filePath) => !baselineUntracked.has(filePath)),
+        ...baselineContentChanges
     ]);
 }
+function repoFileDiffersFromSnapshot(repoRoot, snapshot) {
+    try {
+        const current = readFileSync(resolveRepoPath(repoRoot, snapshot.path));
+        return current.toString("base64") !== snapshot.contentBase64;
+    }
+    catch {
+        return true;
+    }
+}
 export async function captureRollbackBoundary(input) {
     if (!input.repoRoot) {
         return undefined;

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

@@ -15,14 +15,6 @@ export interface RouteDecision {
     blockedSteps: string[];
     compressed: boolean;
     compressionSummary?: string;
-    /**
-     * Recommended model tier based on task complexity and route.
-     * Follows cost-aware routing: direct → haiku/sonnet, manager → sonnet,
-     * consensus → opus. Never use a more expensive model than the task needs.
-     */
-    recommendedModelTier: "haiku" | "sonnet" | "opus";
-    /** Estimated cost saving vs always using sonnet */
-    estimatedSavingVsSonnetUsd: number;
 }
 export interface RouteClassificationInput {
     objective: string;
@@ -37,40 +29,6 @@ export interface RouteClassificationInput {
     /** Historical success rate for similar tasks with direct execution (0-1). */
     historicalDirectSuccessRate?: number;
 }
-/**
- * Resolve a tier to a concrete model ID for a specific engine.
- * Allows downstream adapters to switch models automatically.
- */
-export declare function resolveModelForTier(tier: RouteDecision["recommendedModelTier"], engine: "claude" | "codex" | "gemini" | "openai" | string): string;
-/**
- * Available engine registry — describes what's installed and its capability.
- * Populated by doctor/preflight from PATH and env var detection.
- */
-export interface AvailableEngine {
-    id: string;
-    available: boolean;
-    /** Cost tier: cheap < mid < expensive */
-    costTier: "cheap" | "mid" | "expensive";
-    /** Capability tier: determines which task types this engine can handle */
-    capabilityTier: "haiku" | "sonnet" | "opus";
-}
-/**
- * Select the best available engine for a given tier requirement.
- *
- * When multiple engines are available, picks the cheapest that meets
- * the capability requirement. Falls back gracefully:
- * - If required tier unavailable, upgrades to next tier of same engine
- * - If only one engine family available, uses its best equivalent
- *
- * @param requiredTier - Minimum capability tier needed
- * @param availableEngines - What's installed and authenticated
- * @returns Best engine ID and concrete model to use
- */
-export declare function selectBestEngine(requiredTier: RouteDecision["recommendedModelTier"], availableEngines: AvailableEngine[]): {
-    engineId: string;
-    model: string;
-    reasoning: string;
-};
 export declare function classifyRoute(input: RouteClassificationInput): RouteDecision;
 /**
  * Checks whether a run's Pre Work Burn exceeds the routing policy limits.