@martinloop/mcp 0.5.3 → 0.5.5

package/README.md

@@ -57,27 +57,27 @@ These aren't hypotheticals. The $28 overshoot happened in production testing. We
 
 ### Claude Code
 ```sh
-claude mcp add martin-loop -- npx -y @martinloop/mcp@0.5.3
+claude mcp add martin-loop -- npx -y @martinloop/mcp@0.5.5
 ```
 
 Windows:
 ```sh
-claude mcp add --transport stdio --scope user martin-loop -- cmd /c npx -y @martinloop/mcp@0.5.3
+claude mcp add --transport stdio --scope user martin-loop -- cmd /c npx -y @martinloop/mcp@0.5.5
 ```
 
 ### Codex
 ```sh
-codex mcp add martin-loop -- npx -y @martinloop/mcp@0.5.3
+codex mcp add martin-loop -- npx -y @martinloop/mcp@0.5.5
 ```
 
 ### Gemini CLI
 ```sh
-gemini mcp add martin-loop -- npx -y @martinloop/mcp@0.5.3
+gemini mcp add martin-loop -- npx -y @martinloop/mcp@0.5.5
 ```
 
 ### Any MCP Host
 ```sh
-npx -y @martinloop/mcp@0.5.3
+npx -y @martinloop/mcp@0.5.5
 ```
 
 ## How a Governed Run Works
@@ -139,7 +139,7 @@ MartinLoop does not round failure into success. It preserves the evidence and fo
 | `git restore` fails mid-rollback | Throws, leaves dirty state | Retries once, falls back to `git checkout`, cleans up |
 | Invalid `--profile` flag | Crashes | Warns, falls back to `minimal`, keeps running |
 
-## Codex compatibility in 0.5.3
+## Codex compatibility in 0.5.5
 
 MartinLoop no longer assumes one Codex host or one fixed Codex flag set. The CLI resolves the exact Codex executable, reads its advertised capabilities, negotiates a supported write strategy, proves that strategy before reporting launch readiness, and reuses the same contract for the governed run.
 

package/dist/server-validation.js

@@ -151,6 +151,7 @@ function validateRunInput(args) {
         "maxIterations",
         "maxTokens",
         "verifyTimeoutMs",
+        "providerExecutionTimeoutMs",
         "maxMinutes",
         "maxFilesChanged",
         "maxCommands",
@@ -180,6 +181,7 @@ function validateRunInput(args) {
         ...optionalPositiveInteger(record.maxIterations, "maxIterations"),
         ...optionalPositiveInteger(record.maxTokens, "maxTokens"),
         ...optionalPositiveInteger(record.verifyTimeoutMs, "verifyTimeoutMs"),
+        ...optionalPositiveInteger(record.providerExecutionTimeoutMs, "providerExecutionTimeoutMs"),
         ...optionalPositiveInteger(record.maxMinutes, "maxMinutes"),
         ...optionalPositiveInteger(record.maxFilesChanged, "maxFilesChanged"),
         ...optionalPositiveInteger(record.maxCommands, "maxCommands"),

package/dist/server.js

@@ -47,6 +47,7 @@ import { runLoopTool } from "./tools/run-loop.js";
 import { MARTIN_ENGINE_VALUES } from "./tools/tool-support.js";
 import { classifyRoute } from "./vendor/core/index.js";
 import { createToolErrorResult, createToolSuccessResult } from "./tools/tool-response.js";
+import { buildGovernedPlanStages, renderGovernedRunPlanMarkdown, renderVerifiedHandoffMarkdown } from "./vendor/presentation/index.js";
 import { MartinToolError, toToolFailure } from "./tools/tool-errors.js";
 import { normalizeLoopBudget } from "./tools/workflow-governance.js";
 import { resolveSafeRepoRoot, sanitizeToolErrorMessage, validateToolInput } from "./server-validation.js";
@@ -793,6 +794,16 @@ export function createMartinMcpServer(serverInfo) {
                             exclusiveMinimum: 0,
                             description: "Maximum total tokens across all attempts."
                         },
+                        verifyTimeoutMs: {
+                            type: "integer",
+                            exclusiveMinimum: 0,
+                            description: "Hard timeout for each verifier command in milliseconds."
+                        },
+                        providerExecutionTimeoutMs: {
+                            type: "integer",
+                            exclusiveMinimum: 0,
+                            description: "Hard timeout for each provider coding process in milliseconds."
+                        },
                         verificationPlan: {
                             type: "array",
                             items: { type: "string" },
@@ -1594,7 +1605,23 @@ export function createMartinMcpServer(serverInfo) {
                         budget: output.normalized.budget
                     }).catch(() => { });
                 }
-                return createToolSuccessResult(output, output.summary);
+                const prefPlanView = {
+                    ready: output.ok,
+                    task: output.normalized.objective,
+                    engine: output.normalized.engine,
+                    mode: output.readiness.liveMode ? "live" : "proof",
+                    budget: output.normalized.budget,
+                    verifier: output.normalized.verificationPlan,
+                    receiptScope: output.receiptScope,
+                    policyProfile: output.policy.name,
+                    blockingIssues: output.ok ? [] : [output.summary],
+                    warnings: output.warnings,
+                    stages: []
+                };
+                prefPlanView.stages = buildGovernedPlanStages(prefPlanView);
+                return createToolSuccessResult(output, output.summary, {
+                    human: renderGovernedRunPlanMarkdown(prefPlanView)
+                });
             }
             if (name === "martin_logs") {
                 const input = validateToolInput("martin_logs", args);
@@ -1644,12 +1671,12 @@ export function createMartinMcpServer(serverInfo) {
             if (name === "martin_run_dossier") {
                 const input = validateToolInput("martin_run_dossier", args);
                 const output = await martinRunDossierTool(input);
-                return createToolSuccessResult(output, `Dossier ready for Martin run ${output.loop.loopId} with ${output.attempts.length} attempt(s).`);
+                return createToolSuccessResult(output, `Dossier ready for Martin run ${output.loop.loopId} with ${output.attempts.length} attempt(s).`, { human: renderVerifiedHandoffMarkdown(output.verifiedHandoff) });
             }
             if (name === "martin_dossier") {
                 const input = validateToolInput("martin_dossier", args);
                 const output = await martinRunDossierTool(input);
-                return createToolSuccessResult(output, `Dossier ready for Martin run ${output.loop.loopId} in ${output.format} format.`);
+                return createToolSuccessResult(output, `Dossier ready for Martin run ${output.loop.loopId} in ${output.format} format.`, { human: renderVerifiedHandoffMarkdown(output.verifiedHandoff) });
             }
             if (name === "martin_eval") {
                 const input = validateToolInput("martin_eval", args);

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

@@ -11,6 +11,7 @@ export interface RunLoopInput {
     maxIterations?: number;
     maxTokens?: number;
     verifyTimeoutMs?: number;
+    providerExecutionTimeoutMs?: number;
     verificationPlan?: string[];
     allowedPaths?: string[];
     deniedPaths?: string[];

package/dist/tools/run-loop.js

@@ -30,7 +30,7 @@ export async function runLoopTool(input) {
         repoRoot: workingDirectory,
         runsRoot
     };
-    let codexCommandOverride;
+    let codexProbeOverride;
     if (executionMode.liveMode) {
         if (engine === "codex") {
             const engineAvailability = resolveCliCommandAvailability("codex");
@@ -43,7 +43,10 @@ export async function runLoopTool(input) {
             }
             const codexProbe = probeCodexLaunch({
                 workingDirectory,
-                availability: engineAvailability
+                availability: engineAvailability,
+                ...(input.providerExecutionTimeoutMs !== undefined
+                    ? { providerExecutionTimeoutMs: input.providerExecutionTimeoutMs }
+                    : {})
             });
             if (!codexProbe.ok) {
                 throw new MartinToolError("engine_unavailable", codexProbe.summary, {
@@ -52,7 +55,7 @@ export async function runLoopTool(input) {
                     retryable: false
                 });
             }
-            codexCommandOverride = codexProbe.command;
+            codexProbeOverride = codexProbe;
         }
         else {
             const engineAvailability = getEngineAvailability(engine);
@@ -76,18 +79,33 @@ export async function runLoopTool(input) {
             ? createCodexCliAdapter({
                 workingDirectory,
                 ...(input.verifyTimeoutMs !== undefined ? { verifyTimeoutMs: input.verifyTimeoutMs } : {}),
+                ...(input.providerExecutionTimeoutMs !== undefined
+                    ? { providerExecutionTimeoutMs: input.providerExecutionTimeoutMs }
+                    : {}),
                 ...(model ? { model } : {}),
-                ...(codexCommandOverride ? { command: codexCommandOverride } : {})
+                ...(codexProbeOverride
+                    ? {
+                        command: codexProbeOverride.command,
+                        capabilityProfile: codexProbeOverride.capabilityProfile,
+                        autonomyResolution: codexProbeOverride.autonomyResolution
+                    }
+                    : {})
             })
             : engine === "gemini"
                 ? createGeminiCliAdapter({
                     workingDirectory,
                     ...(input.verifyTimeoutMs !== undefined ? { verifyTimeoutMs: input.verifyTimeoutMs } : {}),
+                    ...(input.providerExecutionTimeoutMs !== undefined
+                        ? { providerExecutionTimeoutMs: input.providerExecutionTimeoutMs }
+                        : {}),
                     ...(model ? { model } : {})
                 })
                 : createClaudeCliAdapter({
                     workingDirectory,
                     ...(input.verifyTimeoutMs !== undefined ? { verifyTimeoutMs: input.verifyTimeoutMs } : {}),
+                    ...(input.providerExecutionTimeoutMs !== undefined
+                        ? { providerExecutionTimeoutMs: input.providerExecutionTimeoutMs }
+                        : {}),
                     ...(model ? { model } : {})
                 });
     const partialBudget = {};
@@ -113,6 +131,9 @@ export async function runLoopTool(input) {
             ...(input.verifyTimeoutMs !== undefined
                 ? { verificationTimeoutMs: input.verifyTimeoutMs }
                 : {}),
+            ...(input.providerExecutionTimeoutMs !== undefined
+                ? { providerExecutionTimeoutMs: input.providerExecutionTimeoutMs }
+                : {}),
             repoRoot: workingDirectory,
             ...(allowedPaths ? { allowedPaths } : {}),
             ...(deniedPaths ? { deniedPaths } : {})

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

@@ -3,7 +3,15 @@ interface TextContentBlock {
     type: "text";
     text: string;
 }
-export declare function createToolSuccessResult<T extends object>(output: T, summary: string): {
+export interface ToolSuccessRenderOptions {
+    /** Explicit human-readable Markdown for content[0].
+     *  Overrides resolveHumanArtifact fallback when provided. */
+    human?: string;
+    /** Include compatibility JSON block in content[]. Default: true.
+     *  Set false only after real-host testing proves structuredContent alone suffices. */
+    includeCompatibilityJson?: boolean;
+}
+export declare function createToolSuccessResult<T extends object>(output: T, summary: string, options?: ToolSuccessRenderOptions): {
     content: TextContentBlock[];
     structuredContent: T;
     _meta: Record<string, unknown>;

package/dist/tools/tool-response.js

@@ -8,12 +8,14 @@ function resolveHumanArtifact(output, summary) {
     const rendered = "rendered" in output ? output.rendered : undefined;
     return typeof rendered === "string" && rendered.trim().length > 0 ? rendered : summary;
 }
-export function createToolSuccessResult(output, summary) {
+export function createToolSuccessResult(output, summary, options = {}) {
+    const humanText = options.human ?? resolveHumanArtifact(output, summary);
+    const content = [{ type: "text", text: humanText }];
+    if (options.includeCompatibilityJson !== false) {
+        content.push(createJsonBlock(output));
+    }
     return {
-        content: [
-            { type: "text", text: resolveHumanArtifact(output, summary) },
-            createJsonBlock(output)
-        ],
+        content,
         structuredContent: output,
         _meta: {
             "martinloop/summary": summary,