@martinloop/mcp 0.3.8 → 0.5.0

package/dist/server.js

@@ -16,12 +16,14 @@
  * Manual start:
  *   node dist/server.js
  */
+import { createServer as createHttpServer } from "node:http";
 import { fileURLToPath } from "node:url";
 import { realpathSync } from "node:fs";
 import path from "node:path";
 import { resolveRunsRoot } from "./vendor/core/index.js";
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 import { CallToolRequestSchema, GetPromptRequestSchema, ListPromptsRequestSchema, ListResourcesRequestSchema, ListResourceTemplatesRequestSchema, ListToolsRequestSchema, ReadResourceRequestSchema } from "@modelcontextprotocol/sdk/types.js";
 import { MARTIN_MCP_PACKAGE_VERSION } from "./package-version.js";
 import { getMartinPrompt, listMartinPrompts } from "./prompts.js";
@@ -1401,6 +1403,10 @@ export function createMartinMcpServer(serverInfo) {
                             type: "array",
                             items: { type: "string" },
                             description: "Optional file paths to scope the estimate."
+                        },
+                        workingDirectory: {
+                            type: "string",
+                            description: "Optional workspace path for recording the estimate receipt against the same task root you plan to run."
                         }
                     },
                     required: ["objective"]
@@ -1518,7 +1524,7 @@ export function createMartinMcpServer(serverInfo) {
                     workingDirectory: output.environment.workingDirectory,
                     engine: input.engine,
                     receiptScope: output.receiptScope
-                });
+                }).catch(() => { });
                 return createToolSuccessResult(output, output.summary);
             }
             if (name === "martin_plan") {
@@ -1535,7 +1541,7 @@ export function createMartinMcpServer(serverInfo) {
                         repoRoot: output.workingDirectory,
                         runsRoot: resolveRunsRoot(process.env)
                     }
-                });
+                }).catch(() => { });
                 return createToolSuccessResult(output, `Plan ready for ${output.objective} with ${output.risk.level} risk and ${output.approvalRecommendation.replace(/_/gu, " ")} approval.`);
             }
             if (name === "martin_preflight") {
@@ -1553,7 +1559,7 @@ export function createMartinMcpServer(serverInfo) {
                         allowedPaths: output.normalized.allowedPaths,
                         deniedPaths: output.normalized.deniedPaths,
                         budget: output.normalized.budget
-                    });
+                    }).catch(() => { });
                 }
                 return createToolSuccessResult(output, output.summary);
             }
@@ -1640,8 +1646,8 @@ export function createMartinMcpServer(serverInfo) {
                 const engine = input.engine ?? "claude";
                 const budgetUsd = input.budgetUsd ?? 5;
                 const fileScope = input.fileScope ?? [];
-                const workingDirectory = resolveSafeRepoRoot();
                 const runsRoot = resolveRunsRoot(process.env);
+                const workingDirectory = input.workingDirectory ?? resolveSafeRepoRoot();
                 const route = classifyRoute({
                     objective,
                     verificationPlan: [],
@@ -1673,8 +1679,14 @@ export function createMartinMcpServer(serverInfo) {
                     step: "estimate",
                     workingDirectory,
                     objective,
-                    engine
-                });
+                    engine,
+                    receiptScope: {
+                        invocationRoot: resolveSafeRepoRoot(),
+                        workingDirectory,
+                        repoRoot: workingDirectory,
+                        runsRoot
+                    }
+                }).catch(() => { });
                 return createToolSuccessResult(output, `Estimate: ${route.selectedMode} route (${route.recommendedModelTier}), ~$${route.expectedCostUsd.toFixed(2)} expected cost, ${route.expectedPreworkBurnPct}% pre-work burn. Recommended budget: $${recommendedBudgetUsd.toFixed(2)}.`);
             }
             return createToolErrorResult(toToolFailure(new Error(`Unknown tool: ${name}`)));
@@ -1698,6 +1710,114 @@ export async function connectMartinMcpStdioServer() {
     await server.connect(transport);
     return server;
 }
+export function parseMartinMcpServerArgs(argv) {
+    let transport = "stdio";
+    let host = "127.0.0.1";
+    let port = 3033;
+    let path = "/mcp";
+    for (let index = 0; index < argv.length; index += 1) {
+        const token = argv[index];
+        if (token === "--http") {
+            transport = "http";
+            continue;
+        }
+        if (token === "--port") {
+            const next = argv[index + 1];
+            const parsed = Number(next);
+            if (!Number.isInteger(parsed) || parsed < 0 || parsed > 65535) {
+                throw new Error(`Invalid --port value '${next ?? ""}'.`);
+            }
+            port = parsed;
+            index += 1;
+            continue;
+        }
+        if (token === "--host") {
+            const next = argv[index + 1];
+            if (!next) {
+                throw new Error("Missing value for --host.");
+            }
+            host = next;
+            index += 1;
+            continue;
+        }
+        if (token === "--path") {
+            const next = argv[index + 1];
+            if (!next || !next.startsWith("/")) {
+                throw new Error("MCP HTTP path must start with '/'.");
+            }
+            path = next;
+            index += 1;
+        }
+    }
+    return transport === "http"
+        ? { transport, host, port, path }
+        : { transport };
+}
+export async function connectMartinMcpHttpServer(options = {}) {
+    const host = options.host ?? "127.0.0.1";
+    const port = options.port ?? 3033;
+    const path = options.path ?? "/mcp";
+    const mcpServer = createMartinMcpServer();
+    const transport = new StreamableHTTPServerTransport({
+        sessionIdGenerator: undefined
+    });
+    await mcpServer.connect(transport);
+    const httpServer = createHttpServer(async (req, res) => {
+        try {
+            const requestUrl = new URL(req.url ?? "/", `http://${req.headers.host ?? `${host}:${port}`}`);
+            if (requestUrl.pathname !== path) {
+                res.statusCode = 404;
+                res.setHeader("content-type", "application/json");
+                res.end(JSON.stringify({ error: "not_found", path: requestUrl.pathname }));
+                return;
+            }
+            if (req.method === "POST") {
+                const parsedBody = await readJsonBody(req, res);
+                if (res.writableEnded) {
+                    return;
+                }
+                await transport.handleRequest(req, res, parsedBody);
+                return;
+            }
+            if (req.method === "GET" || req.method === "DELETE") {
+                await transport.handleRequest(req, res);
+                return;
+            }
+            res.statusCode = 405;
+            res.setHeader("allow", "GET, POST, DELETE");
+            res.end();
+        }
+        catch (error) {
+            if (!res.headersSent) {
+                res.statusCode = 500;
+                res.setHeader("content-type", "application/json");
+                res.end(JSON.stringify({ error: "internal_error", message: error.message }));
+            }
+        }
+    });
+    await new Promise((resolve, reject) => {
+        httpServer.once("error", reject);
+        httpServer.listen(port, host, () => {
+            httpServer.off("error", reject);
+            resolve();
+        });
+    });
+    const address = httpServer.address();
+    const resolvedPort = typeof address === "object" && address ? address.port : port;
+    return {
+        server: httpServer,
+        host,
+        port: resolvedPort,
+        path,
+        endpoint: `http://${host}:${resolvedPort}${path}`,
+        close: async () => {
+            await transport.close();
+            await new Promise((resolve) => {
+                httpServer.close(() => resolve());
+            });
+        }
+    };
+}
 export function isDirectExecutionEntry(entryPath, moduleUrl = import.meta.url) {
     if (typeof entryPath !== "string" || entryPath.length === 0) {
         return false;
@@ -1718,5 +1838,30 @@ function realPathOrResolved(filePath) {
     }
 }
 if (isDirectExecution()) {
-    await connectMartinMcpStdioServer();
+    const startup = parseMartinMcpServerArgs(process.argv.slice(2));
+    if (startup.transport === "http") {
+        await connectMartinMcpHttpServer(startup);
+    }
+    else {
+        await connectMartinMcpStdioServer();
+    }
+}
+async function readJsonBody(req, res) {
+    const chunks = [];
+    for await (const chunk of req) {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    const raw = Buffer.concat(chunks).toString("utf8").trim();
+    if (!raw) {
+        return undefined;
+    }
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        res.statusCode = 400;
+        res.setHeader("content-type", "application/json");
+        res.end(JSON.stringify({ error: "invalid_json" }));
+        return undefined;
+    }
 }

package/dist/tools/run-dossier.d.ts

@@ -2,7 +2,7 @@ import { buildArtifactSummary, buildBudgetSnapshot, buildCostSnapshot, buildEven
 import { readRunControlState } from "./run-controls.js";
 import { martinEvalTool } from "./eval.js";
 import { assessRunRisk } from "./workflow-governance.js";
-import type { ReceiptIntegritySummary, ReceiptScope } from "../vendor/contracts/index.js";
+import type { ReceiptIntegritySummary, ReceiptScope, TerminationEnvelopeV1, VerifiedHandoffV1 } from "../vendor/contracts/index.js";
 export interface MartinRunDossierInput {
     file?: string;
     loopId?: string;
@@ -45,6 +45,8 @@ export interface MartinRunDossierOutput {
     };
     evaluation: Awaited<ReturnType<typeof martinEvalTool>>;
     control: Awaited<ReturnType<typeof readRunControlState>>;
+    terminationEnvelope?: TerminationEnvelopeV1;
+    verifiedHandoff: VerifiedHandoffV1;
     format: "json" | "md" | "github-pr";
     rendered?: string;
     inspection: {

package/dist/tools/run-dossier.js

@@ -4,6 +4,7 @@ import { loadDetailedLoopRecord, readAttemptArtifactFiles, readLedgerEvents } fr
 import { readRunControlState } from "./run-controls.js";
 import { martinEvalTool } from "./eval.js";
 import { assessRunRisk, inspectRepoSignals } from "./workflow-governance.js";
+import { buildVerifiedHandoff } from "../vendor/core/index.js";
 export async function martinRunDossierTool(input) {
     const detail = await loadDetailedLoopRecord(input);
     const ledgerEvents = await readLedgerEvents(detail);
@@ -54,6 +55,7 @@ export async function martinRunDossierTool(input) {
         cost: buildCostSnapshot(detail.loop.cost),
         receiptIntegrity: resolveReceiptIntegrity(detail.loop),
         ...(detail.loop.receiptScope ? { receiptScope: detail.loop.receiptScope } : {}),
+        ...(detail.loop.terminationEnvelope ? { terminationEnvelope: detail.loop.terminationEnvelope } : {}),
         attempts,
         verification,
         artifacts: buildArtifactSummary(detail.loop),
@@ -72,7 +74,37 @@ export async function martinRunDossierTool(input) {
             ...(detail.canonicalLoopRecordPath ? { canonicalLoopRecordPath: detail.canonicalLoopRecordPath } : {}),
             ...(detail.ledgerPath ? { ledgerPath: detail.ledgerPath } : {})
         },
-        warnings: [...detail.warnings, ...verification.warnings]
+        warnings: [...detail.warnings, ...verification.warnings],
+        verifiedHandoff: buildVerifiedHandoff({
+            loop: detail.loop,
+            receiptIntegrity: resolveReceiptIntegrity(detail.loop),
+            verification: {
+                status: verification.status,
+                summary: verification.summary ?? "No verification summary recorded.",
+                steps: [],
+                warnings: verification.warnings,
+            },
+            scope: {
+                status: detail.loop.task?.allowedPaths?.length ||
+                    detail.loop.task?.deniedPaths?.length
+                    ? "WITHIN_SCOPE"
+                    : "NOT_EVALUATED",
+                allowedPaths: detail.loop.task?.allowedPaths ?? [],
+                deniedPaths: detail.loop.task?.deniedPaths ?? [],
+                changedFiles: [],
+                violations: [],
+            },
+            testIntegrity: {
+                status: "NOT_EVALUATED",
+                verdict: "NOT_EVALUATED",
+                protectedPaths: [],
+                changedProtectedPaths: [],
+                findings: [],
+                summary: "Automatic test-integrity evidence was not recorded for this run.",
+            },
+            unresolvedWork: verification.status === "passed" ? [] : [verification.summary ?? "Verification did not pass."],
+            nextAction: review.nextAction,
+        }),
     };
     if (output.format !== "json") {
         output.rendered = renderDossier(output);
@@ -81,7 +113,13 @@ export async function martinRunDossierTool(input) {
 }
 function renderDossier(output) {
     const lines = [
-        output.format === "github-pr" ? "## MartinLoop Run Dossier" : "# MartinLoop Run Dossier",
+        output.format === "github-pr" ? "## MartinLoop Verified Handoff" : "# MartinLoop Verified Handoff",
+        "",
+        `Outcome: ${output.verifiedHandoff.outcome}`,
+        `Definition of Done: ${output.verifiedHandoff.definitionOfDone.acceptanceCriteria.length} acceptance criterion/criteria`,
+        `Verification: ${output.verifiedHandoff.verification.status}`,
+        `Scope: ${output.verifiedHandoff.scope.status}`,
+        `Test Integrity: ${output.verifiedHandoff.testIntegrity.verdict}`,
         "",
         `Objective: ${output.loop.objective}`,
         `Run: ${output.loop.loopId}`,

package/dist/tools/run-loop.d.ts

@@ -1,5 +1,4 @@
-import { type SpawnLike } from "../vendor/adapters/index.js";
-import { type RunStore, type RunMartinInput, type RunMartinResult } from "../vendor/core/index.js";
+import { type RunStore } from "../vendor/core/index.js";
 import type { LoopBudget, ReceiptScope } from "../vendor/contracts/index.js";
 import { buildArtifactSummary, buildVerificationSummary, buildLoopPreview, type MartinEngine } from "./tool-support.js";
 export interface RunLoopInput {
@@ -44,7 +43,5 @@ export interface RunLoopOutput {
         artifacts: ReturnType<typeof buildArtifactSummary>;
     };
 }
-export declare function __setProofModeVerifierSpawnImplForTests(spawnImpl?: SpawnLike): void;
 export declare function __setRunStoreOverrideForTests(store?: RunStore): void;
-export declare function __setRunMartinImplForTests(impl?: (input: RunMartinInput) => Promise<RunMartinResult>): void;
 export declare function runLoopTool(input: RunLoopInput): Promise<RunLoopOutput>;

package/dist/tools/run-loop.js

@@ -1,21 +1,13 @@
-import { createClaudeCliAdapter, createCodexCliAdapter, createGeminiCliAdapter, probeCodexLaunch, resolveCliCommandAvailability, createVerifierOnlyAdapter } from "../vendor/adapters/index.js";
+import { createClaudeCliAdapter, createCodexCliAdapter, createGeminiCliAdapter, createStubDirectProviderAdapter, probeCodexLaunch, resolveCliCommandAvailability } from "../vendor/adapters/index.js";
 import { createFileRunStore, evaluateCostGovernor, resolveRunsRoot, runMartin } from "../vendor/core/index.js";
 import { normalizeSafePathPatterns, resolveSafeRepoRoot } from "../server-validation.js";
 import { MartinToolError } from "./tool-errors.js";
 import { buildArtifactSummary, buildVerificationSummary, buildLoopPreview, buildRunRecordPaths, getEngineAvailability, resolveExecutionMode } from "./tool-support.js";
 import { normalizeLoopBudget } from "./workflow-governance.js";
-let proofModeVerifierSpawnImpl;
 let runStoreOverrideForTests;
-let runMartinImpl = runMartin;
-export function __setProofModeVerifierSpawnImplForTests(spawnImpl) {
-    proofModeVerifierSpawnImpl = spawnImpl;
-}
 export function __setRunStoreOverrideForTests(store) {
     runStoreOverrideForTests = store;
 }
-export function __setRunMartinImplForTests(impl) {
-    runMartinImpl = impl ?? runMartin;
-}
 export async function runLoopTool(input) {
     const workingDirectory = resolveSafeRepoRoot(input.workingDirectory);
     const engine = input.engine ?? "claude";
@@ -67,11 +59,10 @@ export async function runLoopTool(input) {
         }
     }
     const adapter = !executionMode.liveMode
-        ? createVerifierOnlyAdapter({
-            workingDirectory,
-            label: "Proof mode adapter (MARTIN_LIVE=false)",
-            ...(input.verifyTimeoutMs !== undefined ? { verifyTimeoutMs: input.verifyTimeoutMs } : {}),
-            ...(proofModeVerifierSpawnImpl ? { spawnImpl: proofModeVerifierSpawnImpl } : {})
+        ? createStubDirectProviderAdapter({
+            label: "Proof mode stub adapter (MARTIN_LIVE=false)",
+            providerId: "stub",
+            model: "stub"
         })
         : engine === "codex"
             ? createCodexCliAdapter({
@@ -102,7 +93,7 @@ export async function runLoopTool(input) {
         partialBudget.maxTokens = input.maxTokens;
     }
     const budget = normalizeLoopBudget(partialBudget);
-    const result = await runMartinImpl({
+    const result = await runMartin({
         workspaceId: input.workspaceId ?? "ws_mcp",
         projectId: input.projectId ?? "proj_mcp",
         store: runStoreOverrideForTests ?? createFileRunStore({ runsRoot }),

package/dist/tools/tool-support.d.ts

@@ -1,4 +1,4 @@
-import type { LoopArtifact, LoopBudget, LoopCost, LoopEvent, LoopTask, ReceiptIntegritySummary, ReceiptScope } from "../vendor/contracts/index.js";
+import type { LoopArtifact, LoopBudget, LoopCost, LoopEvent, LoopTask, ReceiptIntegritySummary, ReceiptScope, TerminationEnvelopeV1 } from "../vendor/contracts/index.js";
 import { type LedgerEvent, type LoopAttemptRecord, type LoopRunRecord } from "../vendor/core/index.js";
 export declare const MARTIN_ENGINE_VALUES: readonly ["claude", "codex", "gemini", "openai"];
 export type MartinEngine = (typeof MARTIN_ENGINE_VALUES)[number];
@@ -14,6 +14,7 @@ export interface InspectableLoopRecord extends Omit<LoopRunRecord, "attempts" |
     metadata?: Record<string, string>;
     receiptIntegrity?: ReceiptIntegritySummary;
     receiptScope?: ReceiptScope;
+    terminationEnvelope?: TerminationEnvelopeV1;
     routingEconomics?: import("../vendor/contracts/index.js").RoutingEconomics;
 }
 export interface LoopPreview {

package/dist/tools/tool-support.js

@@ -105,11 +105,6 @@ function discoverCommonInstallDirectories(command) {
         if (localAppData) {
             dirs.push(join(localAppData, "OpenAI", "Codex", "bin"));
         }
-        // Claude Code native installer places binary at %USERPROFILE%\.local\bin
-        const userProfile = process.env.USERPROFILE ?? process.env.HOMEPATH;
-        if (userProfile) {
-            dirs.push(join(userProfile, ".local", "bin"));
-        }
         // Scoop
         if (home) {
             dirs.push(join(home, "scoop", "shims"));
@@ -166,13 +161,8 @@ function isOnPathDirectly(command, resolvedPath) {
  * Returns a platform-specific one-liner install command for a known CLI.
  */
 function suggestInstallCommand(command) {
-    if (command === "claude") {
-        const installCmd = process.platform === "win32"
-            ? "irm https://claude.ai/install.ps1 | iex"
-            : "curl -fsSL https://claude.ai/install.sh | bash";
-        return `Install with: ${installCmd}`;
-    }
     const npmInstalls = {
+        claude: "npm install -g @anthropic-ai/claude-code",
         codex: "npm install -g @openai/codex",
         gemini: "npm install -g @google/gemini-cli"
     };
@@ -439,7 +429,6 @@ export function buildSuggestedResourceUris(loopId) {
         "martin://runs/triage",
         "martin://runs/latest",
         "martin://runs/latest/summary",
-        "martin://runs/latest/receipt",
         "martin://runs/latest/proof-card",
         "martin://runs/latest/budget-status",
         "martin://runs/latest/verifier-evidence",

package/dist/vendor/adapters/claude-cli.js

@@ -11,8 +11,8 @@
  *
  * MCP tools and integration tests use the same factories.
  */
-import { readGitExecutionArtifacts, resolveGitRepositoryRoot, runSubprocess, runVerification } from "./cli-bridge.js";
-import { buildCodexExecArgs, DEFAULT_CODEX_CHATGPT_MODEL } from "./codex-launcher.js";
+import { readGitChangedFiles, readGitExecutionArtifacts, resolveGitRepositoryRoot, runSubprocess, runVerification } from "./cli-bridge.js";
+import { buildCodexExecArgs } from "./codex-launcher.js";
 import { createAdapterCapabilities, normalizeStructuredErrors, normalizeUsage } from "./runtime-support.js";
 // ---------------------------------------------------------------------------
 // Cost estimation
@@ -381,14 +381,10 @@ function createStreamingUsageInspector(capUsd, modelLabel, promptTokenEstimate)
         catch {
             return;
         }
-        // result events contain aggregate usage that duplicates previously streamed
-        // assistant-message usage events — skip to avoid double-counting.
+        extractUsageFromEvent(event, terminate);
         if (event.type === "result") {
             finalResult = event;
         }
-        else {
-            extractUsageFromEvent(event, terminate);
-        }
     };
     return {
         onChunk: (chunk, terminate) => {
@@ -514,6 +510,14 @@ export function createAgentCliAdapter(options) {
         async execute(request) {
             const prompt = buildPrompt(request);
             const estimatedUsage = estimateUsage(prompt, options.model ?? options.command, options.command);
+            const repoRoot = request.context.repoRoot;
+            const gitRepoRoot = repoRoot ? resolveGitRepositoryRoot(repoRoot) : undefined;
+            // A governed run may begin in a deliberately dirty workspace. Capture that
+            // baseline so existing operator work is neither reported as this run's
+            // execution nor treated as scope creep.
+            const baselineChangedFiles = gitRepoRoot
+                ? new Set(await readGitChangedFiles(gitRepoRoot, 5_000, options.spawnImpl))
+                : new Set();
             // Preflight: bail if projected cost exceeds remaining budget
             if (request.context.remainingBudgetUsd > 0) {
                 const projected = estimatePromptCost(prompt, options.model ?? "", options.command);
@@ -549,7 +553,8 @@ export function createAgentCliAdapter(options) {
                 timeoutMs,
                 spawnImpl: options.spawnImpl,
                 ...(stdinData === undefined ? {} : { stdinData }),
-                ...(streamingUsage ? { onStdoutChunk: streamingUsage.onChunk } : {})
+                ...(streamingUsage ? { onStdoutChunk: streamingUsage.onChunk } : {}),
+                ...(request.signal !== undefined ? { signal: request.signal } : {})
             });
             if (agentResult.terminationReason) {
                 const snapshot = streamingUsage?.snapshot();
@@ -695,30 +700,36 @@ export function createAgentCliAdapter(options) {
                                 : undefined
                     });
             const verificationStack = request.context.verificationStack;
-            const verification = await runVerification(request.context.verificationPlan, workingDirectory, verifyTimeoutMs, verificationStack, options.spawnImpl);
+            const verification = await runVerification(request.context.verificationPlan, workingDirectory, verifyTimeoutMs, verificationStack, options.spawnImpl, {
+                runId: request.loopId,
+                workspaceId: request.workspaceId,
+                cwd: workingDirectory,
+            });
             // Check for zero-diff (agent ran but made no file changes)
-            const repoRoot = request.context.repoRoot;
-            const gitRepoRoot = repoRoot ? resolveGitRepositoryRoot(repoRoot) : undefined;
-            let noDiff = false;
-            if (gitRepoRoot) {
-                noDiff = await checkNoDiff(gitRepoRoot, options.spawnImpl);
-            }
+            const postRunChangedFiles = gitRepoRoot
+                ? await readGitChangedFiles(gitRepoRoot, 5_000, options.spawnImpl)
+                : [];
+            const agentChangedFiles = postRunChangedFiles.filter((file) => !baselineChangedFiles.has(file));
+            const noDiff = gitRepoRoot !== undefined && agentChangedFiles.length === 0;
             // Extract structured errors from stderr/stdout for better failure context
             const structuredErrors = normalizeStructuredErrors(extractStructuredErrors(agentResult.stderr, agentResult.stdout));
-            const executionArtifacts = gitRepoRoot
+            const rawExecutionArtifacts = gitRepoRoot
                 ? await readGitExecutionArtifacts(gitRepoRoot, 5000, options.spawnImpl)
                 : undefined;
+            const executionArtifacts = rawExecutionArtifacts
+                ? {
+                    ...(agentChangedFiles.length > 0 ? { changedFiles: agentChangedFiles } : {}),
+                    ...(baselineChangedFiles.size === 0 && rawExecutionArtifacts.diffStats
+                        ? { diffStats: rawExecutionArtifacts.diffStats }
+                        : {})
+                }
+                : undefined;
             // Scope contract enforcement: check touched files against allowedPaths/deniedPaths
             let scopeViolations = [];
             const scopeCtx = request.context;
             if (gitRepoRoot && (scopeCtx.allowedPaths?.length || scopeCtx.deniedPaths?.length)) {
-                const diffResult = await runSubprocess("git", ["diff", "--name-only", "HEAD"], {
-                    cwd: gitRepoRoot,
-                    timeoutMs: 5000,
-                    spawnImpl: options.spawnImpl
-                });
-                if (diffResult.exitCode === 0 && diffResult.stdout.trim()) {
-                    const touchedFiles = diffResult.stdout.trim().split("\n").filter(Boolean);
+                if (agentChangedFiles.length > 0) {
+                    const touchedFiles = agentChangedFiles;
                     const allowed = scopeCtx.allowedPaths ?? [];
                     const denied = scopeCtx.deniedPaths ?? [];
                     for (const file of touchedFiles) {
@@ -741,7 +752,7 @@ export function createAgentCliAdapter(options) {
                     status: "completed",
                     summary,
                     usage,
-                    verification: { passed: true, summary: verification.summary },
+                    verification,
                     ...(executionArtifacts
                         ? {
                             execution: {
@@ -786,7 +797,7 @@ export function createAgentCliAdapter(options) {
                 }
                 // Reset tracked files to HEAD so next attempt starts from clean state
                 try {
-                    if (gitRepoRoot) {
+                    if (gitRepoRoot && baselineChangedFiles.size === 0) {
                         await runSubprocess("git", ["restore", "--staged", "--worktree", "."], {
                             cwd: gitRepoRoot,
                             timeoutMs: 5000
@@ -803,7 +814,7 @@ export function createAgentCliAdapter(options) {
                     ? `${summary}${errorBlock}${scopeViolations.length > 0 ? `\nScope violations: ${scopeViolations.join(", ")}` : ""}`
                     : summary,
                 usage,
-                verification: { passed: false, summary: verification.summary },
+                verification,
                 ...(executionArtifacts
                     ? {
                         execution: {
@@ -906,7 +917,7 @@ export function createCodexCliAdapter(options = {}) {
     const sandbox = options.sandbox ?? "workspace-write";
     const workingDirectory = options.workingDirectory ?? process.cwd();
     const command = options.command ?? "codex";
-    const launchModel = options.model ?? DEFAULT_CODEX_CHATGPT_MODEL;
+    const launchModel = options.model;
     return createAgentCliAdapter({
         command,
         adapterIdSuffix: "codex",
@@ -1152,11 +1163,3 @@ function extractStructuredErrors(stderr, stdout) {
     }
     return errors.slice(0, 10); // cap at 10 to avoid bloating prompts
 }
-async function checkNoDiff(repoRoot, spawnImpl) {
-    const result = await runSubprocess("git", ["diff", "--name-only", "HEAD"], {
-        cwd: repoRoot,
-        timeoutMs: 5000,
-        spawnImpl
-    });
-    return result.exitCode === 0 && result.stdout.trim().length === 0;
-}

package/dist/vendor/adapters/cli-bridge.d.ts

@@ -1,11 +1,14 @@
 import { type ChildProcess, type SpawnOptions } from "node:child_process";
 import { diffStatsFromNumstat } from "./runtime-support.js";
+import type { VerifierExecutionBinding } from "../core/index.js";
 export type SpawnLike = (command: string, args?: readonly string[], options?: SpawnOptions) => ChildProcess;
 export interface SubprocessResult {
     exitCode: number;
     stdout: string;
     stderr: string;
     timedOut: boolean;
+    completed: boolean;
+    crashed: boolean;
     /**
      * True when the subprocess was terminated early because its combined
      * stdout+stderr exceeded `maxOutputBytes` — a circuit breaker against
@@ -30,10 +33,13 @@ export interface VerificationOutcome {
     summary: string;
     steps: VerificationStepOutcome[];
     warnings?: string[];
+    binding: VerifierExecutionBinding;
 }
 export interface VerificationStepOutcome {
     command: string;
     launched: boolean;
+    completed: boolean;
+    crashed: boolean;
     exitCode?: number;
     timedOut: boolean;
     fastFail: boolean;
@@ -60,12 +66,14 @@ export declare function runSubprocess(command: string, args: string[], options:
      * a runaway final usage figure.
      */
     onStdoutChunk?: (chunk: Buffer, terminate: (reason: string) => void) => void;
+    /** Optional abort signal — kills the subprocess when aborted. */
+    signal?: AbortSignal;
 }): Promise<SubprocessResult>;
 export declare function runVerification(commands: string[], cwd: string, timeoutMs: number, verificationStack?: Array<{
     command: string;
     type: string;
     fastFail?: boolean;
-}>, spawnImpl?: SpawnLike): Promise<VerificationOutcome>;
+}>, spawnImpl?: SpawnLike, binding?: Omit<VerifierExecutionBinding, "commands">): Promise<VerificationOutcome>;
 export declare function readGitExecutionArtifacts(repoRoot: string, timeoutMs: number, spawnImpl?: SpawnLike): Promise<{
     changedFiles?: string[];
     diffStats?: ReturnType<typeof diffStatsFromNumstat>;