@martinloop/mcp 0.2.5 → 0.3.0

package/dist/tools/run-controls.js

@@ -0,0 +1,88 @@
+import { appendFile, readFile } from "node:fs/promises";
+import path from "node:path";
+import { invalidArgumentsError, unsupportedOperationError } from "./tool-errors.js";
+import { loadDetailedLoopRecord } from "./run-store.js";
+export async function createRunControlReceipt(action, input) {
+    const detail = await loadDetailedLoopRecord(input);
+    if (!detail.canonicalRunDirectory) {
+        throw unsupportedOperationError("Run control receipts require a canonical run directory.", "Use a canonical loopId-backed Martin run before writing control receipts.");
+    }
+    const receipt = {
+        controlId: `ctl_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`,
+        loopId: detail.loop.loopId,
+        action,
+        requestedAt: new Date().toISOString(),
+        ...(input.reason ? { reason: input.reason } : {}),
+        ...(input.requestedBy ? { requestedBy: input.requestedBy } : {})
+    };
+    const receiptPath = path.join(detail.canonicalRunDirectory, "controls.jsonl");
+    await appendFile(receiptPath, `${JSON.stringify(receipt)}\n`, "utf8");
+    const state = await readRunControlState(detail);
+    return {
+        ok: true,
+        summary: action === "cancel"
+            ? `Cancellation request recorded for ${detail.loop.loopId}.`
+            : action === "pause"
+                ? `Pause request recorded for ${detail.loop.loopId}.`
+                : `Continue request recorded for ${detail.loop.loopId}.`,
+        loopId: detail.loop.loopId,
+        requestedAction: action,
+        state
+    };
+}
+export async function readRunControlState(detailOrInput) {
+    const detail = isDetailedLoopSource(detailOrInput)
+        ? detailOrInput
+        : await loadDetailedLoopRecord(detailOrInput);
+    const receiptPath = detail.canonicalRunDirectory
+        ? path.join(detail.canonicalRunDirectory, "controls.jsonl")
+        : undefined;
+    const receipts = receiptPath ? await readControlReceipts(receiptPath) : [];
+    const latestReceipt = receipts.at(-1);
+    return {
+        requestedState: latestReceipt?.action === "pause"
+            ? "paused"
+            : latestReceipt?.action === "cancel"
+                ? "cancellation_requested"
+                : "active",
+        ...(latestReceipt ? { latestReceipt } : {}),
+        approvalState: latestReceipt?.action === "pause" ? "resume_requested" : "not_required",
+        receipts,
+        ...(receiptPath ? { receiptPath } : {})
+    };
+}
+export async function readControlReceipts(receiptPath) {
+    try {
+        const contents = await readFile(receiptPath, "utf8");
+        return contents
+            .split(/\r?\n/u)
+            .map((line) => line.trim())
+            .filter(Boolean)
+            .map((line) => JSON.parse(line))
+            .filter(isRunControlReceipt);
+    }
+    catch {
+        return [];
+    }
+}
+function isDetailedLoopSource(value) {
+    return typeof value === "object" && value !== null && "loop" in value && "runsRoot" in value;
+}
+function isRunControlReceipt(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        typeof value.controlId === "string" &&
+        typeof value.loopId === "string" &&
+        typeof value.action === "string" &&
+        typeof value.requestedAt === "string");
+}
+export function validateControlReason(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    if (trimmed.length === 0) {
+        throw invalidArgumentsError("Invalid reason.");
+    }
+    return trimmed;
+}

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

@@ -1,9 +1,14 @@
 import { buildArtifactSummary, buildBudgetSnapshot, buildCostSnapshot, buildEventSummaries, buildLoopPreview, buildVerificationSummary } from "./tool-support.js";
+import { readRunControlState } from "./run-controls.js";
+import { martinEvalTool } from "./eval.js";
+import { assessRunRisk } from "./workflow-governance.js";
+import type { ReceiptIntegritySummary } from "../vendor/contracts/index.js";
 export interface MartinRunDossierInput {
     file?: string;
     loopId?: string;
     runsDir?: string;
     latest?: boolean;
+    format?: "json" | "md" | "github-pr";
 }
 export interface MartinRunDossierOutput {
     source: string;
@@ -11,6 +16,7 @@ export interface MartinRunDossierOutput {
     loop: ReturnType<typeof buildLoopPreview>;
     budget: ReturnType<typeof buildBudgetSnapshot>;
     cost: ReturnType<typeof buildCostSnapshot>;
+    receiptIntegrity: ReceiptIntegritySummary;
     attempts: Array<{
         index: number;
         attemptId?: string;
@@ -30,6 +36,16 @@ export interface MartinRunDossierOutput {
         resources: string[];
         prompts: string[];
     };
+    review: {
+        diffSummary: string;
+        risk: ReturnType<typeof assessRunRisk>;
+        outcome: "passed" | "failed" | "needs_review";
+        nextAction: string;
+    };
+    evaluation: Awaited<ReturnType<typeof martinEvalTool>>;
+    control: Awaited<ReturnType<typeof readRunControlState>>;
+    format: "json" | "md" | "github-pr";
+    rendered?: string;
     inspection: {
         runsRoot: string;
         canonicalRunDirectory?: string;

package/dist/tools/run-dossier.js

@@ -1,9 +1,23 @@
-import { buildArtifactSummary, buildBudgetSnapshot, buildCostSnapshot, buildEventSummaries, buildLoopPreview, buildSuggestedPromptNames, buildSuggestedResourceUris, buildVerificationSummary } from "./tool-support.js";
+import { buildArtifactSummary, buildBudgetSnapshot, buildCostSnapshot, buildEventSummaries, buildLoopPreview, resolveReceiptIntegrity, buildSuggestedPromptNames, buildSuggestedResourceUris, buildVerificationSummary } from "./tool-support.js";
+import { resolveTrustedLoopRepoRoot } from "../server-validation.js";
 import { loadDetailedLoopRecord, readAttemptArtifactFiles, readLedgerEvents } from "./run-store.js";
+import { readRunControlState } from "./run-controls.js";
+import { martinEvalTool } from "./eval.js";
+import { assessRunRisk, inspectRepoSignals } from "./workflow-governance.js";
 export async function martinRunDossierTool(input) {
     const detail = await loadDetailedLoopRecord(input);
     const ledgerEvents = await readLedgerEvents(detail);
     const verification = buildVerificationSummary(detail.loop, ledgerEvents);
+    const control = await readRunControlState(detail);
+    const evaluation = await martinEvalTool(input);
+    const repoRoot = resolveTrustedLoopRepoRoot(detail.loop.task?.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: inspectRepoSignals(repoRoot)
+    });
     const attempts = await Promise.all(detail.loop.attempts.map(async (attempt) => ({
         index: attempt.index,
         ...(attempt.attemptId ? { attemptId: attempt.attemptId } : {}),
@@ -16,12 +30,29 @@ export async function martinRunDossierTool(input) {
         ...(attempt.summary ? { summary: attempt.summary } : {}),
         artifactFiles: await readAttemptArtifactFiles(detail, attempt.index)
     })));
-    return {
+    const review = {
+        diffSummary: attempts.length > 0
+            ? `Run touched ${attempts.length} attempt(s); latest summary: ${attempts.at(-1)?.summary ?? "No attempt summary recorded."}`
+            : "No attempts were recorded for this run.",
+        risk,
+        outcome: verification.status === "passed"
+            ? "passed"
+            : verification.status === "failed"
+                ? "failed"
+                : "needs_review",
+        nextAction: verification.status === "passed"
+            ? "Review the dossier and evaluation, then decide whether to merge or promote."
+            : verification.status === "failed"
+                ? "Investigate the latest verifier failure before retrying or promoting."
+                : "Collect more evidence before claiming completion."
+    };
+    const output = {
         source: detail.source,
         sourceKind: detail.sourceKind,
         loop: buildLoopPreview(detail.loop),
         budget: buildBudgetSnapshot(detail.loop.budget),
         cost: buildCostSnapshot(detail.loop.cost),
+        receiptIntegrity: resolveReceiptIntegrity(detail.loop),
         attempts,
         verification,
         artifacts: buildArtifactSummary(detail.loop),
@@ -30,6 +61,10 @@ export async function martinRunDossierTool(input) {
             resources: buildSuggestedResourceUris(detail.loop.loopId),
             prompts: buildSuggestedPromptNames()
         },
+        review,
+        evaluation,
+        control,
+        format: input.format ?? "json",
         inspection: {
             runsRoot: detail.runsRoot,
             ...(detail.canonicalRunDirectory ? { canonicalRunDirectory: detail.canonicalRunDirectory } : {}),
@@ -38,4 +73,31 @@ export async function martinRunDossierTool(input) {
         },
         warnings: [...detail.warnings, ...verification.warnings]
     };
+    if (output.format !== "json") {
+        output.rendered = renderDossier(output);
+    }
+    return output;
+}
+function renderDossier(output) {
+    const lines = [
+        output.format === "github-pr" ? "## MartinLoop Run Dossier" : "# MartinLoop Run Dossier",
+        "",
+        `Objective: ${output.loop.objective}`,
+        `Run: ${output.loop.loopId}`,
+        `Status: ${output.loop.status} / ${output.loop.lifecycleState}`,
+        `Attempts: ${output.attempts.length}`,
+        `Verifiers: ${output.verification.status}`,
+        `Risk: ${output.review.risk.level} (${output.review.risk.score})`,
+        `Allowed paths: ${output.review.risk.reasons.length > 0 ? output.review.risk.reasons.join("; ") : "No major risk reasons recorded."}`,
+        "",
+        "Review Summary:",
+        output.review.diffSummary,
+        "",
+        "Next Action:",
+        output.review.nextAction
+    ];
+    if (output.format === "github-pr") {
+        lines.push("", `Evaluation: ${output.evaluation.grade} (${output.evaluation.score})`);
+    }
+    return lines.join("\n");
 }

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

@@ -1,9 +1,9 @@
-import { type LoopBudget } from "../vendor/contracts/index.js";
+import { type LoopBudget, type ReceiptScope } from "../vendor/contracts/index.js";
 import { buildArtifactSummary, buildVerificationSummary, buildLoopPreview, type MartinEngine } from "./tool-support.js";
 export interface RunLoopInput {
     objective: string;
     workingDirectory?: string;
-    engine?: "claude" | "codex";
+    engine?: "claude" | "codex" | "gemini";
     model?: string;
     maxUsd?: number;
     maxIterations?: number;
@@ -35,6 +35,7 @@ export interface RunLoopOutput {
         runDirectory: string;
         loopRecordPath: string;
         ledgerPath: string;
+        receiptScope: ReceiptScope;
         loop: ReturnType<typeof buildLoopPreview>;
         verification: ReturnType<typeof buildVerificationSummary>;
         artifacts: ReturnType<typeof buildArtifactSummary>;

package/dist/tools/run-loop.js

@@ -1,4 +1,4 @@
-import { createClaudeCliAdapter, createCodexCliAdapter, createStubDirectProviderAdapter } from "../vendor/adapters/index.js";
+import { createClaudeCliAdapter, createCodexCliAdapter, createGeminiCliAdapter, probeCodexLaunch, resolveCliCommandAvailability, createVerifierOnlyAdapter } from "../vendor/adapters/index.js";
 import { createFileRunStore, evaluateCostGovernor, resolveRunsRoot, runMartin } from "../vendor/core/index.js";
 import { DEFAULT_BUDGET } from "../vendor/contracts/index.js";
 import { normalizeSafePathPatterns, resolveSafeRepoRoot } from "../server-validation.js";
@@ -11,19 +11,57 @@ export async function runLoopTool(input) {
     const allowedPaths = normalizeSafePathPatterns(input.allowedPaths, "allowedPaths");
     const deniedPaths = normalizeSafePathPatterns(input.deniedPaths, "deniedPaths");
     const executionMode = resolveExecutionMode();
-    const engineAvailability = getEngineAvailability(engine);
-    if (executionMode.liveMode && !engineAvailability.available) {
-        throw new MartinToolError("engine_unavailable", `Engine '${engine}' is not available on PATH.`, {
-            category: "environment",
-            suggestion: "Install the requested CLI or set MARTIN_LIVE=false for stub execution.",
-            retryable: false
-        });
+    const workspaceRoot = resolveSafeRepoRoot();
+    const runsRoot = resolveRunsRoot(process.env);
+    const receiptScope = {
+        invocationRoot: workspaceRoot,
+        workingDirectory,
+        repoRoot: workingDirectory,
+        runsRoot
+    };
+    if (executionMode.liveMode) {
+        if (engine === "codex") {
+            const engineAvailability = resolveCliCommandAvailability("codex");
+            if (!engineAvailability.available) {
+                throw new MartinToolError("engine_unavailable", `Engine '${engine}' is not available on PATH.`, {
+                    category: "environment",
+                    suggestion: "Install the requested CLI or set MARTIN_LIVE=false for a no-spend proof run.",
+                    retryable: false
+                });
+            }
+            const codexProbe = probeCodexLaunch({
+                workingDirectory,
+                availability: engineAvailability
+            });
+            if (!codexProbe.ok) {
+                throw new MartinToolError("engine_unavailable", codexProbe.summary, {
+                    category: "environment",
+                    suggestion: "Run martin_doctor or martin_preflight with engine='codex' before retrying live governed work.",
+                    retryable: false
+                });
+            }
+        }
+        else {
+            const engineAvailability = getEngineAvailability(engine);
+            if (!engineAvailability.available) {
+                throw new MartinToolError("engine_unavailable", `Engine '${engine}' is not available on PATH.`, {
+                    category: "environment",
+                    suggestion: "Install the requested CLI or set MARTIN_LIVE=false for a no-spend proof run.",
+                    retryable: false
+                });
+            }
+        }
     }
-    const adapter = process.env.MARTIN_LIVE === "false"
-        ? createStubDirectProviderAdapter({ label: "Stub adapter (MARTIN_LIVE=false)", providerId: "stub", model: "stub" })
+    const adapter = !executionMode.liveMode
+        ? createVerifierOnlyAdapter({
+            workingDirectory,
+            label: "Proof mode adapter (MARTIN_LIVE=false)"
+        })
         : engine === "codex"
             ? createCodexCliAdapter({ workingDirectory, ...(model ? { model } : {}) })
-            : createClaudeCliAdapter({ workingDirectory, ...(model ? { model } : {}) });
+            : engine === "gemini"
+                ? createGeminiCliAdapter({ workingDirectory, ...(model ? { model } : {}) })
+                : createClaudeCliAdapter({ workingDirectory, ...(model ? { model } : {}) });
     const partialBudget = {};
     if (input.maxUsd !== undefined) {
         partialBudget.maxUsd = input.maxUsd;
@@ -41,7 +79,8 @@ export async function runLoopTool(input) {
     const result = await runMartin({
         workspaceId: input.workspaceId ?? "ws_mcp",
         projectId: input.projectId ?? "proj_mcp",
-        store: createFileRunStore({ runsRoot: resolveRunsRoot(process.env) }),
+        store: createFileRunStore({ runsRoot }),
+        receiptScope,
         task: {
             title: input.objective.slice(0, 100),
             objective: input.objective,
@@ -65,7 +104,6 @@ export async function runLoopTool(input) {
         },
         attemptsUsed: result.loop.attempts.length
     });
-    const runsRoot = resolveRunsRoot(process.env);
     const recordPaths = buildRunRecordPaths(runsRoot, result.loop.loopId);
     const verification = buildVerificationSummary(result.loop);
     const artifacts = buildArtifactSummary(result.loop);
@@ -87,6 +125,7 @@ export async function runLoopTool(input) {
         budget,
         inspection: {
             ...recordPaths,
+            receiptScope: result.loop.receiptScope ?? receiptScope,
             loop: buildLoopPreview(result.loop),
             verification,
             artifacts

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

@@ -1,5 +1,5 @@
 import type { MartinErrorCategory } from "../vendor/contracts/index.js";
-export type ToolFailureCode = "attempt_not_found" | "engine_unavailable" | "invalid_arguments" | "invalid_json" | "invalid_path" | "invalid_selector" | "no_loop_records" | "store_unreadable" | "tool_execution_failed" | "unknown_tool" | "unsupported_operation";
+export type ToolFailureCode = "attempt_not_found" | "engine_unavailable" | "invalid_arguments" | "invalid_json" | "invalid_path" | "invalid_selector" | "no_loop_records" | "policy_blocked" | "store_unreadable" | "tool_execution_failed" | "unknown_tool" | "unsupported_operation";
 export type ToolFailureCategory = MartinErrorCategory;
 export interface ToolFailure {
     code: ToolFailureCode;

package/dist/tools/tool-errors.js

@@ -92,7 +92,7 @@ export function toToolFailure(error) {
             code: "engine_unavailable",
             category: "environment",
             message,
-            suggestion: "Install the requested CLI or set MARTIN_LIVE=false for stub execution.",
+            suggestion: "Install the requested CLI or set MARTIN_LIVE=false for a no-spend proof run.",
             retryable: false
         };
     }

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

@@ -1,6 +1,6 @@
-import type { LoopArtifact, LoopBudget, LoopCost, LoopEvent, LoopTask } from "../vendor/contracts/index.js";
+import type { LoopArtifact, LoopBudget, LoopCost, LoopEvent, LoopTask, ReceiptIntegritySummary, ReceiptScope } from "../vendor/contracts/index.js";
 import { type LedgerEvent, type LoopAttemptRecord, type LoopRunRecord } from "../vendor/core/index.js";
-export type MartinEngine = "claude" | "codex";
+export type MartinEngine = "claude" | "codex" | "gemini";
 export interface InspectableLoopAttempt extends LoopAttemptRecord {
     attemptId?: string;
     summary?: string;
@@ -11,6 +11,8 @@ export interface InspectableLoopRecord extends Omit<LoopRunRecord, "attempts" |
     artifacts?: LoopArtifact[];
     events?: LoopEvent[];
     metadata?: Record<string, string>;
+    receiptIntegrity?: ReceiptIntegritySummary;
+    receiptScope?: ReceiptScope;
 }
 export interface LoopPreview {
     loopId: string;
@@ -90,7 +92,7 @@ export interface CliAvailability {
 }
 export interface ExecutionMode {
     liveMode: boolean;
-    mode: "live" | "stub";
+    mode: "live" | "proof";
     detail: string;
 }
 export interface RunStoreInspection extends LoopCollectionSummary {
@@ -113,6 +115,7 @@ export declare function buildLoopPreview(loop: InspectableLoopRecord): LoopPrevi
 export declare function buildAttemptSummary(attempt: InspectableLoopAttempt, artifacts?: AttemptArtifactFiles): AttemptSummary;
 export declare function buildArtifactSummary(loop: InspectableLoopRecord): ArtifactSummary;
 export declare function buildVerificationSummary(loop: InspectableLoopRecord, ledgerEvents?: LedgerEvent[]): VerificationSummary;
+export declare function resolveReceiptIntegrity(loop: InspectableLoopRecord): ReceiptIntegritySummary;
 export declare function buildEventSummaries(loop: InspectableLoopRecord, limit?: number): EventSummary[];
 export declare function buildLoopCollectionSummary(loops: Array<LoopRunRecord | InspectableLoopRecord>): LoopCollectionSummary;
 export declare function inspectRunsRoot(runsRoot?: string): Promise<RunStoreInspection>;

package/dist/tools/tool-support.js

@@ -11,10 +11,10 @@ export function resolveExecutionMode() {
     const liveMode = process.env.MARTIN_LIVE !== "false";
     return {
         liveMode,
-        mode: liveMode ? "live" : "stub",
+        mode: liveMode ? "live" : "proof",
         detail: liveMode
             ? "Live CLI execution is enabled."
-            : "Stub mode is active because MARTIN_LIVE=false."
+            : "Proof mode is active because MARTIN_LIVE=false."
     };
 }
 export function detectCliAvailability(command) {
@@ -126,7 +126,11 @@ export function buildVerificationSummary(loop, ledgerEvents = []) {
     const verificationEvents = (loop.events ?? []).filter((event) => event.type === "verification.completed");
     const verificationLedgerEvents = ledgerEvents.filter((event) => event.kind === "verification.completed");
     const warnings = [];
+    const integrity = resolveReceiptIntegrity(loop);
     const ledgerWarnings = getLedgerWarnings(ledgerEvents);
+    if (integrity.state !== "verified") {
+        warnings.push(`Receipt integrity is ${integrity.state}; persisted verifier evidence is not trustworthy yet.`);
+    }
     warnings.push(...ledgerWarnings);
     if (verificationEvents.length === 0) {
         warnings.push(verificationLedgerEvents.length > 0
@@ -163,6 +167,12 @@ export function buildVerificationSummary(loop, ledgerEvents = []) {
         warnings
     };
 }
+export function resolveReceiptIntegrity(loop) {
+    return (loop.receiptIntegrity ?? {
+        state: "unsigned",
+        reason: "Receipt integrity metadata was not available on the loop record."
+    });
+}
 export function buildEventSummaries(loop, limit = 5) {
     return (loop.events ?? [])
         .slice(-limit)
@@ -272,18 +282,42 @@ export function buildSuggestedResourceUris(loopId) {
         "martin://server/health",
         "martin://runs/recent",
         "martin://runs/triage",
+        "martin://runs/latest",
+        "martin://runs/latest/summary",
+        "martin://runs/latest/proof-card",
+        "martin://runs/latest/budget-status",
+        "martin://runs/latest/verifier-evidence",
+        "martin://runs/latest/rollback-evidence",
+        "martin://policies/current",
+        "martin://repo/risk-map",
+        "martin://verifiers/results",
+        "martin://agent/next-step",
         `martin://runs/${loopId}`,
+        `martin://runs/${loopId}/dossier`,
         `martin://runs/${loopId}/verification`,
         "martin://guides/mcp-usage",
+        "martin://guides/agent-start",
         "martin://guides/publish-readiness"
     ];
 }
 export function buildSuggestedPromptNames() {
     return [
+        "martin_start",
+        "martin_preflight",
+        "martin_triage",
+        "martin_resume",
+        "martin_prove",
+        "martin_release_check",
         "martin_governed_coding_kickoff",
         "martin_debug_failed_run",
         "martin_publish_readiness_review",
-        "martin_triage_run_store"
+        "martin_triage_run_store",
+        "safe_bug_fix",
+        "write_tests_first",
+        "small_refactor",
+        "security_review",
+        "pr_review",
+        "release_check"
     ];
 }
 function countBy(values, key) {

package/dist/tools/workflow-governance.d.ts

@@ -0,0 +1,133 @@
+import { type RunStoreInspection } from "./tool-support.js";
+export type MartinPolicyPack = "solo-founder" | "startup-team" | "enterprise-strict" | "oss-maintainer" | "security-sensitive";
+export interface RepoGitState {
+    available: boolean;
+    isRepo: boolean;
+    clean: boolean;
+    branch?: string;
+    upstream?: string;
+    ahead?: number;
+    behind?: number;
+}
+export interface RepoSignals {
+    workingDirectory: string;
+    packageManager: "pnpm" | "npm" | "yarn" | "bun" | "unknown";
+    languages: string[];
+    frameworks: string[];
+    verifiers: {
+        test: string[];
+        lint: string[];
+        build: string[];
+        defaultPlan: string[];
+    };
+    packageScripts: Record<string, string>;
+    git: RepoGitState;
+    sensitivePaths: string[];
+    availableHosts: Record<"claude" | "codex" | "cursor" | "gemini", {
+        available: boolean;
+        detail: string;
+        resolvedPath?: string;
+    }>;
+}
+export interface MartinRiskAssessment {
+    score: number;
+    level: "low" | "medium" | "high";
+    reasons: string[];
+    recommendedAction: "proceed" | "review" | "require_human_approval";
+}
+export interface MartinPolicyPackDefinition {
+    name: MartinPolicyPack;
+    summary: string;
+    defaultVerifiers: string[];
+    defaultAllowedPaths: string[];
+    defaultBlockedPaths: string[];
+    dossierExpectations: string[];
+    requireApprovalAtOrAbove: MartinRiskAssessment["level"];
+}
+export interface MartinPlanBudget {
+    maxUsd: number;
+    softLimitUsd: number;
+    maxIterations: number;
+    maxTokens: number;
+    maxMinutes: number;
+    maxFilesChanged: number;
+    maxCommands: number;
+}
+export interface MartinRunContract {
+    objective: string;
+    context?: string;
+    allowedPaths: string[];
+    blockedPaths: string[];
+    budget: MartinPlanBudget;
+    verifiers: string[];
+    risk: MartinRiskAssessment;
+    policyPack: MartinPolicyPack;
+    requiresApproval: boolean;
+}
+export interface MartinPlanProposal {
+    objective: string;
+    implementationSummary: string;
+    proposedFileScope: {
+        allowedPaths: string[];
+        blockedPaths: string[];
+    };
+    proposedVerifiers: string[];
+    estimatedBudget: MartinPlanBudget;
+    risk: MartinRiskAssessment;
+    approvalRecommendation: "not_required" | "recommended" | "required";
+    policyPack: MartinPolicyPackDefinition;
+    nextSteps: string[];
+}
+export interface MartinReadinessReport {
+    score: number;
+    level: "low" | "medium" | "high";
+    missingSafeguards: string[];
+    repo: {
+        git: RepoGitState;
+        packageManager: RepoSignals["packageManager"];
+        languages: string[];
+        frameworks: string[];
+    };
+    safeguards: {
+        verifierDetected: boolean;
+        repoScoped: boolean;
+        branchSafe: boolean;
+        runStoreHealthy: boolean;
+    };
+    availableHosts: RepoSignals["availableHosts"];
+}
+interface ContractOverrides {
+    objective: string;
+    context?: string;
+    verificationPlan?: string[];
+    allowedPaths?: string[];
+    deniedPaths?: string[];
+    policyPack?: MartinPolicyPack;
+    maxUsd?: number;
+    maxIterations?: number;
+    maxTokens?: number;
+    maxMinutes?: number;
+    maxFilesChanged?: number;
+    maxCommands?: number;
+}
+export declare function inspectRepoSignals(workingDirectory: string): RepoSignals;
+export declare function buildReadinessReport(signals: RepoSignals, runStore: RunStoreInspection): MartinReadinessReport;
+export declare function buildPolicyPackDefinition(policyPack: MartinPolicyPack | undefined, signals: RepoSignals): MartinPolicyPackDefinition;
+export declare function buildPlanProposal(workingDirectory: string, overrides: ContractOverrides): MartinPlanProposal;
+export declare function buildRunContract(workingDirectory: string, overrides: ContractOverrides): MartinRunContract;
+export declare function assessRunRisk(input: {
+    objective: string;
+    context?: string;
+    allowedPaths: string[];
+    blockedPaths: string[];
+    verifiers: string[];
+    signals: RepoSignals;
+}): MartinRiskAssessment;
+export declare function buildRepoRiskMap(signals: RepoSignals): {
+    workingDirectory: string;
+    packageManager: RepoSignals["packageManager"];
+    frameworks: string[];
+    sensitivePaths: string[];
+    recommendedPolicyPack: MartinPolicyPack;
+};
+export {};