@martinloop/mcp 0.3.9 → 0.5.1

package/dist/vendor/core/routing.js

@@ -84,144 +84,6 @@ function calculateDirectConfidence(signals, input) {
 // ---------------------------------------------------------------------------
 // Public API
 // ---------------------------------------------------------------------------
-// ---------------------------------------------------------------------------
-// Cost-aware model tier routing
-//
-// Engine-agnostic tier system — each engine maps tiers to real model IDs.
-// Never pay for reasoning/orchestration on simple tasks.
-//
-// Tier → concrete model per engine:
-//   haiku  → claude-haiku-4-5, gpt-4o-mini, gemini-2.5-flash, deepseek-chat, qwen3-8b,  llama-3.1-8b
-//   sonnet → claude-sonnet-4-6, gpt-4o,     gemini-2.5-pro,  deepseek-r1,   qwen3-32b, llama-3.3-70b
-//   opus   → claude-opus-4-6,  o3,          gemini-2.5-ultra, deepseek-r1-671b, qwen3-235b, llama-3.1-405b
-//
-// Pricing reference (USD per 1M tokens, approx 2026):
-//   haiku:  $0.80 input / $4.00 output  (~1x baseline)
-//   sonnet: $3.00 input / $15.00 output (~4x haiku)
-//   opus:   $15.00 input / $75.00 output (~19x haiku)
-// ---------------------------------------------------------------------------
-const SONNET_AVG_COST_PER_USD_BUDGET = 0.35; // sonnet uses ~35% of budget on average
-const HAIKU_AVG_COST_PER_USD_BUDGET = 0.10; // haiku uses ~10% — ~3.5x cheaper
-function selectModelTier(mode) {
-    // Route already encodes complexity. Direct = passed the simplicity check → haiku.
-    if (mode === "direct")
-        return "haiku";
-    if (mode === "manager")
-        return "sonnet";
-    return "opus";
-}
-/**
- * Resolve a tier to a concrete model ID for a specific engine.
- * Allows downstream adapters to switch models automatically.
- */
-export function resolveModelForTier(tier, engine) {
-    const matrix = {
-        claude: {
-            haiku: "claude-haiku-4-5-20251001",
-            sonnet: "claude-sonnet-4-6",
-            opus: "claude-opus-4-6"
-        },
-        codex: {
-            haiku: "gpt-4o-mini",
-            sonnet: "gpt-4.1",
-            opus: "o3"
-        },
-        gemini: {
-            haiku: "gemini-2.5-flash",
-            sonnet: "gemini-2.5-pro",
-            opus: "gemini-2.5-ultra"
-        },
-        openai: {
-            haiku: "gpt-4o-mini",
-            sonnet: "gpt-4o",
-            opus: "o3"
-        },
-        deepseek: {
-            haiku: "deepseek-chat",
-            sonnet: "deepseek-r1",
-            opus: "deepseek-r1"
-        },
-        qwen: {
-            haiku: "qwen/qwen3-8b",
-            sonnet: "qwen/qwen3-32b",
-            opus: "qwen/qwen3-235b-a22b"
-        },
-        llama: {
-            haiku: "meta-llama/llama-3.1-8b-instruct",
-            sonnet: "meta-llama/llama-3.3-70b-instruct",
-            opus: "meta-llama/llama-3.1-405b-instruct"
-        }
-    };
-    const engineKey = engine.toLowerCase().split("-")[0] ?? engine;
-    const claudeMatrix = matrix.claude;
-    return matrix[engineKey]?.[tier] ?? claudeMatrix?.[tier] ?? "claude-sonnet-4-6";
-}
-function estimateSavingVsSonnet(tier, budgetUsd) {
-    if (tier === "sonnet")
-        return 0;
-    if (tier === "haiku")
-        return Math.round((SONNET_AVG_COST_PER_USD_BUDGET - HAIKU_AVG_COST_PER_USD_BUDGET) * budgetUsd * 100) / 100;
-    // opus costs more than sonnet — negative saving
-    return Math.round(-1 * SONNET_AVG_COST_PER_USD_BUDGET * budgetUsd * 0.5 * 100) / 100;
-}
-/**
- * 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 function selectBestEngine(requiredTier, availableEngines) {
-    const available = availableEngines.filter((e) => e.available);
-    if (available.length === 0) {
-        // Nothing detected — default to claude (user must install)
-        return {
-            engineId: "claude",
-            model: resolveModelForTier(requiredTier, "claude"),
-            reasoning: "No engines detected. Defaulting to claude. Run martin doctor for setup instructions."
-        };
-    }
-    const tierRank = {
-        haiku: 0, sonnet: 1, opus: 2
-    };
-    const requiredRank = tierRank[requiredTier];
-    // Find the cheapest engine that meets or exceeds the required tier
-    const eligible = available
-        .filter((e) => tierRank[e.capabilityTier] >= requiredRank)
-        .sort((a, b) => {
-        // Sort by cost (cheap first), then by exact tier match
-        const costOrder = { cheap: 0, mid: 1, expensive: 2 };
-        if (costOrder[a.costTier] !== costOrder[b.costTier]) {
-            return costOrder[a.costTier] - costOrder[b.costTier];
-        }
-        // Prefer exact tier match over overqualified
-        const aExact = a.capabilityTier === requiredTier ? 0 : 1;
-        const bExact = b.capabilityTier === requiredTier ? 0 : 1;
-        return aExact - bExact;
-    });
-    if (eligible.length > 0) {
-        const best = eligible[0];
-        const model = resolveModelForTier(requiredTier, best.id);
-        return {
-            engineId: best.id,
-            model,
-            reasoning: `Selected ${best.id} (${model}) as cheapest available engine for ${requiredTier}-tier task.`
-        };
-    }
-    // All available engines are below required tier — upgrade to best available
-    const best = available.sort((a, b) => tierRank[b.capabilityTier] - tierRank[a.capabilityTier])[0];
-    const model = resolveModelForTier(best.capabilityTier, best.id);
-    return {
-        engineId: best.id,
-        model,
-        reasoning: `No ${requiredTier}-tier engine available. Upgrading to ${best.id} (${model}) — best available.`
-    };
-}
 export function classifyRoute(input) {
     const policy = { ...DEFAULT_ROUTING_POLICY, ...input.policy };
     const signals = extractComplexitySignals(input);
@@ -230,7 +92,6 @@ export function classifyRoute(input) {
     const blockedSteps = [];
     // Policy override: forced mode
     if (policy.mode === "direct") {
-        const tier = selectModelTier("direct");
         return {
             selectedMode: "direct",
             confidence: 1,
@@ -239,13 +100,10 @@ export function classifyRoute(input) {
             reason: ["Policy forces direct execution mode."],
             blockedSteps: ["manager", "planner", "router", "consensus"],
             compressed: true,
-            compressionSummary: "Policy: direct mode — skipping all orchestration.",
-            recommendedModelTier: tier,
-            estimatedSavingVsSonnetUsd: estimateSavingVsSonnet(tier, input.budgetUsd)
+            compressionSummary: "Policy: direct mode — skipping all orchestration."
         };
     }
     if (policy.mode === "consensus") {
-        const tier = selectModelTier("consensus");
         return {
             selectedMode: "consensus",
             confidence: 0.5,
@@ -253,9 +111,7 @@ export function classifyRoute(input) {
             expectedPreworkBurnPct: 35,
             reason: ["Policy forces consensus mode."],
             blockedSteps: [],
-            compressed: false,
-            recommendedModelTier: tier,
-            estimatedSavingVsSonnetUsd: estimateSavingVsSonnet(tier, input.budgetUsd)
+            compressed: false
         };
     }
     // Adaptive routing
@@ -268,7 +124,6 @@ export function classifyRoute(input) {
         if (signals.scopeRestricted)
             reason.push("Path scope is restricted.");
         blockedSteps.push("manager", "consensus");
-        const tier = selectModelTier("direct");
         return {
             selectedMode: "direct",
             confidence: directConfidence,
@@ -277,9 +132,7 @@ export function classifyRoute(input) {
             reason,
             blockedSteps,
             compressed: true,
-            compressionSummary: `Compressed from manager→planner→worker to direct worker. Estimated savings: ${String(Math.round(input.budgetUsd * 0.3 * 100) / 100)} USD.`,
-            recommendedModelTier: tier,
-            estimatedSavingVsSonnetUsd: estimateSavingVsSonnet(tier, input.budgetUsd)
+            compressionSummary: `Compressed from manager→planner→worker to direct worker. Estimated savings: ${String(Math.round(input.budgetUsd * 0.3 * 100) / 100)} USD.`
         };
     }
     // Complex task — needs orchestration
@@ -293,7 +146,6 @@ export function classifyRoute(input) {
         reason.push(`Touches ${String(signals.fileCount)}+ files.`);
     const needsConsensus = signals.hasSecurityKeywords && signals.hasMigrationKeywords;
     const mode = needsConsensus ? "consensus" : "manager";
-    const tier = selectModelTier(mode);
     return {
         selectedMode: mode,
         confidence: directConfidence,
@@ -301,9 +153,7 @@ export function classifyRoute(input) {
         expectedPreworkBurnPct: needsConsensus ? 40 : 25,
         reason,
         blockedSteps: needsConsensus ? [] : ["consensus"],
-        compressed: false,
-        recommendedModelTier: tier,
-        estimatedSavingVsSonnetUsd: estimateSavingVsSonnet(tier, input.budgetUsd)
+        compressed: false
     };
 }
 function estimateDirectCost(budgetUsd) {

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

@@ -0,0 +1,13 @@
+import type { LoopRecord } from "../contracts/index.js";
+import type { ExitDecision } from "./policy.js";
+export interface AvoidedUsdInput {
+    lifecycleState: LoopRecord["lifecycleState"];
+    actualUsd: number;
+    uncontrolledBaselineUsd?: number;
+}
+export declare function calculateAvoidedUsd(input: AvoidedUsdInput): number;
+export declare function calculateLoopAvoidedUsd(input: {
+    loop: LoopRecord;
+    decision: ExitDecision;
+    uncontrolledBaselineUsd?: number;
+}): number;

package/dist/vendor/core/savings.js

@@ -0,0 +1,22 @@
+export function calculateAvoidedUsd(input) {
+    if (input.lifecycleState !== "completed")
+        return 0;
+    if (!Number.isFinite(input.actualUsd) || input.actualUsd < 0)
+        return 0;
+    if (input.uncontrolledBaselineUsd === undefined ||
+        !Number.isFinite(input.uncontrolledBaselineUsd) ||
+        input.uncontrolledBaselineUsd <= input.actualUsd) {
+        return 0;
+    }
+    return roundUsd(input.uncontrolledBaselineUsd - input.actualUsd);
+}
+export function calculateLoopAvoidedUsd(input) {
+    return calculateAvoidedUsd({
+        lifecycleState: input.decision.lifecycleState,
+        actualUsd: input.loop.cost.actualUsd,
+        uncontrolledBaselineUsd: input.uncontrolledBaselineUsd
+    });
+}
+function roundUsd(value) {
+    return Math.round(value * 100) / 100;
+}

package/dist/vendor/core/termination-store.d.ts

@@ -0,0 +1,15 @@
+import type { TerminationEnvelopeV1 } from "../contracts/index.js";
+/**
+ * Atomically persist the termination envelope for a governed run.
+ *
+ * Crash-safe write sequence (mirrors exit-signal.ts atomic publication):
+ *   1. Write complete JSON to a unique tmp file (wx, 0o600) in runDirectory
+ *   2. Sync and close the tmp file
+ *   3. Hard-link tmp → termination.json (EEXIST → slot already occupied)
+ *   4. On EEXIST, read and return the existing envelope
+ *   5. Unlink the tmp file in finally (best-effort)
+ *
+ * First terminal exit path wins — competing callers that hit EEXIST get back
+ * the envelope that won the race.  This is the A1 idempotency guarantee.
+ */
+export declare function persistTerminationEnvelope(runDirectory: string, envelope: TerminationEnvelopeV1): Promise<TerminationEnvelopeV1>;

package/dist/vendor/core/termination-store.js

@@ -0,0 +1,44 @@
+import { link, open, readFile, unlink } from "node:fs/promises";
+import { join } from "node:path";
+import { randomUUID } from "node:crypto";
+/**
+ * Atomically persist the termination envelope for a governed run.
+ *
+ * Crash-safe write sequence (mirrors exit-signal.ts atomic publication):
+ *   1. Write complete JSON to a unique tmp file (wx, 0o600) in runDirectory
+ *   2. Sync and close the tmp file
+ *   3. Hard-link tmp → termination.json (EEXIST → slot already occupied)
+ *   4. On EEXIST, read and return the existing envelope
+ *   5. Unlink the tmp file in finally (best-effort)
+ *
+ * First terminal exit path wins — competing callers that hit EEXIST get back
+ * the envelope that won the race.  This is the A1 idempotency guarantee.
+ */
+export async function persistTerminationEnvelope(runDirectory, envelope) {
+    const finalPath = join(runDirectory, "termination.json");
+    const tmpPath = join(runDirectory, `.termination-tmp-${randomUUID()}.json`);
+    const json = `${JSON.stringify(envelope, null, 2)}\n`;
+    let handle;
+    try {
+        handle = await open(tmpPath, "wx", 0o600);
+        await handle.writeFile(json, "utf8");
+        await handle.sync();
+        await handle.close();
+        handle = undefined;
+        try {
+            await link(tmpPath, finalPath);
+            return envelope;
+        }
+        catch (linkErr) {
+            if (linkErr.code !== "EEXIST")
+                throw linkErr;
+            // Another path won the race — read what's on disk and return it
+            const existing = await readFile(finalPath, "utf8");
+            return JSON.parse(existing);
+        }
+    }
+    finally {
+        await handle?.close().catch(() => undefined);
+        await unlink(tmpPath).catch(() => undefined);
+    }
+}

package/dist/vendor/core/verified-handoff.d.ts

@@ -0,0 +1,72 @@
+import type { ExecutionMode, LoopRecord, ReceiptIntegritySummary, TestIntegrityStatus, TestIntegrityVerdict, VerifiedHandoffOutcome, VerifiedHandoffRecoveryV1, VerifiedHandoffRequirementV1, VerifiedHandoffScopeV1, VerifiedHandoffTestIntegrityV1, VerifiedHandoffV1 } from "../contracts/index.js";
+export declare function toTestIntegrityVerdict(status: TestIntegrityStatus): TestIntegrityVerdict;
+export interface VerifierExecutionBinding {
+    runId: string;
+    workspaceId: string;
+    cwd: string;
+    commands: string[];
+}
+export interface BoundVerifierEvidence {
+    passed: boolean;
+    binding?: VerifierExecutionBinding;
+    steps?: Array<{
+        command: string;
+        launched: boolean;
+        completed?: boolean;
+        crashed?: boolean;
+        exitCode?: number;
+        timedOut?: boolean;
+    }>;
+}
+export declare function verifierActuallyPassed(evidence: BoundVerifierEvidence | null | undefined, expected: VerifierExecutionBinding): boolean;
+export declare function resolveVerifiedHandoffOutcome(input: {
+    lifecycleState: LoopRecord["lifecycleState"];
+    executionStatus?: "completed" | "write_blocked" | "sandbox_blocked" | "policy_rejected" | "failed";
+    verificationStatus: BuildVerifiedHandoffInput["verification"]["status"];
+    receiptIntegrity: ReceiptIntegritySummary["state"];
+    scopeStatus?: VerifiedHandoffScopeV1["status"];
+    testIntegrityStatus?: TestIntegrityStatus;
+    mutationRequired?: boolean;
+    changedFileCount?: number;
+    definitionOfDonePreSatisfied?: boolean;
+    evidenceContradicted?: boolean;
+    governanceClaimEligible?: boolean;
+    unresolvedWorkCount: number;
+}): VerifiedHandoffOutcome;
+export declare function deriveVerifiedHandoffExecutionBoundary(loop: LoopRecord): {
+    executionMode: ExecutionMode;
+    governanceClaimEligible: boolean;
+};
+export interface BuildVerifiedHandoffInput {
+    loop: LoopRecord;
+    generatedAt?: string;
+    receiptIntegrity: ReceiptIntegritySummary;
+    verification: {
+        status: "passed" | "failed" | "contradicted" | "not_run";
+        summary: string;
+        steps: Array<{
+            command: string;
+            launched: boolean;
+            completed?: boolean;
+            crashed?: boolean;
+            exitCode?: number;
+            timedOut?: boolean;
+            detail?: string;
+        }>;
+        warnings: string[];
+        binding?: VerifierExecutionBinding;
+    };
+    executionStatus?: "completed" | "write_blocked" | "sandbox_blocked" | "policy_rejected" | "failed";
+    mutationRequired?: boolean;
+    definitionOfDonePreSatisfied?: boolean;
+    evidenceContradicted?: boolean;
+    changedFiles?: string[];
+    scope?: Partial<VerifiedHandoffScopeV1>;
+    testIntegrity?: Partial<VerifiedHandoffTestIntegrityV1>;
+    requirements?: VerifiedHandoffRequirementV1[];
+    unresolvedWork?: string[];
+    stopReason?: string;
+    recovery?: Partial<VerifiedHandoffRecoveryV1>;
+    nextAction: string;
+}
+export declare function buildVerifiedHandoff(input: BuildVerifiedHandoffInput): VerifiedHandoffV1;

package/dist/vendor/core/verified-handoff.js

@@ -0,0 +1,238 @@
+// SPDX-FileCopyrightText: MartinLoop contributors
+// SPDX-License-Identifier: Apache-2.0
+import { createHash } from "node:crypto";
+// ---------------------------------------------------------------------------
+// Mapping: granular TestIntegrityStatus → public TestIntegrityVerdict
+//
+// A new enum value MUST appear here or TypeScript compilation will fail,
+// ensuring the mapping is always exhaustive.
+// ---------------------------------------------------------------------------
+export function toTestIntegrityVerdict(status) {
+    switch (status) {
+        case "UNCHANGED":
+        case "AUTHORIZED_CHANGE":
+            return "VERIFIED";
+        case "PREVENTED":
+        case "DETECTED_AND_ROLLED_BACK":
+        case "DETECTED_NEEDS_REVIEW":
+            return "TAMPERING_DETECTED";
+        case "NOT_EVALUATED":
+            return "NOT_EVALUATED";
+    }
+}
+// ---------------------------------------------------------------------------
+// Outcome resolution — deterministic, no hidden defaults
+// ---------------------------------------------------------------------------
+const STOPPED_LIFECYCLE_STATES = new Set([
+    "budget_exit",
+    "diminishing_returns",
+    "stuck_exit",
+    "human_escalation",
+]);
+export function verifierActuallyPassed(evidence, expected) {
+    if (!evidence?.passed || !evidence.binding || !evidence.steps) {
+        return false;
+    }
+    if (evidence.binding.runId !== expected.runId ||
+        evidence.binding.workspaceId !== expected.workspaceId ||
+        evidence.binding.cwd !== expected.cwd ||
+        JSON.stringify(evidence.binding.commands) !== JSON.stringify(expected.commands)) {
+        return false;
+    }
+    if (evidence.steps.length !== expected.commands.length) {
+        return false;
+    }
+    return evidence.steps.every((step, index) => step.command === expected.commands[index] &&
+        step.launched === true &&
+        step.completed === true &&
+        step.crashed === false &&
+        step.timedOut !== true &&
+        step.exitCode === 0);
+}
+export function resolveVerifiedHandoffOutcome(input) {
+    if (STOPPED_LIFECYCLE_STATES.has(input.lifecycleState) ||
+        input.executionStatus === "write_blocked" ||
+        input.executionStatus === "sandbox_blocked" ||
+        input.executionStatus === "policy_rejected") {
+        return "STOPPED";
+    }
+    if (input.executionStatus === "failed" ||
+        input.governanceClaimEligible === false ||
+        input.evidenceContradicted === true ||
+        (input.mutationRequired === true &&
+            (input.changedFileCount ?? 0) === 0 &&
+            input.definitionOfDonePreSatisfied !== true)) {
+        return "NEEDS_REVIEW";
+    }
+    const evidenceTrustworthy = input.receiptIntegrity === "verified";
+    const scopeAcceptable = input.scopeStatus === undefined ||
+        input.scopeStatus === "WITHIN_SCOPE" ||
+        input.scopeStatus === "NOT_EVALUATED";
+    const testIntegrityAcceptable = input.testIntegrityStatus === undefined ||
+        input.testIntegrityStatus === "UNCHANGED" ||
+        input.testIntegrityStatus === "AUTHORIZED_CHANGE" ||
+        input.testIntegrityStatus === "NOT_EVALUATED";
+    if (input.verificationStatus === "passed" &&
+        evidenceTrustworthy &&
+        scopeAcceptable &&
+        testIntegrityAcceptable &&
+        input.unresolvedWorkCount === 0) {
+        return "VERIFIED";
+    }
+    return "NEEDS_REVIEW";
+}
+const SIMULATED_ADAPTER_PATTERN = /(?:^|:)(?:stub|fixture|synthetic)(?::|$)/u;
+function isExecutionMode(value) {
+    return value === "governed" || value === "verification_only" || value === "simulated";
+}
+export function deriveVerifiedHandoffExecutionBoundary(loop) {
+    const adapterIds = loop.attempts.map((attempt) => attempt.adapterId);
+    const hasSimulatedAdapter = adapterIds.some((adapterId) => adapterId === "direct:proof:no-mutation" ||
+        SIMULATED_ADAPTER_PATTERN.test(adapterId));
+    const hasVerifierOnlyAdapter = adapterIds.some((adapterId) => adapterId === "direct:verifier:verify-only");
+    const persistedMode = isExecutionMode(loop.metadata["executionMode"])
+        ? loop.metadata["executionMode"]
+        : undefined;
+    const groundingEvidenceAvailable = loop.metadata["groundingEvidenceStatus"] !== "unavailable";
+    const executionMode = hasSimulatedAdapter
+        ? "simulated"
+        : hasVerifierOnlyAdapter
+            ? "verification_only"
+            : persistedMode ?? (adapterIds.length > 0 ? "governed" : "simulated");
+    return {
+        executionMode,
+        governanceClaimEligible: executionMode === "governed" && adapterIds.length > 0 && groundingEvidenceAvailable,
+    };
+}
+function toEvidenceStatus(status) {
+    switch (status) {
+        case "passed":
+            return "PASSED";
+        case "failed":
+            return "FAILED";
+        case "contradicted":
+            return "CONTRADICTED";
+        case "not_run":
+            return "NOT_RUN";
+    }
+}
+function toCheck(step) {
+    const status = !step.launched
+        ? "NOT_RUN"
+        : step.timedOut
+            ? "FAILED"
+            : step.exitCode === 0
+                ? "PASSED"
+                : "FAILED";
+    return {
+        command: step.command,
+        status,
+        ...(step.exitCode !== undefined ? { exitCode: step.exitCode } : {}),
+        ...(step.timedOut !== undefined ? { timedOut: step.timedOut } : {}),
+        ...(step.detail ? { detail: step.detail } : {}),
+    };
+}
+// ---------------------------------------------------------------------------
+// Main builder
+// ---------------------------------------------------------------------------
+export function buildVerifiedHandoff(input) {
+    const generatedAt = input.generatedAt ?? new Date().toISOString();
+    const changedFiles = input.changedFiles ?? [];
+    const unresolvedWork = input.unresolvedWork ?? [];
+    const scope = {
+        status: input.scope?.status ?? "NOT_EVALUATED",
+        allowedPaths: input.scope?.allowedPaths ?? input.loop.task.allowedPaths ?? [],
+        deniedPaths: input.scope?.deniedPaths ?? input.loop.task.deniedPaths ?? [],
+        changedFiles: input.scope?.changedFiles ?? changedFiles,
+        violations: input.scope?.violations ?? [],
+    };
+    const testIntegrityStatus = input.testIntegrity?.status ?? "NOT_EVALUATED";
+    const testIntegrity = {
+        verdict: toTestIntegrityVerdict(testIntegrityStatus),
+        status: testIntegrityStatus,
+        protectedPaths: input.testIntegrity?.protectedPaths ?? [],
+        changedProtectedPaths: input.testIntegrity?.changedProtectedPaths ?? [],
+        findings: input.testIntegrity?.findings ?? [],
+        summary: input.testIntegrity?.summary ??
+            "Test integrity was not evaluated for this run.",
+    };
+    const executionBoundary = deriveVerifiedHandoffExecutionBoundary(input.loop);
+    const outcome = resolveVerifiedHandoffOutcome({
+        lifecycleState: input.loop.lifecycleState,
+        executionStatus: input.executionStatus,
+        verificationStatus: input.verification.status,
+        receiptIntegrity: input.receiptIntegrity.state,
+        scopeStatus: scope.status,
+        testIntegrityStatus: testIntegrity.status,
+        mutationRequired: input.mutationRequired ?? input.loop.task.mutationMode === "edit",
+        changedFileCount: scope.changedFiles.length,
+        definitionOfDonePreSatisfied: input.definitionOfDonePreSatisfied,
+        evidenceContradicted: input.evidenceContradicted ?? input.verification.status === "contradicted",
+        governanceClaimEligible: executionBoundary.governanceClaimEligible,
+        unresolvedWorkCount: unresolvedWork.length,
+    });
+    const handoffId = `vh_${createHash("sha256")
+        .update(`${input.loop.loopId}:${generatedAt}`)
+        .digest("hex")
+        .slice(0, 16)}`;
+    return {
+        schemaVersion: "1.0.0",
+        handoffId,
+        loopId: input.loop.loopId,
+        generatedAt,
+        task: {
+            title: input.loop.task.title,
+            objective: input.loop.task.objective,
+        },
+        definitionOfDone: {
+            acceptanceCriteria: input.loop.task.acceptanceCriteria ?? [],
+            verificationPlan: input.loop.task.verificationPlan,
+        },
+        outcome,
+        executionMode: executionBoundary.executionMode,
+        governanceClaimEligible: executionBoundary.governanceClaimEligible,
+        sourceStatus: {
+            status: input.loop.status,
+            lifecycleState: input.loop.lifecycleState,
+        },
+        verification: {
+            status: toEvidenceStatus(input.verification.status),
+            summary: input.verification.summary,
+            checks: input.verification.steps.map(toCheck),
+            warnings: input.verification.warnings,
+        },
+        requirements: input.requirements ?? [],
+        scope,
+        testIntegrity,
+        unresolvedWork,
+        ...(input.stopReason ? { stopReason: input.stopReason } : {}),
+        recovery: {
+            rollbackBoundaryAvailable: input.recovery?.rollbackBoundaryAvailable ?? false,
+            rollbackAttempted: input.recovery?.rollbackAttempted ?? false,
+            ...(input.recovery?.rollbackSucceeded !== undefined
+                ? { rollbackSucceeded: input.recovery.rollbackSucceeded }
+                : {}),
+            ...(input.recovery?.isolatedRef
+                ? { isolatedRef: input.recovery.isolatedRef }
+                : {}),
+            ...(input.recovery?.nextCommand
+                ? { nextCommand: input.recovery.nextCommand }
+                : {}),
+            summary: input.recovery?.summary ??
+                "No explicit recovery evidence was supplied to the handoff builder.",
+        },
+        usage: {
+            attempts: input.loop.attempts.length,
+            actualUsd: input.loop.cost.actualUsd,
+            ...(input.loop.cost.estimatedUsd !== undefined
+                ? { estimatedUsd: input.loop.cost.estimatedUsd }
+                : {}),
+            tokensIn: input.loop.cost.tokensIn,
+            tokensOut: input.loop.cost.tokensOut,
+            costProvenance: input.loop.cost.provenance ??
+                "unavailable",
+        },
+        receiptIntegrity: input.receiptIntegrity,
+        nextAction: input.nextAction,
+    };
+}

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@martinloop/mcp",
-  "version": "0.3.9",
+  "version": "0.5.1",
   "mcpName": "io.github.Keesan12/martin-loop",
   "private": false,
   "type": "module",
-  "description": "Governed MCP server for AI coding agents with budgets, verifier gates, and inspectable runs.",
+  "description": "MCP server for AI coding agents — verifier gates, stop limits, and Verified Handoffs.",
   "license": "Apache-2.0",
   "author": "MartinLoop contributors",
   "homepage": "https://martinloop.com/",
@@ -18,18 +18,11 @@
   },
   "keywords": [
     "mcp",
-    "mcp-server",
     "model-context-protocol",
     "martin-loop",
     "ai-agent",
-    "ai-governance",
-    "agent-governance",
     "claude",
-    "claude-code",
     "codex",
-    "cursor",
-    "budget-guardrails",
-    "verifier-gates",
     "martin_doctor",
     "martin_triage_runs",
     "martin_run_dossier",
@@ -68,7 +61,8 @@
     "start": "node dist/server.js",
     "inspect:live": "node ./scripts/inspect-live.mjs",
     "mcpb:build": "node ./mcpb/build-mcpb.mjs",
-    "mcpb:validate": "mcpb validate ./dist-mcpb/martinloop"
+    "mcpb:validate": "mcpb validate ./dist-mcpb/martinloop",
+    "mcpb:smoke": "node ./mcpb/smoke-mcpb.mjs"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",