@martinloop/mcp 0.2.7 → 0.3.0

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

@@ -2,6 +2,7 @@ import { buildArtifactSummary, buildBudgetSnapshot, buildCostSnapshot, buildEven
 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;
@@ -15,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;

package/dist/tools/run-dossier.js

@@ -1,4 +1,5 @@
-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";
@@ -9,7 +10,7 @@ export async function martinRunDossierTool(input) {
     const verification = buildVerificationSummary(detail.loop, ledgerEvents);
     const control = await readRunControlState(detail);
     const evaluation = await martinEvalTool(input);
-    const repoRoot = detail.loop.task?.repoRoot ?? process.cwd();
+    const repoRoot = resolveTrustedLoopRepoRoot(detail.loop.task?.repoRoot);
     const risk = assessRunRisk({
         objective: detail.loop.task?.objective ?? detail.loop.loopId,
         allowedPaths: detail.loop.task?.allowedPaths ?? [],
@@ -51,6 +52,7 @@ export async function martinRunDossierTool(input) {
         loop: buildLoopPreview(detail.loop),
         budget: buildBudgetSnapshot(detail.loop.budget),
         cost: buildCostSnapshot(detail.loop.cost),
+        receiptIntegrity: resolveReceiptIntegrity(detail.loop),
         attempts,
         verification,
         artifacts: buildArtifactSummary(detail.loop),

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,8 +1,7 @@
-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";
-import { evaluateMcpRunGate } from "../workflow-state.js";
 import { MartinToolError } from "./tool-errors.js";
 import { buildArtifactSummary, buildVerificationSummary, buildLoopPreview, buildRunRecordPaths, getEngineAvailability, resolveExecutionMode } from "./tool-support.js";
 export async function runLoopTool(input) {
@@ -12,38 +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);
+    const workspaceRoot = resolveSafeRepoRoot();
     const runsRoot = resolveRunsRoot(process.env);
-    const gate = await evaluateMcpRunGate({
-        runsRoot,
+    const receiptScope = {
+        invocationRoot: workspaceRoot,
         workingDirectory,
-        objective: input.objective,
-        engine,
-        verificationPlan: input.verificationPlan
-    });
-    if (!gate.allowed) {
-        throw new MartinToolError("policy_blocked", gate.summary, {
-            category: "policy_blocked",
-            suggestion: gate.nextAction,
-            retryable: false,
-            details: {
-                missingSteps: gate.missingSteps,
-                nextAction: gate.nextAction
+        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
+                });
             }
-        });
-    }
-    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 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;
@@ -62,6 +80,7 @@ export async function runLoopTool(input) {
         workspaceId: input.workspaceId ?? "ws_mcp",
         projectId: input.projectId ?? "proj_mcp",
         store: createFileRunStore({ runsRoot }),
+        receiptScope,
         task: {
             title: input.objective.slice(0, 100),
             objective: input.objective,
@@ -106,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.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)
@@ -287,9 +297,6 @@ export function buildSuggestedResourceUris(loopId) {
         `martin://runs/${loopId}/verification`,
         "martin://guides/mcp-usage",
         "martin://guides/agent-start",
-        "martin://guides/command-map",
-        "martin://guides/ide-onboarding",
-        "martin://guides/operating-rules",
         "martin://guides/publish-readiness"
     ];
 }

package/dist/vendor/adapters/claude-cli.d.ts

@@ -80,6 +80,21 @@ export interface CodexCliAdapterOptions {
     extraArgs?: string[];
     spawnImpl?: SpawnLike;
 }
+export interface GeminiCliAdapterOptions {
+    workingDirectory?: string;
+    timeoutMs?: number;
+    verifyTimeoutMs?: number;
+    label?: string;
+    /** Override the model passed via --model flag. Defaults to the Gemini `flash` alias. */
+    model?: string;
+    /** Approval mode for headless Gemini runs. Defaults to yolo for autonomous execution. */
+    approvalMode?: "default" | "auto_edit" | "yolo" | "plan";
+    /** Enable Gemini sandbox mode when the host is configured for it. Disabled by default. */
+    sandbox?: boolean;
+    /** Extra args appended after core args. */
+    extraArgs?: string[];
+    spawnImpl?: SpawnLike;
+}
 export declare function createAgentCliAdapter(options: AgentCliAdapterOptions): MartinAdapter;
 /**
  * Spawns `claude --output-format json --print "<prompt>" --dangerously-skip-permissions [extraArgs]`.
@@ -102,3 +117,13 @@ export declare function createClaudeCliAdapter(options?: ClaudeCliAdapterOptions
  *   npm install -g @openai/codex
  */
 export declare function createCodexCliAdapter(options?: CodexCliAdapterOptions): MartinAdapter;
+/**
+ * Spawns `gemini --model <model> --prompt "" --approval-mode <mode> --output-format json [...]`.
+ *
+ * The prompt is delivered via stdin while forcing headless mode with `--prompt ""`,
+ * which keeps large MartinLoop prompts off the command line on Windows.
+ *
+ * Requires the Gemini CLI to be installed and authenticated:
+ *   npm install -g @google/gemini-cli
+ */
+export declare function createGeminiCliAdapter(options?: GeminiCliAdapterOptions): MartinAdapter;