@martinloop/mcp 0.2.5 → 0.2.7

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" }
@@ -649,6 +656,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 +689,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 +822,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 +848,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 +911,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 +934,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 +971,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 +1231,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 +1397,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 +1481,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,5 @@
 import { type LoopPreview, type MartinEngine } from "./tool-support.js";
+import { type MartinReadinessReport } from "./workflow-governance.js";
 export interface MartinDoctorInput {
     workingDirectory?: string;
     runsDir?: string;
@@ -30,6 +31,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,6 +1,7 @@
 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));
@@ -8,6 +9,8 @@ export async function martinDoctorTool(input) {
     const claude = getEngineAvailability("claude");
     const codex = getEngineAvailability("codex");
     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.");
@@ -24,8 +27,8 @@ export async function martinDoctorTool(input) {
     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,
@@ -59,6 +62,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>;

package/dist/tools/eval.js

@@ -0,0 +1,65 @@
+import { loadDetailedLoopRecord, readLedgerEvents } from "./run-store.js";
+import { buildVerificationSummary } from "./tool-support.js";
+import { assessRunRisk, inspectRepoSignals } from "./workflow-governance.js";
+export async function martinEvalTool(input) {
+    const detail = await loadDetailedLoopRecord(input);
+    const ledgerEvents = await readLedgerEvents(detail);
+    const verification = buildVerificationSummary(detail.loop, ledgerEvents);
+    const repoRoot = detail.loop.task?.repoRoot;
+    const signals = inspectRepoSignals(repoRoot ?? process.cwd());
+    const risk = assessRunRisk({
+        objective: detail.loop.task?.objective ?? detail.loop.loopId,
+        allowedPaths: detail.loop.task?.allowedPaths ?? [],
+        blockedPaths: detail.loop.task?.deniedPaths ?? [],
+        verifiers: detail.loop.task?.verificationPlan ?? [],
+        signals
+    });
+    const checks = {
+        taskCompletion: detail.loop.status === "completed" ? "passed" : detail.loop.status === "exited" ? "warning" : "failed",
+        verifier: verification.status === "passed"
+            ? "passed"
+            : verification.status === "failed"
+                ? "failed"
+                : "warning",
+        diffDiscipline: (detail.loop.task?.allowedPaths?.length ?? 0) > 0 ? "passed" : "warning",
+        regressionRisk: verification.status === "passed" ? "passed" : "warning",
+        securityRisk: risk.level === "high" ? "failed" : risk.level === "medium" ? "warning" : "passed",
+        reviewability: detail.loop.attempts.length > 0 && (detail.loop.events?.length ?? 0) > 0 ? "passed" : "warning"
+    };
+    let score = 100;
+    score -= checks.taskCompletion === "failed" ? 25 : checks.taskCompletion === "warning" ? 10 : 0;
+    score -= checks.verifier === "failed" ? 25 : checks.verifier === "warning" ? 10 : 0;
+    score -= checks.diffDiscipline === "warning" ? 8 : 0;
+    score -= checks.regressionRisk === "warning" ? 10 : 0;
+    score -= checks.securityRisk === "failed" ? 20 : checks.securityRisk === "warning" ? 10 : 0;
+    score -= checks.reviewability === "warning" ? 8 : 0;
+    score = Math.max(0, score);
+    const grade = verification.status === "unavailable"
+        ? "insufficient_evidence"
+        : score >= 90
+            ? "mergeable"
+            : score >= 75
+                ? "mergeable_with_review"
+                : score >= 55
+                    ? "needs_review"
+                    : "blocked";
+    const warnings = [...detail.warnings, ...verification.warnings, ...risk.reasons];
+    return {
+        source: detail.source,
+        sourceKind: detail.sourceKind,
+        loopId: detail.loop.loopId,
+        score,
+        grade,
+        checks: { ...checks },
+        warnings,
+        summary: grade === "mergeable"
+            ? `Run ${detail.loop.loopId} looks mergeable with verifier-backed completion.`
+            : grade === "mergeable_with_review"
+                ? `Run ${detail.loop.loopId} looks mergeable with review; inspect dossier and risk notes first.`
+                : grade === "needs_review"
+                    ? `Run ${detail.loop.loopId} needs review before promotion.`
+                    : grade === "insufficient_evidence"
+                        ? `Run ${detail.loop.loopId} does not have enough evidence for a safe promotion decision.`
+                        : `Run ${detail.loop.loopId} is blocked from promotion by verification or risk gaps.`
+    };
+}

package/dist/tools/get-status.d.ts

@@ -33,5 +33,13 @@ export interface GetStatusOutput {
     inspection: {
         loop: LoopPreview;
     };
+    live: {
+        phase: string;
+        pauseState: "active" | "paused" | "cancellation_requested";
+        approvalState: "not_required" | "resume_requested";
+        commandsRun: number;
+        filesTouched: number;
+        verifierStep?: string;
+    };
 }
 export declare function getStatusTool(input: GetStatusInput): Promise<GetStatusOutput>;

package/dist/tools/get-status.js

@@ -1,9 +1,19 @@
 import { evaluateCostGovernor } from "../vendor/core/index.js";
 import { loadLoopRecordForStatus } from "./run-store.js";
 import { buildLoopPreview } from "./tool-support.js";
+import { readRunControlState } from "./run-controls.js";
 export async function getStatusTool(input) {
     const resolved = await loadLoopRecordForStatus(input);
     const loop = resolved.loop;
+    const control = input.loopJson !== undefined
+        ? {
+            requestedState: "active",
+            approvalState: "not_required",
+            receipts: []
+        }
+        : await readRunControlState(input);
+    const latestEvent = loop.events?.at(-1);
+    const changedFiles = loop.artifacts?.filter((artifact) => artifact.kind === "diff").length ?? 0;
     const costState = evaluateCostGovernor({
         budget: loop.budget,
         cost: {
@@ -35,6 +45,14 @@ export async function getStatusTool(input) {
         },
         inspection: {
             loop: buildLoopPreview(loop)
+        },
+        live: {
+            phase: latestEvent?.lifecycleState ?? loop.lifecycleState,
+            pauseState: control.requestedState,
+            approvalState: control.approvalState,
+            commandsRun: loop.attempts.length,
+            filesTouched: changedFiles,
+            ...(loop.task?.verificationPlan?.[0] ? { verifierStep: loop.task.verificationPlan[0] } : {})
         }
     };
 }