@martinloop/mcp 0.3.9 → 0.5.0

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

@@ -0,0 +1,210 @@
+// 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.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";
+}
+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 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",
+        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,
+        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.0",
   "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",
@@ -66,9 +59,7 @@
     "test": "vitest run --maxWorkers=1",
     "lint": "tsc -p tsconfig.json --noEmit",
     "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"
+    "inspect:live": "node ./scripts/inspect-live.mjs"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
@@ -80,7 +71,6 @@
     "ts-morph": "^21.0.0"
   },
   "devDependencies": {
-    "@anthropic-ai/mcpb": "2.1.2",
     "@martin/contracts": "workspace:*"
   }
 }

package/server.json

@@ -2,17 +2,17 @@
   "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
   "name": "io.github.Keesan12/martin-loop",
   "title": "Martin Loop",
-  "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.",
   "repository": {
     "url": "https://github.com/Keesan12/martin-loop",
     "source": "github"
   },
-  "version": "0.3.9",
+  "version": "0.5.0",
   "packages": [
     {
       "registryType": "npm",
       "identifier": "@martinloop/mcp",
-      "version": "0.3.9",
+      "version": "0.5.0",
       "transport": {
         "type": "stdio"
       }

package/dist/vendor/adapters/stub-agent-cli.d.ts

@@ -1,8 +0,0 @@
-import type { MartinAdapter, MartinAdapterRequest, MartinAdapterResult } from "../core/index.js";
-export interface StubAgentCliAdapterOptions {
-    command: string[];
-    profile?: string;
-    label?: string;
-    responder?: (request: MartinAdapterRequest) => Promise<MartinAdapterResult> | MartinAdapterResult;
-}
-export declare function createStubAgentCliAdapter(options: StubAgentCliAdapterOptions): MartinAdapter;

package/dist/vendor/adapters/stub-agent-cli.js

@@ -1,40 +0,0 @@
-import { createAdapterCapabilities } from "./runtime-support.js";
-export function createStubAgentCliAdapter(options) {
-    const metadata = {
-        command: options.command.join(" "),
-        providerId: "agent-cli",
-        model: options.profile ?? options.command[0] ?? "default",
-        transport: "cli",
-        capabilities: createAdapterCapabilities(),
-        ...(options.profile ? { profile: options.profile } : {})
-    };
-    return {
-        adapterId: `agent-cli:${options.command.join(":")}`,
-        kind: "agent-cli",
-        label: options.label ?? `Stub agent CLI (${options.command.join(" ")})`,
-        metadata,
-        async execute(request) {
-            if (options.responder) {
-                return await options.responder(request);
-            }
-            return {
-                status: "failed",
-                summary: `Stub agent CLI ${options.command.join(" ")} did not execute a live session.`,
-                usage: {
-                    actualUsd: 0,
-                    tokensIn: 0,
-                    tokensOut: 0,
-                    provenance: "unavailable"
-                },
-                verification: {
-                    passed: false,
-                    summary: "No CLI execution was attempted."
-                },
-                failure: {
-                    message: `Agent CLI ${options.command.join(" ")} is not configured for live execution.`,
-                    classHint: "environment_mismatch"
-                }
-            };
-        }
-    };
-}

package/dist/vendor/adapters/verifier-only.d.ts

@@ -1,9 +0,0 @@
-import type { MartinAdapter } from "../core/index.js";
-import { type SpawnLike } from "./cli-bridge.js";
-export interface VerifierOnlyAdapterOptions {
-    workingDirectory?: string;
-    verifyTimeoutMs?: number;
-    label?: string;
-    spawnImpl?: SpawnLike;
-}
-export declare function createVerifierOnlyAdapter(options?: VerifierOnlyAdapterOptions): MartinAdapter;

package/dist/vendor/adapters/verifier-only.js

@@ -1,63 +0,0 @@
-import { readGitChangedFiles, runVerification } from "./cli-bridge.js";
-import { createAdapterCapabilities, normalizeUsage } from "./runtime-support.js";
-export function createVerifierOnlyAdapter(options = {}) {
-    const workingDirectory = options.workingDirectory ?? process.cwd();
-    const verifyTimeoutMs = options.verifyTimeoutMs ?? 120_000;
-    return {
-        adapterId: "direct:verifier:verify-only",
-        kind: "direct-provider",
-        label: options.label ?? "Verifier-only adapter",
-        metadata: {
-            providerId: "verifier",
-            model: "verify-only",
-            transport: "cli",
-            capabilities: createAdapterCapabilities({
-                usageSettlement: true,
-                diffArtifacts: true
-            })
-        },
-        async execute(request) {
-            const shouldTrackVerifierWrites = request.context.verificationPlan.length > 0 ||
-                (request.context.verificationStack?.length ?? 0) > 0;
-            const baselineChangedFiles = shouldTrackVerifierWrites
-                ? new Set(await readGitChangedFiles(workingDirectory, 5_000, options.spawnImpl))
-                : new Set();
-            const verification = await runVerification(request.context.verificationPlan, workingDirectory, verifyTimeoutMs, request.context.verificationStack, options.spawnImpl);
-            const changedFiles = shouldTrackVerifierWrites
-                ? (await readGitChangedFiles(workingDirectory, 5_000, options.spawnImpl)).filter((file) => !baselineChangedFiles.has(file))
-                : [];
-            const execution = { changedFiles };
-            if (verification.passed) {
-                return {
-                    status: "completed",
-                    summary: changedFiles.length > 0
-                        ? `Verifier-only run completed but modified files: ${changedFiles.join(", ")}`
-                        : "Verifier-only run completed without file edits.",
-                    usage: normalizeUsage({
-                        actualUsd: 0,
-                        tokensIn: 0,
-                        tokensOut: 0,
-                        provenance: "actual"
-                    }),
-                    verification,
-                    execution
-                };
-            }
-            return {
-                status: "failed",
-                summary: "Verifier-only run failed.",
-                usage: normalizeUsage({
-                    actualUsd: 0,
-                    tokensIn: 0,
-                    tokensOut: 0,
-                    provenance: "actual"
-                }),
-                verification,
-                execution,
-                failure: {
-                    message: verification.summary
-                }
-            };
-        }
-    };
-}