@martinloop/mcp 0.2.5 → 0.3.0

package/dist/tools/eval.js

@@ -0,0 +1,66 @@
+import { loadDetailedLoopRecord, readLedgerEvents } from "./run-store.js";
+import { resolveTrustedLoopRepoRoot } from "../server-validation.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 = resolveTrustedLoopRepoRoot(detail.loop.task?.repoRoot);
+    const signals = inspectRepoSignals(repoRoot);
+    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-run.d.ts

@@ -1,4 +1,5 @@
 import { buildArtifactSummary, buildBudgetSnapshot, buildCostSnapshot, buildLoopPreview, buildVerificationSummary } from "./tool-support.js";
+import type { ReceiptIntegritySummary } from "../vendor/contracts/index.js";
 export interface MartinGetRunInput {
     file?: string;
     loopId?: string;
@@ -12,6 +13,7 @@ export interface MartinGetRunOutput {
     budget: ReturnType<typeof buildBudgetSnapshot>;
     cost: ReturnType<typeof buildCostSnapshot>;
     verification: ReturnType<typeof buildVerificationSummary>;
+    receiptIntegrity: ReceiptIntegritySummary;
     artifacts: ReturnType<typeof buildArtifactSummary>;
     inspection: {
         runsRoot: string;

package/dist/tools/get-run.js

@@ -1,4 +1,4 @@
-import { buildArtifactSummary, buildBudgetSnapshot, buildCostSnapshot, buildLoopPreview, buildVerificationSummary } from "./tool-support.js";
+import { buildArtifactSummary, buildBudgetSnapshot, buildCostSnapshot, buildLoopPreview, resolveReceiptIntegrity, buildVerificationSummary } from "./tool-support.js";
 import { loadDetailedLoopRecord, readLedgerEvents } from "./run-store.js";
 export async function martinGetRunTool(input) {
     const detail = await loadDetailedLoopRecord(input);
@@ -11,6 +11,7 @@ export async function martinGetRunTool(input) {
         budget: buildBudgetSnapshot(detail.loop.budget),
         cost: buildCostSnapshot(detail.loop.cost),
         verification,
+        receiptIntegrity: resolveReceiptIntegrity(detail.loop),
         artifacts: buildArtifactSummary(detail.loop),
         inspection: {
             runsRoot: detail.runsRoot,

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] } : {})
         }
     };
 }

package/dist/tools/get-verification-results.d.ts

@@ -1,4 +1,5 @@
 import { buildLoopPreview, buildVerificationSummary } from "./tool-support.js";
+import type { ReceiptIntegritySummary } from "../vendor/contracts/index.js";
 export interface MartinGetVerificationResultsInput {
     file?: string;
     loopId?: string;
@@ -9,6 +10,7 @@ export interface MartinGetVerificationResultsOutput {
     sourceKind: "file" | "loop_id" | "latest" | "runs_root";
     loop: ReturnType<typeof buildLoopPreview>;
     verification: ReturnType<typeof buildVerificationSummary>;
+    receiptIntegrity: ReceiptIntegritySummary;
     warnings: string[];
 }
 export declare function martinGetVerificationResultsTool(input: MartinGetVerificationResultsInput): Promise<MartinGetVerificationResultsOutput>;

package/dist/tools/get-verification-results.js

@@ -1,4 +1,4 @@
-import { buildLoopPreview, buildVerificationSummary } from "./tool-support.js";
+import { buildLoopPreview, buildVerificationSummary, resolveReceiptIntegrity } from "./tool-support.js";
 import { loadDetailedLoopRecord, readLedgerEvents } from "./run-store.js";
 export async function martinGetVerificationResultsTool(input) {
     const detail = await loadDetailedLoopRecord(input);
@@ -9,6 +9,7 @@ export async function martinGetVerificationResultsTool(input) {
         sourceKind: detail.sourceKind,
         loop: buildLoopPreview(detail.loop),
         verification,
+        receiptIntegrity: resolveReceiptIntegrity(detail.loop),
         warnings: [...detail.warnings, ...verification.warnings]
     };
 }

package/dist/tools/logs.d.ts

@@ -0,0 +1,25 @@
+export interface MartinLogsInput {
+    file?: string;
+    loopId?: string;
+    runsDir?: string;
+    latest?: boolean;
+    limit?: number;
+}
+export interface MartinLogsOutput {
+    source: string;
+    sourceKind: "file" | "loop_id" | "latest" | "runs_root";
+    loopId: string;
+    logCount: number;
+    live: {
+        lifecycleState: string;
+        pauseState: "active" | "paused" | "cancellation_requested";
+        approvalState: "not_required" | "resume_requested";
+    };
+    entries: Array<{
+        timestamp?: string;
+        source: "event" | "ledger" | "control";
+        kind: string;
+        payload: Record<string, unknown>;
+    }>;
+}
+export declare function martinLogsTool(input: MartinLogsInput): Promise<MartinLogsOutput>;

package/dist/tools/logs.js

@@ -0,0 +1,49 @@
+import { readRunControlState } from "./run-controls.js";
+import { loadDetailedLoopRecord, readLedgerEvents } from "./run-store.js";
+export async function martinLogsTool(input) {
+    const detail = await loadDetailedLoopRecord(input);
+    const ledgerEvents = await readLedgerEvents(detail);
+    const controls = await readRunControlState(detail);
+    const limit = input.limit ?? 20;
+    const eventEntries = (detail.loop.events ?? []).map((event) => ({
+        timestamp: event.timestamp,
+        source: "event",
+        kind: event.type,
+        payload: event.payload ?? {}
+    }));
+    const ledgerEntries = ledgerEvents.map((event) => ({
+        timestamp: event.timestamp,
+        source: "ledger",
+        kind: event.kind,
+        payload: (event.payload ?? {})
+    }));
+    const controlEntries = controls.receipts.map((receipt) => ({
+        timestamp: receipt.requestedAt,
+        source: "control",
+        kind: `run.${receipt.action}`,
+        payload: {
+            controlId: receipt.controlId,
+            ...(receipt.reason ? { reason: receipt.reason } : {}),
+            ...(receipt.requestedBy ? { requestedBy: receipt.requestedBy } : {})
+        }
+    }));
+    const entries = [...eventEntries, ...ledgerEntries, ...controlEntries]
+        .sort((left, right) => {
+        const leftTime = left.timestamp ? new Date(left.timestamp).getTime() : 0;
+        const rightTime = right.timestamp ? new Date(right.timestamp).getTime() : 0;
+        return rightTime - leftTime;
+    })
+        .slice(0, limit);
+    return {
+        source: detail.source,
+        sourceKind: detail.sourceKind,
+        loopId: detail.loop.loopId,
+        logCount: entries.length,
+        live: {
+            lifecycleState: detail.loop.lifecycleState,
+            pauseState: controls.requestedState,
+            approvalState: controls.approvalState
+        },
+        entries
+    };
+}

package/dist/tools/plan.d.ts

@@ -0,0 +1,20 @@
+import { type MartinPlanProposal, type MartinPolicyPack } from "./workflow-governance.js";
+export interface MartinPlanInput {
+    objective: string;
+    workingDirectory?: string;
+    context?: string;
+    verificationPlan?: string[];
+    allowedPaths?: string[];
+    deniedPaths?: string[];
+    policyPack?: MartinPolicyPack;
+    maxUsd?: number;
+    maxIterations?: number;
+    maxTokens?: number;
+    maxMinutes?: number;
+    maxFilesChanged?: number;
+    maxCommands?: number;
+}
+export interface MartinPlanOutput extends MartinPlanProposal {
+    workingDirectory: string;
+}
+export declare function martinPlanTool(input: MartinPlanInput): Promise<MartinPlanOutput>;

package/dist/tools/plan.js

@@ -0,0 +1,10 @@
+import { resolveSafeRepoRoot } from "../server-validation.js";
+import { buildPlanProposal } from "./workflow-governance.js";
+export async function martinPlanTool(input) {
+    const workingDirectory = resolveSafeRepoRoot(input.workingDirectory);
+    const proposal = buildPlanProposal(workingDirectory, input);
+    return {
+        workingDirectory,
+        ...proposal
+    };
+}

package/dist/tools/pr-tools.d.ts

@@ -0,0 +1,31 @@
+import { type MartinRunDossierInput } from "./run-dossier.js";
+export interface MartinPrSummaryOutput {
+    loopId: string;
+    title: string;
+    body: string;
+    grade: string;
+    score: number;
+}
+export interface MartinCreatePrInput extends MartinRunDossierInput {
+    title?: string;
+    base?: string;
+    execute?: boolean;
+}
+export interface MartinCreatePrOutput extends MartinPrSummaryOutput {
+    execute: boolean;
+    created: boolean;
+    url?: string;
+    branch?: string;
+}
+export interface MartinReviewPrInput extends MartinRunDossierInput {
+    prBody?: string;
+}
+export interface MartinReviewPrOutput {
+    loopId: string;
+    verdict: "approve_with_review" | "needs_changes" | "blocked";
+    findings: string[];
+    summary: string;
+}
+export declare function martinPrSummaryTool(input: MartinRunDossierInput): Promise<MartinPrSummaryOutput>;
+export declare function martinCreatePrTool(input: MartinCreatePrInput): Promise<MartinCreatePrOutput>;
+export declare function martinReviewPrTool(input: MartinReviewPrInput): Promise<MartinReviewPrOutput>;

package/dist/tools/pr-tools.js

@@ -0,0 +1,112 @@
+import { spawnSync } from "node:child_process";
+import { loadDetailedLoopRecord } from "./run-store.js";
+import { martinRunDossierTool } from "./run-dossier.js";
+import { martinEvalTool } from "./eval.js";
+import { resolveTrustedLoopRepoRoot } from "../server-validation.js";
+import { detectCliAvailability } from "./tool-support.js";
+import { MartinToolError } from "./tool-errors.js";
+export async function martinPrSummaryTool(input) {
+    const dossier = await martinRunDossierTool({ ...input, format: "github-pr" });
+    const evaluation = await martinEvalTool(input);
+    const title = `martin: ${trimForTitle(dossier.loop.objective)}`;
+    const body = dossier.rendered ?? "";
+    return {
+        loopId: dossier.loop.loopId,
+        title,
+        body,
+        grade: evaluation.grade,
+        score: evaluation.score
+    };
+}
+export async function martinCreatePrTool(input) {
+    const summary = await martinPrSummaryTool(input);
+    const detail = await loadDetailedLoopRecord(input);
+    const repoRoot = resolveTrustedLoopRepoRoot(detail.loop.task?.repoRoot);
+    const branch = readGitValue(repoRoot, ["branch", "--show-current"]);
+    const title = input.title?.trim() || summary.title;
+    if (!input.execute) {
+        return {
+            ...summary,
+            title,
+            execute: false,
+            created: false,
+            ...(branch ? { branch } : {})
+        };
+    }
+    const gh = detectCliAvailability("gh");
+    if (!gh.available) {
+        throw new MartinToolError("engine_unavailable", "GitHub CLI is not available on PATH.", {
+            category: "environment",
+            suggestion: "Install gh or rerun martin_create_pr with execute=false to preview the PR body.",
+            retryable: false
+        });
+    }
+    const args = ["pr", "create", "--title", title, "--body", summary.body];
+    if (input.base) {
+        args.push("--base", input.base);
+    }
+    const result = spawnSync("gh", args, {
+        cwd: repoRoot,
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "pipe"]
+    });
+    if (result.status !== 0) {
+        throw new MartinToolError("tool_execution_failed", "GitHub PR creation failed.", {
+            category: "transient",
+            suggestion: (result.stderr || result.stdout || "Check gh auth and branch state.").trim(),
+            retryable: false
+        });
+    }
+    const url = `${result.stdout ?? ""}`.split(/\r?\n/u).map((line) => line.trim()).find(Boolean);
+    return {
+        ...summary,
+        title,
+        execute: true,
+        created: true,
+        ...(url ? { url } : {}),
+        ...(branch ? { branch } : {})
+    };
+}
+export async function martinReviewPrTool(input) {
+    const summary = await martinPrSummaryTool(input);
+    const evaluation = await martinEvalTool(input);
+    const findings = [];
+    if (evaluation.grade === "blocked" || evaluation.grade === "insufficient_evidence") {
+        findings.push("Run evidence is not strong enough for a safe merge decision.");
+    }
+    if (evaluation.checks.verifier !== "passed") {
+        findings.push("Verifier evidence is not green.");
+    }
+    if (evaluation.checks.securityRisk !== "passed") {
+        findings.push("Risk score requires closer human review.");
+    }
+    if (input.prBody && !/MartinLoop Run Dossier/iu.test(input.prBody)) {
+        findings.push("PR body is missing the MartinLoop dossier section.");
+    }
+    const verdict = findings.length === 0
+        ? "approve_with_review"
+        : findings.some((finding) => /not strong enough|not green/iu.test(finding))
+            ? "blocked"
+            : "needs_changes";
+    return {
+        loopId: summary.loopId,
+        verdict,
+        findings,
+        summary: verdict === "approve_with_review"
+            ? "PR evidence looks reviewable."
+            : verdict === "needs_changes"
+                ? "PR needs changes before review is complete."
+                : "PR is blocked by evidence or verifier gaps."
+    };
+}
+function trimForTitle(value) {
+    return value.length > 60 ? `${value.slice(0, 57).trimEnd()}...` : value;
+}
+function readGitValue(cwd, args) {
+    const result = spawnSync("git", args, {
+        cwd,
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "pipe"]
+    });
+    return result.status === 0 ? result.stdout.trim() || undefined : undefined;
+}

package/dist/tools/preflight.d.ts

@@ -1,12 +1,19 @@
+import { type CodexHostPlatform } from "../vendor/adapters/index.js";
 import { type MartinEngine } from "./tool-support.js";
+import { buildPolicyPackDefinition, type MartinPlanProposal, type MartinPolicyPack, type MartinRiskAssessment, type MartinRunContract } from "./workflow-governance.js";
 export interface MartinPreflightInput {
     objective: string;
     workingDirectory?: string;
     engine?: MartinEngine;
     model?: string;
+    context?: string;
+    policyPack?: MartinPolicyPack;
     maxUsd?: number;
     maxIterations?: number;
     maxTokens?: number;
+    maxMinutes?: number;
+    maxFilesChanged?: number;
+    maxCommands?: number;
     verificationPlan?: string[];
     allowedPaths?: string[];
     deniedPaths?: string[];
@@ -17,8 +24,14 @@ export interface MartinPreflightOutput {
     ok: boolean;
     summary: string;
     warnings: string[];
+    scope: {
+        invocationRoot: string;
+        workingDirectory: string;
+        repoRoot: string;
+        runsRoot: string;
+    };
     readiness: {
-        mode: "live" | "stub";
+        mode: "live" | "proof";
         liveMode: boolean;
         engineReady: boolean;
     };
@@ -46,6 +59,12 @@ export interface MartinPreflightOutput {
             detail: string;
             resolvedPath?: string;
         };
+        codexDiagnostics?: {
+            hostPlatform: CodexHostPlatform;
+            nativeInstallValid: boolean;
+            launchReady: boolean;
+            summary: string;
+        };
         runsRoot: string;
         pathScope: {
             repoRoot: string;
@@ -58,5 +77,9 @@ export interface MartinPreflightOutput {
             loopRecordPathPattern: string;
         };
     };
+    policy: ReturnType<typeof buildPolicyPackDefinition>;
+    risk: MartinRiskAssessment;
+    runContract: MartinRunContract;
+    plan: MartinPlanProposal;
 }
 export declare function martinPreflightTool(input: MartinPreflightInput): Promise<MartinPreflightOutput>;

package/dist/tools/preflight.js

@@ -1,12 +1,22 @@
+import { probeCodexLaunch, resolveCliCommandAvailability } from "../vendor/adapters/index.js";
 import { DEFAULT_BUDGET } from "../vendor/contracts/index.js";
 import { resolveRunsRoot } from "../vendor/core/index.js";
 import { resolveSafeRepoRoot } from "../server-validation.js";
 import { formatUsd, getEngineAvailability, resolveExecutionMode } from "./tool-support.js";
+import { buildPlanProposal, buildRunContract, buildPolicyPackDefinition, inspectRepoSignals } from "./workflow-governance.js";
 export async function martinPreflightTool(input) {
     const executionMode = resolveExecutionMode();
+    const workspaceRoot = resolveSafeRepoRoot();
     const workingDirectory = resolveSafeRepoRoot(input.workingDirectory);
+    const signals = inspectRepoSignals(workingDirectory);
     const engine = input.engine ?? "claude";
-    const engineAvailability = getEngineAvailability(engine);
+    const engineAvailability = engine === "codex" ? resolveCliCommandAvailability("codex") : getEngineAvailability(engine);
+    const codexProbe = executionMode.liveMode && engine === "codex" && engineAvailability.available
+        ? probeCodexLaunch({
+            workingDirectory,
+            availability: engineAvailability
+        })
+        : undefined;
     const warnings = [];
     const allowedPaths = input.allowedPaths ?? [];
     const deniedPaths = input.deniedPaths ?? [];
@@ -18,11 +28,14 @@ export async function martinPreflightTool(input) {
         ...(input.maxTokens !== undefined ? { maxTokens: input.maxTokens } : {})
     };
     if (!executionMode.liveMode) {
-        warnings.push("Stub mode is active; preflight only proves configuration shape, not live CLI readiness.");
+        warnings.push("Proof mode is active; preflight only proves configuration shape, not live CLI readiness.");
     }
     else if (!engineAvailability.available) {
         warnings.push(`Requested engine '${engine}' is not available on PATH.`);
     }
+    else if (engine === "codex" && codexProbe && !codexProbe.ok) {
+        warnings.push(codexProbe.summary);
+    }
     if ((input.verificationPlan?.length ?? 0) === 0) {
         warnings.push("No verificationPlan was provided; Martin can run, but completion confidence will be lower.");
     }
@@ -32,17 +45,30 @@ export async function martinPreflightTool(input) {
     if (overlappingScopes.length > 0) {
         warnings.push(`Some path patterns appear in both allowedPaths and deniedPaths: ${overlappingScopes.join(", ")}.`);
     }
-    const ok = !executionMode.liveMode || engineAvailability.available;
+    const plan = buildPlanProposal(workingDirectory, input);
+    const runContract = buildRunContract(workingDirectory, input);
+    const policy = buildPolicyPackDefinition(input.policyPack, signals);
+    const engineReady = !executionMode.liveMode ||
+        (engineAvailability.available && (engine !== "codex" || codexProbe?.ok !== false));
+    const ok = engineReady;
     return {
         ok,
         summary: ok
-            ? `Preflight ready for ${engine} in ${workingDirectory} with a ${formatUsd(budget.maxUsd)} budget cap.`
-            : `Preflight blocked: ${engine} is not available for live execution.`,
+            ? `Preflight ready for ${engine} in ${workingDirectory} with a ${formatUsd(budget.maxUsd)} budget cap and ${runContract.risk.level} risk.`
+            : `Preflight blocked: ${engine === "codex" && codexProbe && !codexProbe.ok
+                ? codexProbe.summary
+                : `${engine} is not available for live execution.`}`,
         warnings,
+        scope: {
+            invocationRoot: workspaceRoot,
+            workingDirectory,
+            repoRoot: workingDirectory,
+            runsRoot: resolveRunsRoot(process.env)
+        },
         readiness: {
             mode: executionMode.mode,
             liveMode: executionMode.liveMode,
-            engineReady: !executionMode.liveMode || engineAvailability.available
+            engineReady
         },
         normalized: {
             objective: input.objective,
@@ -65,6 +91,16 @@ export async function martinPreflightTool(input) {
                     ? { resolvedPath: engineAvailability.resolvedPath }
                     : {})
             },
+            ...(codexProbe
+                ? {
+                    codexDiagnostics: {
+                        hostPlatform: codexProbe.diagnosis.hostPlatform,
+                        nativeInstallValid: codexProbe.diagnosis.nativeInstallValid,
+                        launchReady: codexProbe.ok,
+                        summary: codexProbe.summary
+                    }
+                }
+                : {}),
             runsRoot: resolveRunsRoot(process.env),
             pathScope: {
                 repoRoot: workingDirectory,
@@ -76,6 +112,10 @@ export async function martinPreflightTool(input) {
                 runDirectoryPattern: "<runsRoot>/<loopId>/",
                 loopRecordPathPattern: "<runsRoot>/<loopId>/loop-record.json"
             }
-        }
+        },
+        policy,
+        risk: runContract.risk,
+        runContract,
+        plan
     };
 }

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

@@ -0,0 +1,36 @@
+import { type DetailedLoopSource } from "./run-store.js";
+export type MartinControlAction = "pause" | "cancel" | "continue";
+export interface MartinRunControlRequestInput {
+    file?: string;
+    loopId?: string;
+    runsDir?: string;
+    latest?: boolean;
+    reason?: string;
+    requestedBy?: string;
+}
+export interface MartinRunControlReceipt {
+    controlId: string;
+    loopId: string;
+    action: MartinControlAction;
+    requestedAt: string;
+    reason?: string;
+    requestedBy?: string;
+}
+export interface MartinRunControlState {
+    requestedState: "active" | "paused" | "cancellation_requested";
+    latestReceipt?: MartinRunControlReceipt;
+    approvalState: "not_required" | "resume_requested";
+    receipts: MartinRunControlReceipt[];
+    receiptPath?: string;
+}
+export interface MartinRunControlOutput {
+    ok: boolean;
+    summary: string;
+    loopId: string;
+    requestedAction: MartinControlAction;
+    state: MartinRunControlState;
+}
+export declare function createRunControlReceipt(action: MartinControlAction, input: MartinRunControlRequestInput): Promise<MartinRunControlOutput>;
+export declare function readRunControlState(detailOrInput: DetailedLoopSource | MartinRunControlRequestInput): Promise<MartinRunControlState>;
+export declare function readControlReceipts(receiptPath: string): Promise<MartinRunControlReceipt[]>;
+export declare function validateControlReason(value?: string): string | undefined;