@martinloop/mcp 0.2.5 → 0.3.0

package/dist/server.js

@@ -19,6 +19,7 @@
 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 { CallToolRequestSchema, GetPromptRequestSchema, ListPromptsRequestSchema, ListResourcesRequestSchema, ListResourceTemplatesRequestSchema, ListToolsRequestSchema, ReadResourceRequestSchema } from "@modelcontextprotocol/sdk/types.js";
@@ -26,19 +27,25 @@ import { MARTIN_MCP_PACKAGE_VERSION } from "./package-version.js";
 import { getMartinPrompt, listMartinPrompts } from "./prompts.js";
 import { listMartinResources, listMartinResourceTemplates, readMartinResource } from "./resources.js";
 import { martinDoctorTool } from "./tools/doctor.js";
+import { martinEvalTool } from "./tools/eval.js";
 import { martinGetAttemptTool } from "./tools/get-attempt.js";
 import { martinGetRunTool } from "./tools/get-run.js";
 import { martinGetVerificationResultsTool } from "./tools/get-verification-results.js";
 import { getStatusTool } from "./tools/get-status.js";
 import { inspectLoopTool } from "./tools/inspect-loop.js";
 import { martinListRunsTool } from "./tools/list-runs.js";
+import { martinLogsTool } from "./tools/logs.js";
+import { martinPlanTool } from "./tools/plan.js";
 import { martinPreflightTool } from "./tools/preflight.js";
+import { martinCreatePrTool, martinPrSummaryTool, martinReviewPrTool } from "./tools/pr-tools.js";
 import { martinRunDossierTool } from "./tools/run-dossier.js";
+import { createRunControlReceipt } from "./tools/run-controls.js";
 import { martinTriageRunsTool } from "./tools/triage-runs.js";
 import { runLoopTool } from "./tools/run-loop.js";
 import { createToolErrorResult, createToolSuccessResult } from "./tools/tool-response.js";
 import { MartinToolError, toToolFailure } from "./tools/tool-errors.js";
 import { sanitizeToolErrorMessage, validateToolInput } from "./server-validation.js";
+import { recordMcpWorkflowStep } from "./workflow-state.js";
 const stringArraySchema = {
     type: "array",
     items: { type: "string" }
@@ -115,6 +122,22 @@ const verificationSchema = {
         latestAttemptIndex: { type: "integer" },
         completedAt: { type: "string" },
         summary: { type: "string" },
+        steps: {
+            type: "array",
+            items: {
+                type: "object",
+                additionalProperties: true,
+                properties: {
+                    command: { type: "string" },
+                    launched: { type: "boolean" },
+                    exitCode: { type: "integer" },
+                    timedOut: { type: "boolean" },
+                    fastFail: { type: "boolean" },
+                    detail: { type: "string" }
+                },
+                required: ["command", "launched"]
+            }
+        },
         warnings: stringArraySchema
     },
     required: ["status", "eventCount", "ledgerEventCount", "warnings"]
@@ -363,7 +386,7 @@ const doctorOutputSchema = {
                 workspaceRoot: { type: "string" },
                 workingDirectory: { type: "string" },
                 runsRoot: { type: "string" },
-                mode: { type: "string", enum: ["live", "stub"] },
+                mode: { type: "string", enum: ["live", "proof"] },
                 liveMode: { type: "boolean" }
             },
             required: ["workspaceRoot", "workingDirectory", "runsRoot", "mode", "liveMode"]
@@ -398,7 +421,7 @@ const preflightOutputSchema = {
             type: "object",
             additionalProperties: false,
             properties: {
-                mode: { type: "string", enum: ["live", "stub"] },
+                mode: { type: "string", enum: ["live", "proof"] },
                 liveMode: { type: "boolean" },
                 engineReady: { type: "boolean" }
             },
@@ -649,6 +672,30 @@ const dossierOutputSchema = {
         "warnings"
     ]
 };
+const planOutputSchema = {
+    type: "object",
+    additionalProperties: true
+};
+const logsOutputSchema = {
+    type: "object",
+    additionalProperties: true
+};
+const controlOutputSchema = {
+    type: "object",
+    additionalProperties: true
+};
+const evalOutputSchema = {
+    type: "object",
+    additionalProperties: true
+};
+const prSummaryOutputSchema = {
+    type: "object",
+    additionalProperties: true
+};
+const prReviewOutputSchema = {
+    type: "object",
+    additionalProperties: true
+};
 export function createMartinMcpServer(serverInfo) {
     const server = new Server({
         name: serverInfo?.name ?? "martin-loop",
@@ -658,7 +705,7 @@ export function createMartinMcpServer(serverInfo) {
         tools: [
             {
                 name: "martin_run",
-                description: "Execute a governed Martin Loop run on a coding task and return the run summary, spend, artifact rollup, and verification state.",
+                description: "Execute a governed Martin Loop run on a coding task and return the run summary, spend, artifact rollup, and verification state. This hard-blocks until martin_doctor, martin_plan, and martin_preflight receipts exist for the same task.",
                 annotations: {
                     destructiveHint: true,
                     idempotentHint: false,
@@ -791,7 +838,7 @@ export function createMartinMcpServer(serverInfo) {
             },
             {
                 name: "martin_doctor",
-                description: "Read-only environment and run-store diagnostics for the Martin MCP server.",
+                description: "Read-only environment and run-store diagnostics for the Martin MCP server. This is the expected first call before governed work begins.",
                 annotations: {
                     readOnlyHint: true,
                     idempotentHint: true
@@ -817,9 +864,44 @@ export function createMartinMcpServer(serverInfo) {
                 },
                 outputSchema: doctorOutputSchema
             },
+            {
+                name: "martin_plan",
+                description: "Read-only planning step that turns an objective into a scoped implementation plan, verifier proposal, policy pack, and risk recommendation. Use before preflight and before any real coding run.",
+                annotations: {
+                    readOnlyHint: true,
+                    idempotentHint: true
+                },
+                inputSchema: {
+                    type: "object",
+                    additionalProperties: false,
+                    properties: {
+                        objective: { type: "string", description: "The coding objective to plan." },
+                        workingDirectory: {
+                            type: "string",
+                            description: "Optional repo-root override resolved under the MCP workspace root."
+                        },
+                        context: { type: "string", description: "Optional extra issue or bug context." },
+                        policyPack: {
+                            type: "string",
+                            enum: ["solo-founder", "startup-team", "enterprise-strict", "oss-maintainer", "security-sensitive"]
+                        },
+                        verificationPlan: { type: "array", items: { type: "string" } },
+                        allowedPaths: { type: "array", items: { type: "string" } },
+                        deniedPaths: { type: "array", items: { type: "string" } },
+                        maxUsd: { type: "number", exclusiveMinimum: 0 },
+                        maxIterations: { type: "integer", exclusiveMinimum: 0 },
+                        maxTokens: { type: "integer", exclusiveMinimum: 0 },
+                        maxMinutes: { type: "integer", exclusiveMinimum: 0 },
+                        maxFilesChanged: { type: "integer", exclusiveMinimum: 0 },
+                        maxCommands: { type: "integer", exclusiveMinimum: 0 }
+                    },
+                    required: ["objective"]
+                },
+                outputSchema: planOutputSchema
+            },
             {
                 name: "martin_preflight",
-                description: "Read-only validation of a planned Martin run before any execution or spend.",
+                description: "Read-only validation of a planned Martin run before any execution or spend. This is the last required step before martin_run.",
                 annotations: {
                     readOnlyHint: true,
                     idempotentHint: true
@@ -845,6 +927,14 @@ export function createMartinMcpServer(serverInfo) {
                             type: "string",
                             description: "Model override passed to the CLI."
                         },
+                        context: {
+                            type: "string",
+                            description: "Optional issue context carried into the run contract."
+                        },
+                        policyPack: {
+                            type: "string",
+                            enum: ["solo-founder", "startup-team", "enterprise-strict", "oss-maintainer", "security-sensitive"]
+                        },
                         maxUsd: {
                             type: "number",
                             exclusiveMinimum: 0,
@@ -860,6 +950,21 @@ export function createMartinMcpServer(serverInfo) {
                             exclusiveMinimum: 0,
                             description: "Maximum total tokens across all attempts."
                         },
+                        maxMinutes: {
+                            type: "integer",
+                            exclusiveMinimum: 0,
+                            description: "Estimated wall-clock minutes allowed for the run contract."
+                        },
+                        maxFilesChanged: {
+                            type: "integer",
+                            exclusiveMinimum: 0,
+                            description: "Estimated maximum files changed for the run contract."
+                        },
+                        maxCommands: {
+                            type: "integer",
+                            exclusiveMinimum: 0,
+                            description: "Estimated maximum commands allowed for the run contract."
+                        },
                         verificationPlan: {
                             type: "array",
                             items: { type: "string" },
@@ -882,6 +987,93 @@ export function createMartinMcpServer(serverInfo) {
                 },
                 outputSchema: preflightOutputSchema
             },
+            {
+                name: "martin_logs",
+                description: "Read recent Martin loop events, ledger entries, and operator control receipts for live observability.",
+                annotations: {
+                    readOnlyHint: true,
+                    idempotentHint: true
+                },
+                inputSchema: {
+                    type: "object",
+                    additionalProperties: false,
+                    properties: {
+                        file: { type: "string" },
+                        loopId: { type: "string" },
+                        runsDir: { type: "string" },
+                        latest: { const: true },
+                        limit: { type: "integer", minimum: 1 }
+                    },
+                    oneOf: [{ required: ["file"] }, { required: ["loopId"] }, { required: ["latest"] }]
+                },
+                outputSchema: logsOutputSchema
+            },
+            {
+                name: "martin_pause",
+                description: "Record a durable pause request for a Martin run so humans and runtimes can see that execution should pause before risky follow-up work.",
+                annotations: {
+                    destructiveHint: true,
+                    idempotentHint: false
+                },
+                inputSchema: {
+                    type: "object",
+                    additionalProperties: false,
+                    properties: {
+                        file: { type: "string" },
+                        loopId: { type: "string" },
+                        runsDir: { type: "string" },
+                        latest: { const: true },
+                        reason: { type: "string" },
+                        requestedBy: { type: "string" }
+                    },
+                    oneOf: [{ required: ["file"] }, { required: ["loopId"] }, { required: ["latest"] }]
+                },
+                outputSchema: controlOutputSchema
+            },
+            {
+                name: "martin_cancel",
+                description: "Record a durable cancellation request for a Martin run. This writes a control receipt; it does not silently kill a process without evidence.",
+                annotations: {
+                    destructiveHint: true,
+                    idempotentHint: false
+                },
+                inputSchema: {
+                    type: "object",
+                    additionalProperties: false,
+                    properties: {
+                        file: { type: "string" },
+                        loopId: { type: "string" },
+                        runsDir: { type: "string" },
+                        latest: { const: true },
+                        reason: { type: "string" },
+                        requestedBy: { type: "string" }
+                    },
+                    oneOf: [{ required: ["file"] }, { required: ["loopId"] }, { required: ["latest"] }]
+                },
+                outputSchema: controlOutputSchema
+            },
+            {
+                name: "martin_continue",
+                description: "Record a durable continue or resume request for a Martin run after a human pause or approval checkpoint.",
+                annotations: {
+                    destructiveHint: true,
+                    idempotentHint: false
+                },
+                inputSchema: {
+                    type: "object",
+                    additionalProperties: false,
+                    properties: {
+                        file: { type: "string" },
+                        loopId: { type: "string" },
+                        runsDir: { type: "string" },
+                        latest: { const: true },
+                        reason: { type: "string" },
+                        requestedBy: { type: "string" }
+                    },
+                    oneOf: [{ required: ["file"] }, { required: ["loopId"] }, { required: ["latest"] }]
+                },
+                outputSchema: controlOutputSchema
+            },
             {
                 name: "martin_list_runs",
                 description: "List recent Martin runs from the run store with lightweight filters for status, lifecycle, engine metadata, and recency.",
@@ -1055,6 +1247,114 @@ export function createMartinMcpServer(serverInfo) {
                     ]
                 },
                 outputSchema: dossierOutputSchema
+            },
+            {
+                name: "martin_dossier",
+                description: "Alias for martin_run_dossier with support for JSON, Markdown, or GitHub PR formatting. Use after martin_run to understand what happened and whether the result is actually safe to trust.",
+                annotations: {
+                    readOnlyHint: true,
+                    idempotentHint: true
+                },
+                inputSchema: {
+                    type: "object",
+                    additionalProperties: false,
+                    properties: {
+                        file: { type: "string" },
+                        loopId: { type: "string" },
+                        runsDir: { type: "string" },
+                        latest: { const: true },
+                        format: { type: "string", enum: ["json", "md", "github-pr"] }
+                    },
+                    oneOf: [{ required: ["file"] }, { required: ["loopId"] }, { required: ["latest"] }]
+                },
+                outputSchema: dossierOutputSchema
+            },
+            {
+                name: "martin_eval",
+                description: "Grade a Martin run for task completion, verifier health, diff discipline, risk, and reviewability.",
+                annotations: {
+                    readOnlyHint: true,
+                    idempotentHint: true
+                },
+                inputSchema: {
+                    type: "object",
+                    additionalProperties: false,
+                    properties: {
+                        file: { type: "string" },
+                        loopId: { type: "string" },
+                        runsDir: { type: "string" },
+                        latest: { const: true }
+                    },
+                    oneOf: [{ required: ["file"] }, { required: ["loopId"] }, { required: ["latest"] }]
+                },
+                outputSchema: evalOutputSchema
+            },
+            {
+                name: "martin_pr_summary",
+                description: "Generate a PR title and body with a MartinLoop dossier block for a completed run.",
+                annotations: {
+                    readOnlyHint: true,
+                    idempotentHint: true
+                },
+                inputSchema: {
+                    type: "object",
+                    additionalProperties: false,
+                    properties: {
+                        file: { type: "string" },
+                        loopId: { type: "string" },
+                        runsDir: { type: "string" },
+                        latest: { const: true },
+                        format: { type: "string", enum: ["json", "md", "github-pr"] }
+                    },
+                    oneOf: [{ required: ["file"] }, { required: ["loopId"] }, { required: ["latest"] }]
+                },
+                outputSchema: prSummaryOutputSchema
+            },
+            {
+                name: "martin_create_pr",
+                description: "Create or preview a GitHub PR with a MartinLoop dossier body. Use execute=true to actually call gh.",
+                annotations: {
+                    destructiveHint: true,
+                    idempotentHint: false
+                },
+                inputSchema: {
+                    type: "object",
+                    additionalProperties: false,
+                    properties: {
+                        file: { type: "string" },
+                        loopId: { type: "string" },
+                        runsDir: { type: "string" },
+                        latest: { const: true },
+                        format: { type: "string", enum: ["json", "md", "github-pr"] },
+                        title: { type: "string" },
+                        base: { type: "string" },
+                        execute: { type: "boolean" }
+                    },
+                    oneOf: [{ required: ["file"] }, { required: ["loopId"] }, { required: ["latest"] }]
+                },
+                outputSchema: prSummaryOutputSchema
+            },
+            {
+                name: "martin_review_pr",
+                description: "Review a PR or PR draft against the Martin dossier and evaluation evidence.",
+                annotations: {
+                    readOnlyHint: true,
+                    idempotentHint: true
+                },
+                inputSchema: {
+                    type: "object",
+                    additionalProperties: false,
+                    properties: {
+                        file: { type: "string" },
+                        loopId: { type: "string" },
+                        runsDir: { type: "string" },
+                        latest: { const: true },
+                        format: { type: "string", enum: ["json", "md", "github-pr"] },
+                        prBody: { type: "string" }
+                    },
+                    oneOf: [{ required: ["file"] }, { required: ["loopId"] }, { required: ["latest"] }]
+                },
+                outputSchema: prReviewOutputSchema
             }
         ]
     }));
@@ -1113,11 +1413,58 @@ export function createMartinMcpServer(serverInfo) {
             if (name === "martin_doctor") {
                 const input = validateToolInput("martin_doctor", args);
                 const output = await martinDoctorTool(input);
+                await recordMcpWorkflowStep({
+                    runsRoot: output.environment.runsRoot,
+                    step: "doctor",
+                    workingDirectory: output.environment.workingDirectory,
+                    engine: input.engine
+                }).catch(() => { });
                 return createToolSuccessResult(output, output.summary);
             }
+            if (name === "martin_plan") {
+                const input = validateToolInput("martin_plan", args);
+                const output = await martinPlanTool(input);
+                await recordMcpWorkflowStep({
+                    runsRoot: resolveRunsRoot(process.env),
+                    step: "plan",
+                    workingDirectory: output.workingDirectory,
+                    objective: output.objective
+                }).catch(() => { });
+                return createToolSuccessResult(output, `Plan ready for ${output.objective} with ${output.risk.level} risk and ${output.approvalRecommendation.replace(/_/gu, " ")} approval.`);
+            }
             if (name === "martin_preflight") {
                 const input = validateToolInput("martin_preflight", args);
                 const output = await martinPreflightTool(input);
+                if (output.ok) {
+                    await recordMcpWorkflowStep({
+                        runsRoot: output.execution.runsRoot,
+                        step: "preflight",
+                        workingDirectory: output.normalized.workingDirectory,
+                        objective: output.normalized.objective,
+                        engine: output.normalized.engine,
+                        verificationPlan: output.normalized.verificationPlan
+                    }).catch(() => { });
+                }
+                return createToolSuccessResult(output, output.summary);
+            }
+            if (name === "martin_logs") {
+                const input = validateToolInput("martin_logs", args);
+                const output = await martinLogsTool(input);
+                return createToolSuccessResult(output, `Loaded ${output.logCount} log entries for Martin run ${output.loopId}.`);
+            }
+            if (name === "martin_pause") {
+                const input = validateToolInput("martin_pause", args);
+                const output = await createRunControlReceipt("pause", input);
+                return createToolSuccessResult(output, output.summary);
+            }
+            if (name === "martin_cancel") {
+                const input = validateToolInput("martin_cancel", args);
+                const output = await createRunControlReceipt("cancel", input);
+                return createToolSuccessResult(output, output.summary);
+            }
+            if (name === "martin_continue") {
+                const input = validateToolInput("martin_continue", args);
+                const output = await createRunControlReceipt("continue", input);
                 return createToolSuccessResult(output, output.summary);
             }
             if (name === "martin_list_runs") {
@@ -1150,6 +1497,33 @@ export function createMartinMcpServer(serverInfo) {
                 const output = await martinRunDossierTool(input);
                 return createToolSuccessResult(output, `Dossier ready for Martin run ${output.loop.loopId} with ${output.attempts.length} attempt(s).`);
             }
+            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.`);
+            }
+            if (name === "martin_eval") {
+                const input = validateToolInput("martin_eval", args);
+                const output = await martinEvalTool(input);
+                return createToolSuccessResult(output, `Evaluation for ${output.loopId}: ${output.grade} (${output.score}).`);
+            }
+            if (name === "martin_pr_summary") {
+                const input = validateToolInput("martin_pr_summary", args);
+                const output = await martinPrSummaryTool(input);
+                return createToolSuccessResult(output, `PR summary ready for Martin run ${output.loopId}.`);
+            }
+            if (name === "martin_create_pr") {
+                const input = validateToolInput("martin_create_pr", args);
+                const output = await martinCreatePrTool(input);
+                return createToolSuccessResult(output, output.created
+                    ? `Created PR for Martin run ${output.loopId}.`
+                    : `PR preview ready for Martin run ${output.loopId}.`);
+            }
+            if (name === "martin_review_pr") {
+                const input = validateToolInput("martin_review_pr", args);
+                const output = await martinReviewPrTool(input);
+                return createToolSuccessResult(output, `PR review verdict for ${output.loopId}: ${output.verdict}.`);
+            }
             return createToolErrorResult(toToolFailure(new Error(`Unknown tool: ${name}`)));
         }
         catch (error) {

package/dist/tools/doctor.d.ts

@@ -1,4 +1,6 @@
+import { type CodexHostPlatform } from "../vendor/adapters/index.js";
 import { type LoopPreview, type MartinEngine } from "./tool-support.js";
+import { type MartinReadinessReport } from "./workflow-governance.js";
 export interface MartinDoctorInput {
     workingDirectory?: string;
     runsDir?: string;
@@ -16,13 +18,23 @@ export interface MartinDoctorOutput {
         workspaceRoot: string;
         workingDirectory: string;
         runsRoot: string;
-        mode: "live" | "stub";
+        mode: "live" | "proof";
         liveMode: boolean;
     };
+    scope: {
+        invocationRoot: string;
+        workingDirectory: string;
+        repoRoot: string;
+        runsRoot: string;
+    };
     engines: Record<MartinEngine, {
         available: boolean;
         detail: string;
         resolvedPath?: string;
+        hostPlatform?: CodexHostPlatform;
+        nativeInstallValid?: boolean;
+        launchReady?: boolean;
+        probeSummary?: string;
     }>;
     requestedEngine?: MartinEngine;
     runStore: {
@@ -30,6 +42,7 @@ export interface MartinDoctorOutput {
         loopCount: number;
         latestRun?: LoopPreview;
     };
+    readiness: MartinReadinessReport;
     warnings: string[];
 }
 export declare function martinDoctorTool(input: MartinDoctorInput): Promise<MartinDoctorOutput>;

package/dist/tools/doctor.js

@@ -1,31 +1,46 @@
+import { probeCodexLaunch, resolveCliCommandAvailability } from "../vendor/adapters/index.js";
 import { resolveRunsRoot } from "../vendor/core/index.js";
 import { resolveSafeRepoRoot, resolveSafeRunsRootPath } from "../server-validation.js";
 import { getEngineAvailability, inspectRunsRoot, resolveExecutionMode } from "./tool-support.js";
+import { buildReadinessReport, inspectRepoSignals } from "./workflow-governance.js";
 export async function martinDoctorTool(input) {
     const workingDirectory = resolveSafeRepoRoot(input.workingDirectory);
     const runsRoot = resolveSafeRunsRootPath(input.runsDir, resolveRunsRoot(process.env));
+    const workspaceRoot = resolveSafeRepoRoot();
     const executionMode = resolveExecutionMode();
     const claude = getEngineAvailability("claude");
-    const codex = getEngineAvailability("codex");
+    const codex = resolveCliCommandAvailability("codex");
+    const gemini = getEngineAvailability("gemini");
+    const codexProbe = executionMode.liveMode && codex.available
+        ? probeCodexLaunch({
+            workingDirectory,
+            availability: codex
+        })
+        : undefined;
     const runStore = await inspectRunsRoot(runsRoot);
+    const signals = inspectRepoSignals(workingDirectory);
+    const readiness = buildReadinessReport(signals, runStore);
     const warnings = [];
     if (!runStore.exists) {
         warnings.push("Configured Martin runs root does not exist yet.");
     }
-    if (executionMode.liveMode && !claude.available && !codex.available) {
-        warnings.push("Neither claude nor codex is currently available on PATH for live runs.");
+    if (executionMode.liveMode && !claude.available && !codex.available && !gemini.available) {
+        warnings.push("None of claude, codex, or gemini is currently available on PATH for live runs.");
     }
     if (input.engine && executionMode.liveMode) {
-        const selected = input.engine === "claude" ? claude : codex;
+        const selected = input.engine === "claude" ? claude : input.engine === "gemini" ? gemini : codex;
         if (!selected.available) {
             warnings.push(`Requested engine '${input.engine}' is not available on PATH.`);
         }
+        if (input.engine === "codex" && codexProbe && !codexProbe.ok) {
+            warnings.push(codexProbe.summary);
+        }
     }
     warnings.push(...runStore.warnings);
     const status = warnings.length === 0 ? "ok" : "degraded";
     const summary = status === "ok"
-        ? `Doctor passed: ${runStore.loopCount} run(s) visible in ${runsRoot}.`
-        : `Doctor found ${warnings.length} issue(s); review warnings before live execution.`;
+        ? `Doctor passed: repo readiness ${readiness.score}/100 with ${runStore.loopCount} visible run(s).`
+        : `Doctor found ${warnings.length} issue(s); readiness ${readiness.score}/100 before live execution.`;
     return {
         status,
         summary,
@@ -35,12 +50,18 @@ export async function martinDoctorTool(input) {
             platform: process.platform
         },
         environment: {
-            workspaceRoot: resolveSafeRepoRoot(),
+            workspaceRoot,
             workingDirectory,
             runsRoot,
             mode: executionMode.mode,
             liveMode: executionMode.liveMode
         },
+        scope: {
+            invocationRoot: workspaceRoot,
+            workingDirectory,
+            repoRoot: workingDirectory,
+            runsRoot
+        },
         engines: {
             claude: {
                 available: claude.available,
@@ -50,7 +71,20 @@ export async function martinDoctorTool(input) {
             codex: {
                 available: codex.available,
                 detail: codex.detail,
-                ...(codex.resolvedPath ? { resolvedPath: codex.resolvedPath } : {})
+                ...(codex.resolvedPath ? { resolvedPath: codex.resolvedPath } : {}),
+                ...(codexProbe
+                    ? {
+                        hostPlatform: codexProbe.diagnosis.hostPlatform,
+                        nativeInstallValid: codexProbe.diagnosis.nativeInstallValid,
+                        launchReady: codexProbe.ok,
+                        probeSummary: codexProbe.summary
+                    }
+                    : {})
+            },
+            gemini: {
+                available: gemini.available,
+                detail: gemini.detail,
+                ...(gemini.resolvedPath ? { resolvedPath: gemini.resolvedPath } : {})
             }
         },
         ...(input.engine ? { requestedEngine: input.engine } : {}),
@@ -59,6 +93,7 @@ export async function martinDoctorTool(input) {
             loopCount: runStore.loopCount,
             ...(runStore.latestRun ? { latestRun: runStore.latestRun } : {})
         },
+        readiness,
         warnings
     };
 }

package/dist/tools/eval.d.ts

@@ -0,0 +1,24 @@
+export interface MartinEvalInput {
+    file?: string;
+    loopId?: string;
+    runsDir?: string;
+    latest?: boolean;
+}
+export interface MartinEvalOutput {
+    source: string;
+    sourceKind: "file" | "loop_id" | "latest" | "runs_root";
+    loopId: string;
+    score: number;
+    grade: "mergeable" | "mergeable_with_review" | "needs_review" | "blocked" | "insufficient_evidence";
+    checks: {
+        taskCompletion: "passed" | "warning" | "failed";
+        verifier: "passed" | "warning" | "failed";
+        diffDiscipline: "passed" | "warning" | "failed";
+        regressionRisk: "passed" | "warning" | "failed";
+        securityRisk: "passed" | "warning" | "failed";
+        reviewability: "passed" | "warning" | "failed";
+    };
+    warnings: string[];
+    summary: string;
+}
+export declare function martinEvalTool(input: MartinEvalInput): Promise<MartinEvalOutput>;