@martinloop/mcp 0.5.5 → 0.5.6

package/README.md

@@ -1,175 +1,175 @@
-# @martinloop/mcp
-
-You give an AI agent a coding task. It runs. You get a bill.
-
-But did it actually work? Did it pass your tests? How much did it spend? What files did it touch? Did it loop 47 times trying the same broken approach?
-
-You don't know. And that's the problem.
-
-## One system around the coding agent
-
-MartinLoop is the execution-control system around coding agents. The coding agent still performs the software work. MartinLoop connects the run from Definition of Done through preflight, control, verification, recovery evidence, receipts, and post-run analysis.
-
-```text
-DEFINE -> PREFLIGHT -> CONTROL -> VERIFY -> RECOVER -> PROVE -> ANALYZE
-```
-
-The product-level flow is **Definition of Done -> Controlled Run -> Verified Handoff**.
-
-Through MCP, compatible hosts can use the same MartinLoop lifecycle without giving up the host's own model selection. MartinLoop does not inject a hidden fallback model.
-
-For agent-readable product context see [`../../llms.txt`](../../llms.txt), [`../../llms-full.txt`](../../llms-full.txt), and [`../../docs/for-agents.md`](../../docs/for-agents.md).
-
-## What This Does
-
-MartinLoop governs AI coding-agent execution. You define what the run needs to accomplish, set execution boundaries such as budget and verifier checks, and let the configured coding agent do the work inside that contract.
-
-When it's done, you get a receipt — not a vague summary, but a structured record: dollars spent when available, attempts made, verification results, files changed, recovery state, and what the available evidence established.
-
-The final governed outcome is one of:
-
-- `VERIFIED` when the configured evidence supports the Definition of Done
-- `STOPPED` when a configured hard boundary ends the run
-- `NEEDS REVIEW` when completion cannot be established from the available evidence
-
-**One line to connect it:**
-
-```sh
-claude mcp add martin-loop -- npx -y @martinloop/mcp
-```
-
-That's it. Your host can now use MartinLoop's governed run and evidence surfaces.
-
-## Real Numbers From Real Runs
-
-We tested this against live repos with real API spend:
-
-| What happened | Without MartinLoop | With MartinLoop |
-|---|---|---|
-| Budget: $1.50 task | Agent spent **$28.42** | Agent stopped at **$1.20** |
-| Failing verifier | Retried indefinitely | Stopped after 3 attempts with diagnosis |
-| CLI not on PATH | "not available on PATH" (dead stop) | Auto-discovered in AppData, kept running |
-| `bun run lint && bun run test` | Passed `&&` as a literal arg (always fails) | Routed through shell, worked |
-
-These aren't hypotheticals. The $28 overshoot happened in production testing. We fixed the circuit breaker in `0.3.8`.
-
-## Install
-
-### Claude Code
-```sh
-claude mcp add martin-loop -- npx -y @martinloop/mcp@0.5.5
-```
-
-Windows:
-```sh
-claude mcp add --transport stdio --scope user martin-loop -- cmd /c npx -y @martinloop/mcp@0.5.5
-```
-
-### Codex
-```sh
-codex mcp add martin-loop -- npx -y @martinloop/mcp@0.5.5
-```
-
-### Gemini CLI
-```sh
-gemini mcp add martin-loop -- npx -y @martinloop/mcp@0.5.5
-```
-
-### Any MCP Host
-```sh
-npx -y @martinloop/mcp@0.5.5
-```
-
-## How a Governed Run Works
-
-```
-You: "Fix the auth bug. Budget $3. Verify: npm test"
-
-  martin_doctor     →  checks CLI, auth, environment
-  martin_plan       →  scopes the task, sets constraints
-  martin_preflight  →  validates before any spend
-  martin_run        →  agent works inside budget + verifier gates
-  martin_dossier    →  receipt: spend, attempts, verifier evidence, final outcome
-```
-
-Every attempt can be checked by your configured verifier. Budget and policy controls stay attached to the run. If the agent drifts off-task, the scope contract can block the change. If a hard spend boundary is reached, the run stops according to policy instead of silently retrying forever.
-
-## What Your Agent Gets
-
-### MCP Tools
-
-The exact tool set is discoverable from the running MCP server with `tools/list`; do not rely on a hard-coded count in documentation.
-
-**Run the loop:**
-`martin_doctor` `martin_plan` `martin_preflight` `martin_run` `martin_pause` `martin_continue` `martin_cancel`
-
-**Inspect results:**
-`martin_status` `martin_logs` `martin_dossier` `martin_eval` `martin_inspect` `martin_list_runs` `martin_get_run` `martin_get_attempt` `martin_get_verification_results` `martin_triage_runs`
-
-**Ship the work:**
-`martin_pr_summary` `martin_create_pr` `martin_review_pr`
-
-### Read-Only Resources
-
-The exact resource set is discoverable from the running MCP server; this documentation names the primary public resources without treating a count as a release invariant.
-
-Your agent can pull context without side effects:
-
-`martin://runs/latest` · `martin://runs/latest/proof-card` · `martin://runs/latest/budget-status` · `martin://runs/latest/verifier-evidence` · `martin://runs/recent` · `martin://server/health` · `martin://policies/current` · `martin://agent/next-step` · `martin://guides/mcp-usage` · `martin://guides/agent-start` · `martin://repo/risk-map`
-
-### Configuration Profiles
-
-Generate host config tuned to your workflow:
-
-```sh
-npx martin-loop mcp print-config --host claude --profile minimal        # run + inspect
-npx martin-loop mcp print-config --host claude --profile diagnostic     # + doctor + triage
-npx martin-loop mcp print-config --host claude --profile full-local     # all local tools
-npx martin-loop mcp print-config --host claude --profile github-review  # + PR workflow
-```
-
-## What Happens When Things Go Wrong
-
-MartinLoop does not round failure into success. It preserves the evidence and follows the configured recovery path while budget and policy still allow useful work.
-
-| Failure | Old behavior | Now |
-|---|---|---|
-| CLI not on PATH | Error message, dead stop | Searches npm global, homebrew, nvm, scoop — uses what it finds |
-| Verifier says "command not found" | Generic "verification failed" | Carries specific failure context into the next allowed attempt |
-| `git restore` fails mid-rollback | Throws, leaves dirty state | Retries once, falls back to `git checkout`, cleans up |
-| Invalid `--profile` flag | Crashes | Warns, falls back to `minimal`, keeps running |
-
-## Codex compatibility in 0.5.5
-
-MartinLoop no longer assumes one Codex host or one fixed Codex flag set. The CLI resolves the exact Codex executable, reads its advertised capabilities, negotiates a supported write strategy, proves that strategy before reporting launch readiness, and reuses the same contract for the governed run.
-
-That means MCP hosts can point MartinLoop at different Codex installations without requiring a documentation-specific approval or sandbox flag to exist everywhere.
-
-## Presentation and evidence
-
-MCP responses are Markdown-first for humans while retaining structured content for agents and automation. The presentation layer does not rewrite governed truth.
-
-MartinLoop Arcade is a terminal-only experience. It does not run inside MCP and cannot influence MCP evidence, budgets, verification, or final outcomes.
-
-## Who Uses This
-
-- **Engineers running overnight agent loops** — you need a kill switch that actually works, and a receipt in the morning
-- **Teams with shared API budgets** — you need per-task spend caps, not org-wide prayer
-- **Anyone reviewing agent-generated PRs** — the dossier shows what the agent tried, what passed, and what didn't
-- **Teams tired of stitching together point tools** — you want one execution-control lifecycle around coding-agent work from preflight through post-run analysis
-
-## Requirements
-
-- Node.js 20+
-- One AI coding CLI: [Claude Code](https://docs.anthropic.com/claude-code), [Codex](https://github.com/openai/codex), or [Gemini CLI](https://github.com/google/gemini-cli)
-
-## Links
-
-- [martin-loop](https://www.npmjs.com/package/martin-loop) — the standalone CLI
-- [MartinLoop for AI Agents](../../docs/for-agents.md)
-- [GitHub](https://github.com/Keesan12/martin-loop) — source and issues
-- [martinloop.com](https://martinloop.com)
-
-## License
-
-Apache-2.0
+# @martinloop/mcp
+
+You give an AI agent a coding task. It runs. You get a bill.
+
+But did it actually work? Did it pass your tests? How much did it spend? What files did it touch? Did it loop 47 times trying the same broken approach?
+
+You don't know. And that's the problem.
+
+## One system around the coding agent
+
+MartinLoop is the execution-control system around coding agents. The coding agent still performs the software work. MartinLoop connects the run from Definition of Done through preflight, control, verification, recovery evidence, receipts, and post-run analysis.
+
+```text
+DEFINE -> PREFLIGHT -> CONTROL -> VERIFY -> RECOVER -> PROVE -> ANALYZE
+```
+
+The product-level flow is **Definition of Done -> Controlled Run -> Verified Handoff**.
+
+Through MCP, compatible hosts can use the same MartinLoop lifecycle without giving up the host's own model selection. MartinLoop does not inject a hidden fallback model.
+
+For agent-readable product context see [`../../llms.txt`](../../llms.txt), [`../../llms-full.txt`](../../llms-full.txt), and [`../../docs/for-agents.md`](../../docs/for-agents.md).
+
+## What This Does
+
+MartinLoop governs AI coding-agent execution. You define what the run needs to accomplish, set execution boundaries such as budget and verifier checks, and let the configured coding agent do the work inside that contract.
+
+When it's done, you get a receipt — not a vague summary, but a structured record: dollars spent when available, attempts made, verification results, files changed, recovery state, and what the available evidence established.
+
+The final governed outcome is one of:
+
+- `VERIFIED` when the configured evidence supports the Definition of Done
+- `STOPPED` when a configured hard boundary ends the run
+- `NEEDS REVIEW` when completion cannot be established from the available evidence
+
+**One line to connect it:**
+
+```sh
+claude mcp add martin-loop -- npx -y @martinloop/mcp
+```
+
+That's it. Your host can now use MartinLoop's governed run and evidence surfaces.
+
+## Real Numbers From Real Runs
+
+We tested this against live repos with real API spend:
+
+| What happened | Without MartinLoop | With MartinLoop |
+|---|---|---|
+| Budget: $1.50 task | Agent spent **$28.42** | Agent stopped at **$1.20** |
+| Failing verifier | Retried indefinitely | Stopped after 3 attempts with diagnosis |
+| CLI not on PATH | "not available on PATH" (dead stop) | Auto-discovered in AppData, kept running |
+| `bun run lint && bun run test` | Passed `&&` as a literal arg (always fails) | Routed through shell, worked |
+
+These aren't hypotheticals. The $28 overshoot happened in production testing. We fixed the circuit breaker in `0.3.8`.
+
+## Install
+
+### Claude Code
+```sh
+claude mcp add martin-loop -- npx -y @martinloop/mcp@0.5.5
+```
+
+Windows:
+```sh
+claude mcp add --transport stdio --scope user martin-loop -- cmd /c npx -y @martinloop/mcp@0.5.5
+```
+
+### Codex
+```sh
+codex mcp add martin-loop -- npx -y @martinloop/mcp@0.5.5
+```
+
+### Gemini CLI
+```sh
+gemini mcp add martin-loop -- npx -y @martinloop/mcp@0.5.5
+```
+
+### Any MCP Host
+```sh
+npx -y @martinloop/mcp@0.5.5
+```
+
+## How a Governed Run Works
+
+```
+You: "Fix the auth bug. Budget $3. Verify: npm test"
+
+  martin_doctor     →  checks CLI, auth, environment
+  martin_plan       →  scopes the task, sets constraints
+  martin_preflight  →  validates before any spend
+  martin_run        →  agent works inside budget + verifier gates
+  martin_dossier    →  receipt: spend, attempts, verifier evidence, final outcome
+```
+
+Every attempt can be checked by your configured verifier. Budget and policy controls stay attached to the run. If the agent drifts off-task, the scope contract can block the change. If a hard spend boundary is reached, the run stops according to policy instead of silently retrying forever.
+
+## What Your Agent Gets
+
+### MCP Tools
+
+The exact tool set is discoverable from the running MCP server with `tools/list`; do not rely on a hard-coded count in documentation.
+
+**Run the loop:**
+`martin_doctor` `martin_plan` `martin_preflight` `martin_run` `martin_pause` `martin_continue` `martin_cancel`
+
+**Inspect results:**
+`martin_status` `martin_logs` `martin_dossier` `martin_eval` `martin_inspect` `martin_list_runs` `martin_get_run` `martin_get_attempt` `martin_get_verification_results` `martin_triage_runs`
+
+**Ship the work:**
+`martin_pr_summary` `martin_create_pr` `martin_review_pr`
+
+### Read-Only Resources
+
+The exact resource set is discoverable from the running MCP server; this documentation names the primary public resources without treating a count as a release invariant.
+
+Your agent can pull context without side effects:
+
+`martin://runs/latest` · `martin://runs/latest/proof-card` · `martin://runs/latest/budget-status` · `martin://runs/latest/verifier-evidence` · `martin://runs/recent` · `martin://server/health` · `martin://policies/current` · `martin://agent/next-step` · `martin://guides/mcp-usage` · `martin://guides/agent-start` · `martin://repo/risk-map`
+
+### Configuration Profiles
+
+Generate host config tuned to your workflow:
+
+```sh
+npx martin-loop mcp print-config --host claude --profile minimal        # run + inspect
+npx martin-loop mcp print-config --host claude --profile diagnostic     # + doctor + triage
+npx martin-loop mcp print-config --host claude --profile full-local     # all local tools
+npx martin-loop mcp print-config --host claude --profile github-review  # + PR workflow
+```
+
+## What Happens When Things Go Wrong
+
+MartinLoop does not round failure into success. It preserves the evidence and follows the configured recovery path while budget and policy still allow useful work.
+
+| Failure | Old behavior | Now |
+|---|---|---|
+| CLI not on PATH | Error message, dead stop | Searches npm global, homebrew, nvm, scoop — uses what it finds |
+| Verifier says "command not found" | Generic "verification failed" | Carries specific failure context into the next allowed attempt |
+| `git restore` fails mid-rollback | Throws, leaves dirty state | Retries once, falls back to `git checkout`, cleans up |
+| Invalid `--profile` flag | Crashes | Warns, falls back to `minimal`, keeps running |
+
+## Codex compatibility in 0.5.5
+
+MartinLoop no longer assumes one Codex host or one fixed Codex flag set. The CLI resolves the exact Codex executable, reads its advertised capabilities, negotiates a supported write strategy, proves that strategy before reporting launch readiness, and reuses the same contract for the governed run.
+
+That means MCP hosts can point MartinLoop at different Codex installations without requiring a documentation-specific approval or sandbox flag to exist everywhere.
+
+## Presentation and evidence
+
+MCP responses are Markdown-first for humans while retaining structured content for agents and automation. The presentation layer does not rewrite governed truth.
+
+MartinLoop Arcade is a terminal-only experience. It does not run inside MCP and cannot influence MCP evidence, budgets, verification, or final outcomes.
+
+## Who Uses This
+
+- **Engineers running overnight agent loops** — you need a kill switch that actually works, and a receipt in the morning
+- **Teams with shared API budgets** — you need per-task spend caps, not org-wide prayer
+- **Anyone reviewing agent-generated PRs** — the dossier shows what the agent tried, what passed, and what didn't
+- **Teams tired of stitching together point tools** — you want one execution-control lifecycle around coding-agent work from preflight through post-run analysis
+
+## Requirements
+
+- Node.js 20+
+- One AI coding CLI: [Claude Code](https://docs.anthropic.com/claude-code), [Codex](https://github.com/openai/codex), or [Gemini CLI](https://github.com/google/gemini-cli)
+
+## Links
+
+- [martin-loop](https://www.npmjs.com/package/martin-loop) — the standalone CLI
+- [MartinLoop for AI Agents](../../docs/for-agents.md)
+- [GitHub](https://github.com/Keesan12/martin-loop) — source and issues
+- [martinloop.com](https://martinloop.com)
+
+## License
+
+Apache-2.0

package/dist/arcade/capabilities.d.ts

@@ -0,0 +1,36 @@
+export declare const MARTIN_ARCADE_UI_EXTENSION_ID = "io.modelcontextprotocol/ui";
+export declare const MARTIN_ARCADE_MIME_TYPE = "text/html;profile=mcp-app";
+export declare const MARTIN_ARCADE_RESOURCE_URI = "ui://martinloop/arcade/index.html";
+export declare const MARTIN_ARCADE_FALLBACK_TEXT = "MartinLoop Arcade is available in an interactive terminal with --arcade.";
+export declare function supportsMartinArcadeApp(capabilities: unknown): boolean;
+export declare function buildArcadeToolDefinitions(capabilities: unknown): readonly [{
+    readonly _meta?: {
+        ui: {
+            resourceUri: string;
+        };
+    } | undefined;
+    readonly name: "martin_arcade";
+    readonly description: "Open the presentation-only MartinLoop Arcade when the host supports MCP Apps. The Arcade cannot change governed execution or evidence.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly additionalProperties: false;
+        readonly properties: {};
+    };
+}, {
+    readonly name: "martin_arcade_status";
+    readonly description: "Read authoritative MartinLoop evidence for the Arcade view without changing run state.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly additionalProperties: false;
+        readonly properties: {
+            readonly loopId: {
+                readonly type: "string";
+            };
+        };
+    };
+    readonly _meta: {
+        readonly ui: {
+            readonly visibility: readonly ["app"];
+        };
+    };
+}];

package/dist/arcade/capabilities.js

@@ -0,0 +1,37 @@
+export const MARTIN_ARCADE_UI_EXTENSION_ID = "io.modelcontextprotocol/ui";
+export const MARTIN_ARCADE_MIME_TYPE = "text/html;profile=mcp-app";
+export const MARTIN_ARCADE_RESOURCE_URI = "ui://martinloop/arcade/index.html";
+export const MARTIN_ARCADE_FALLBACK_TEXT = "MartinLoop Arcade is available in an interactive terminal with --arcade.";
+export function supportsMartinArcadeApp(capabilities) {
+    if (!capabilities || typeof capabilities !== "object")
+        return false;
+    const extension = capabilities.extensions?.[MARTIN_ARCADE_UI_EXTENSION_ID];
+    return Array.isArray(extension?.mimeTypes) && extension.mimeTypes.includes(MARTIN_ARCADE_MIME_TYPE);
+}
+export function buildArcadeToolDefinitions(capabilities) {
+    const arcadeMeta = supportsMartinArcadeApp(capabilities)
+        ? { ui: { resourceUri: MARTIN_ARCADE_RESOURCE_URI } }
+        : undefined;
+    return [
+        {
+            name: "martin_arcade",
+            description: "Open the presentation-only MartinLoop Arcade when the host supports MCP Apps. The Arcade cannot change governed execution or evidence.",
+            inputSchema: {
+                type: "object",
+                additionalProperties: false,
+                properties: {}
+            },
+            ...(arcadeMeta ? { _meta: arcadeMeta } : {})
+        },
+        {
+            name: "martin_arcade_status",
+            description: "Read authoritative MartinLoop evidence for the Arcade view without changing run state.",
+            inputSchema: {
+                type: "object",
+                additionalProperties: false,
+                properties: { loopId: { type: "string" } }
+            },
+            _meta: { ui: { visibility: ["app"] } }
+        }
+    ];
+}

package/dist/arcade/resource.d.ts

@@ -0,0 +1,31 @@
+export declare function listArcadeResources(capabilities: unknown): {
+    resources: {
+        uri: string;
+        name: string;
+        description: string;
+        mimeType: string;
+        _meta: {
+            ui: {
+                csp: {
+                    connectDomains: never[];
+                    resourceDomains: never[];
+                };
+            };
+        };
+    }[];
+};
+export declare function readArcadeResource(uri: string): Promise<{
+    contents: {
+        uri: string;
+        mimeType: string;
+        text: string;
+        _meta: {
+            ui: {
+                csp: {
+                    connectDomains: never[];
+                    resourceDomains: never[];
+                };
+            };
+        };
+    }[];
+}>;

package/dist/arcade/resource.js

@@ -0,0 +1,52 @@
+import { MARTIN_ARCADE_MIME_TYPE, MARTIN_ARCADE_RESOURCE_URI, supportsMartinArcadeApp } from "./capabilities.js";
+const ARCADE_APP_HTML = `<!doctype html>
+<html lang="en" data-martin-arcade-app>
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width,initial-scale=1">
+  <title>MartinLoop Arcade</title>
+  <style>
+    :root { color-scheme: light dark; font-family: ui-monospace, SFMono-Regular, Consolas, monospace; }
+    body { margin: 0; min-height: 100vh; display: grid; place-items: center; background: Canvas; color: CanvasText; }
+    main { width: min(42rem, calc(100% - 2rem)); border: 1px solid currentColor; padding: 1.25rem; }
+    p { line-height: 1.5; }
+  </style>
+</head>
+<body>
+  <main aria-labelledby="arcade-title">
+    <h1 id="arcade-title">MartinLoop Arcade</h1>
+    <p>Presentation only. Governed run status and outcomes remain authoritative in MartinLoop.</p>
+    <p aria-live="polite" data-run-status>Waiting for authoritative run evidence.</p>
+  </main>
+</body>
+</html>`;
+export function listArcadeResources(capabilities) {
+    return {
+        resources: supportsMartinArcadeApp(capabilities)
+            ? [
+                {
+                    uri: MARTIN_ARCADE_RESOURCE_URI,
+                    name: "MartinLoop Arcade",
+                    description: "Presentation-only Arcade view for a governed MartinLoop run.",
+                    mimeType: MARTIN_ARCADE_MIME_TYPE,
+                    _meta: { ui: { csp: { connectDomains: [], resourceDomains: [] } } }
+                }
+            ]
+            : []
+    };
+}
+export async function readArcadeResource(uri) {
+    if (uri !== MARTIN_ARCADE_RESOURCE_URI) {
+        throw new Error(`Unknown Arcade resource: ${uri}`);
+    }
+    return {
+        contents: [
+            {
+                uri: MARTIN_ARCADE_RESOURCE_URI,
+                mimeType: MARTIN_ARCADE_MIME_TYPE,
+                text: ARCADE_APP_HTML,
+                _meta: { ui: { csp: { connectDomains: [], resourceDomains: [] } } }
+            }
+        ]
+    };
+}

package/dist/arcade/status.d.ts

@@ -0,0 +1,23 @@
+import { type MartinRunDossierInput, type MartinRunDossierOutput } from "../tools/run-dossier.js";
+export interface ArcadeStatusInput {
+    loopId?: string;
+}
+export type ArcadeDossierReader = (input: MartinRunDossierInput) => Promise<MartinRunDossierOutput>;
+export declare function readArcadeStatus(input: ArcadeStatusInput, readDossier?: ArcadeDossierReader): Promise<{
+    loopId: string;
+    lifecycleState: string;
+    completed: boolean;
+    displayOutcome: "NEEDS_REVIEW" | "VERIFIED" | "STOPPED" | null;
+    verification: import("../tools/tool-support.js").VerificationSummary;
+    receiptIntegrity: import("../vendor/contracts/index.js").ReceiptIntegritySummary;
+    attempts: number;
+    cost: {
+        actualUsd: number;
+        provenance: import("../vendor/contracts/index.js").CostProvenance | undefined;
+    };
+    budget: {
+        maxUsd: number;
+        remainingUsd: number;
+    };
+    warnings: string[];
+}>;

package/dist/arcade/status.js

@@ -0,0 +1,25 @@
+import { martinRunDossierTool } from "../tools/run-dossier.js";
+const ACTIVE_LIFECYCLES = new Set(["created", "running", "verifying"]);
+export async function readArcadeStatus(input, readDossier = martinRunDossierTool) {
+    const dossier = await readDossier(input.loopId ? { loopId: input.loopId } : { latest: true });
+    const lifecycleState = dossier.loop.lifecycleState;
+    const completed = !ACTIVE_LIFECYCLES.has(lifecycleState);
+    return {
+        loopId: dossier.loop.loopId,
+        lifecycleState,
+        completed,
+        displayOutcome: completed ? dossier.verifiedHandoff.outcome : null,
+        verification: dossier.verification,
+        receiptIntegrity: dossier.receiptIntegrity,
+        attempts: dossier.attempts.length,
+        cost: {
+            actualUsd: dossier.cost.actualUsd,
+            provenance: dossier.cost.provenance
+        },
+        budget: {
+            maxUsd: dossier.budget.maxUsd,
+            remainingUsd: dossier.loop.remainingBudgetUsd
+        },
+        warnings: dossier.warnings
+    };
+}

package/dist/package-version.d.ts

@@ -1 +1 @@
-export declare const MARTIN_MCP_PACKAGE_VERSION = "0.3.2";
+export declare const MARTIN_MCP_PACKAGE_VERSION = "0.5.6";

package/dist/package-version.js

@@ -1,3 +1,3 @@
-// Keep this aligned with packages/mcp/package.json during version bumps so the
-// runtime does not depend on package.json being present in every hosted bundle.
-export const MARTIN_MCP_PACKAGE_VERSION = "0.3.2";
+// Auto-generated by build — do not edit by hand.
+// Source of truth: packages/mcp/package.json#version
+export const MARTIN_MCP_PACKAGE_VERSION = "0.5.6";