@martinloop/mcp 0.3.8 → 0.3.9

package/README.md

@@ -1,153 +1,196 @@
-# MCP Registry
+# MartinLoop MCP
 
-The MCP registry provides MCP clients with a list of MCP servers, like an app store for MCP servers.
+<div align="center">
+  <img src="https://raw.githubusercontent.com/Keesan12/martin-loop/main/docs/assets/martinloop-logo.png" alt="MartinLoop" width="240">
 
-[**📤 Publish my MCP server**](docs/modelcontextprotocol-io/quickstart.mdx) | [**⚡️ Live API docs**](https://registry.modelcontextprotocol.io/docs) | [**👀 Ecosystem vision**](docs/design/ecosystem-vision.md) | 📖 **[Full documentation](./docs)**
+  **Stop runaway loops, bad code, and token waste.**
 
-## Development Status
+  The governed MCP runtime for Claude Code, Codex, Gemini CLI, Cursor, and autonomous coding agents.
 
-**2025-10-24 update**: The Registry API has entered an **API freeze (v0.1)** 🎉. For the next month or more, the API will remain stable with no breaking changes, allowing integrators to confidently implement support. This freeze applies to v0.1 while development continues on v0. We'll use this period to validate the API in real-world integrations and gather feedback to shape v1 for general availability. Thank you to everyone for your contributions and patience—your involvement has been key to getting us here!
+  [![npm version](https://img.shields.io/npm/v/@martinloop/mcp?style=flat-square&logo=npm&logoColor=white)](https://www.npmjs.com/package/@martinloop/mcp)
+  [![npm downloads](https://img.shields.io/npm/dm/@martinloop/mcp?style=flat-square&label=downloads)](https://www.npmjs.com/package/@martinloop/mcp)
+  [![License: Apache-2.0](https://img.shields.io/badge/license-Apache--2.0-blue?style=flat-square&logo=apache)](https://github.com/Keesan12/martin-loop/blob/main/LICENSE)
+  [![Node](https://img.shields.io/badge/node-%3E%3D20-3c873a?style=flat-square&logo=nodedotjs&logoColor=white)](#requirements)
+  [![Glama score](https://glama.ai/mcp/servers/Keesan12/martin-loop/badges/score.svg)](https://glama.ai/mcp/servers/Keesan12/martin-loop)
+</div>
 
-**2025-09-08 update**: The registry has launched in preview 🎉 ([announcement blog post](https://blog.modelcontextprotocol.io/posts/2025-09-08-mcp-registry-preview/)). While the system is now more stable, this is still a preview release and breaking changes or data resets may occur. A general availability (GA) release will follow later. We'd love your feedback in [GitHub discussions](https://github.com/modelcontextprotocol/registry/discussions/new?category=ideas) or in the [#registry-dev Discord](https://discord.com/channels/1358869848138059966/1369487942862504016) ([joining details here](https://modelcontextprotocol.io/community/communication)).
+AI coding agents can write code. MartinLoop decides whether they are allowed to keep spending, whether the result is actually verified, and what evidence must remain for review.
 
-Registry Working Group:
-- **Tadas Antanavicius** (PulseMCP) [@tadasant](https://github.com/tadasant)
-- **Radoslav (Rado) Dimitrov** (Stacklok) [@rdimitrov](https://github.com/rdimitrov)
-- **Bob Dickinson** (TeamSpark) [@BobDickinson](https://github.com/BobDickinson)
-- **Preeti (Pree) Dewani** (Ravenmail) [@pree-dew](https://github.com/pree-dew)
+It wraps agent execution with:
 
-## Contributing
+- hard USD, token, iteration, time, command, and file-change limits
+- verifier gates that must pass before completion
+- allowed and denied path contracts
+- preflight checks before any execution or spend
+- durable pause, continue, and cancel receipts
+- failure triage, run dossiers, evaluations, and PR-review evidence
 
-We use multiple channels for collaboration - see [modelcontextprotocol.io/community/communication](https://modelcontextprotocol.io/community/communication).
+## Connect in one command
 
-Often (but not always) ideas flow through this pipeline:
+| Host | Command |
+| --- | --- |
+| Claude Code | `claude mcp add martin-loop -- npx -y @martinloop/mcp` |
+| Codex | `codex mcp add martin-loop -- npx -y @martinloop/mcp` |
+| Gemini CLI | `gemini mcp add martin-loop -- npx -y @martinloop/mcp` |
+| Any stdio MCP host | `npx -y @martinloop/mcp` |
 
-- **[Discord](https://modelcontextprotocol.io/community/communication)** - Real-time community discussions
-- **[Discussions](https://github.com/modelcontextprotocol/registry/discussions)** - Propose and discuss product/technical requirements
-- **[Issues](https://github.com/modelcontextprotocol/registry/issues)** - Track well-scoped technical work  
-- **[Pull Requests](https://github.com/modelcontextprotocol/registry/pulls)** - Contribute work towards issues
+Windows Claude Code:
 
-### Quick start:
-
-#### Pre-requisites
+```sh
+claude mcp add --transport stdio --scope user martin-loop -- cmd /c npx -y @martinloop/mcp
+```
 
-- **Docker**
-- **Go 1.24.x**
-- **ko** - Container image builder for Go ([installation instructions](https://ko.build/install/))
-- **golangci-lint v2.4.0**
+No API key is required to start and inspect the server. Live execution requires a supported coding-agent CLI and its normal authentication.
 
-#### Running the server
+## Why agents use MartinLoop
 
-```bash
-# Start full development environment
-make dev-compose
-```
+| Uncontrolled agent run | Governed MartinLoop run |
+| --- | --- |
+| The agent decides when it is done | Your verifier decides whether completion is valid |
+| Retries continue until the user notices | Hard budgets and stop conditions prevent open-ended spend |
+| Scope drifts across the repository | Allowed and denied paths constrain writes |
+| The final answer hides failed attempts | The dossier preserves attempts, costs, verification, and artifacts |
+| Process control is ephemeral | Pause, continue, and cancel actions leave durable receipts |
+| “Probably fixed” becomes accepted | Missing, failed, contradicted, or unknown verification stays incomplete |
 
-This starts the registry at [`localhost:8080`](http://localhost:8080) with PostgreSQL. The database uses ephemeral storage and is reset each time you restart the containers, ensuring a clean state for development and testing.
+MartinLoop is not another coding agent. It is the enforcement and evidence layer around the agents you already use.
 
-**Note:** The registry uses [ko](https://ko.build) to build container images. The `make dev-compose` command automatically builds the registry image with ko and loads it into your local Docker daemon before starting the services.
+## Agent operating contract
 
-By default, the registry seeds from the production API with a filtered subset of servers (to keep startup fast). This ensures your local environment mirrors production behavior and all seed data passes validation. For offline development you can seed from a file without validation with `MCP_REGISTRY_SEED_FROM=data/seed.json MCP_REGISTRY_ENABLE_REGISTRY_VALIDATION=false make dev-compose`.
+Use this sequence for governed coding work:
 
-The setup can be configured with environment variables in [docker-compose.yml](./docker-compose.yml) - see [.env.example](./.env.example) for a reference.
+```text
+martin_doctor
+  → martin_estimate
+  → martin_plan
+  → martin_preflight
+  → martin_run
+  → martin_dossier
+  → martin_eval
+```
 
-<details>
-<summary>Alternative: Running a pre-built Docker image</summary>
+### Rules for agents
 
-Pre-built Docker images are automatically published to GitHub Container Registry. Note that the image does not bundle PostgreSQL, so you need to run your own and point the registry at it via `MCP_REGISTRY_DATABASE_URL` (see [docker-compose.yml](./docker-compose.yml) for a working example):
+1. Start with `martin_doctor` to inspect the environment and run store.
+2. Call `martin_estimate` before spending.
+3. Keep the same objective and compatible scope through estimate, plan, preflight, and run.
+4. Prefer read-only tools until execution is explicitly authorized.
+5. Treat failed, contradicted, missing, or unknown verification as incomplete.
+6. Use `martin://agent/next-step` or `martin://guides/agent-start` when the next action is unclear.
+7. Do not use `martin_create_pr` with `execute: true` unless the user has explicitly authorized a GitHub write.
 
-```bash
-# Run latest stable release
-docker run -p 8080:8080 ghcr.io/modelcontextprotocol/registry:latest
+`martin_run` intentionally hard-blocks until the required doctor, estimate, plan, and preflight receipts exist for the same task.
 
-# Run latest from main branch (continuous deployment)
-docker run -p 8080:8080 ghcr.io/modelcontextprotocol/registry:main
+## What a governed run looks like
 
-# Run specific release version
-docker run -p 8080:8080 ghcr.io/modelcontextprotocol/registry:v1.0.0
+```text
+User objective:
+"Fix the auth regression. Budget: $3. Verify: npm test."
 
-# Run development build from main branch
-docker run -p 8080:8080 ghcr.io/modelcontextprotocol/registry:main-20250906-abc123d
+doctor       checks environment, CLI availability, and run storage
+estimate     predicts route, spend, and pre-work burn without spending
+plan         defines scope, verifier proposal, policy pack, and risk
+preflight    validates the contract before execution
+run          executes inside budget, scope, policy, and verifier gates
+dossier      returns attempts, cost, verification, artifacts, and evidence paths
+eval         grades completion, verifier health, risk, and reviewability
 ```
 
-**Available tags:** 
-- **Releases**: `latest`, `v1.0.0`, `v1.1.0`, etc.
-- **Continuous**: `main` (latest main branch build)
-- **Development**: `main-<date>-<sha>` (specific commit builds)
+Every attempt is bounded by the run contract. A confident model answer does not override a failed verifier.
 
-</details>
+## Proof, not promises
 
-#### Publishing a server
+This real governed run spent `$0.51` against a `$3.00` budget. The verifier passed and the receipt integrity was signed. MartinLoop still kept the result at `EVIDENCE_BOUNDARY` because rollback evidence had not been recorded.
 
-To publish a server, we've built a simple CLI. You can use it with:
+<div align="center">
+  <img src="https://raw.githubusercontent.com/Keesan12/martin-loop/main/docs/assets/proof-receipt-live-governed.png" alt="MartinLoop governed run receipt showing spend, budget, verifier result, integrity, and evidence boundary" width="720">
+</div>
 
-```bash
-# Build the latest CLI
-make publisher
+Inspect the example receipt:
 
-# Use it!
-./bin/mcp-publisher --help
-```
+- [Markdown receipt](https://github.com/Keesan12/martin-loop/blob/main/docs/examples/proof-receipts/live-governed-run-receipt.md)
+- [JSON receipt](https://github.com/Keesan12/martin-loop/blob/main/docs/examples/proof-receipts/live-governed-run-receipt.json)
 
-See [the publisher guide](./docs/modelcontextprotocol-io/quickstart.mdx) for more details.
+## Tool surface
 
-#### Other commands
+### Governed workflow
 
-```bash
-# Run lint, unit tests and integration tests
-make check
-```
+- `martin_doctor` — inspect environment readiness; expected first call
+- `martin_estimate` — estimate cost and route without spending
+- `martin_plan` — produce scoped plan, verifier proposal, policy pack, and risk
+- `martin_preflight` — validate readiness before execution
+- `martin_run` — execute a governed coding task
+- `martin_pause` — record a durable pause request
+- `martin_continue` — record a durable resume request
+- `martin_cancel` — record a durable cancellation request
 
-There are also a few more helpful commands for development. Run `make help` to learn more, or look in [Makefile](./Makefile).
+### Inspection and review
 
-<!--
-For Claude and other AI tools: Always prefer make targets over custom commands where possible.
--->
+- `martin_status`, `martin_logs`, `martin_inspect`
+- `martin_list_runs`, `martin_triage_runs`
+- `martin_get_run`, `martin_get_attempt`, `martin_get_verification_results`
+- `martin_run_dossier`, `martin_dossier`, `martin_eval`
+- `martin_pr_summary`, `martin_create_pr`, `martin_review_pr`
 
-## Architecture
+### Read-only resources
 
-### Project Structure
+The server exposes run summaries, receipts, budget status, verifier evidence, policies, health, agent guidance, and repository-risk context through `martin://` resources, including:
 
+```text
+martin://runs/latest
+martin://runs/latest/summary
+martin://runs/latest/receipt
+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/agent-start
+martin://repo/risk-map
 ```
-├── cmd/                     # Application entry points
-│   └── publisher/           # Server publishing tool
-├── data/                    # Seed data
-├── deploy/                  # Deployment configuration (Pulumi)
-├── docs/                    # Documentation
-├── internal/                # Private application code
-│   ├── api/                 # HTTP handlers and routing
-│   ├── auth/                # Authentication (GitHub OAuth, JWT, namespace blocking)
-│   ├── config/              # Configuration management
-│   ├── database/            # Data persistence (PostgreSQL)
-│   ├── service/             # Business logic
-│   ├── telemetry/           # Metrics and monitoring
-│   └── validators/          # Input validation
-├── pkg/                     # Public packages
-│   ├── api/                 # API types and structures
-│   │   └── v0/              # Version 0 API types
-│   └── model/               # Data models for server.json
-├── scripts/                 # Development and testing scripts
-├── tests/                   # Integration tests
-└── tools/                   # CLI tools and utilities
-    └── validate-*.sh        # Schema validation tools
+
+Use resources when the agent needs context without side effects.
+
+## Configuration profiles
+
+Generate host config tuned to the minimum surface needed:
+
+```sh
+npx martin-loop mcp print-config --host claude --profile minimal
+npx martin-loop mcp print-config --host claude --profile diagnostic
+npx martin-loop mcp print-config --host claude --profile full-local
+npx martin-loop mcp print-config --host claude --profile github-review
 ```
 
-### Authentication
+- `minimal` — core run and inspection path
+- `diagnostic` — adds doctor and triage surfaces
+- `full-local` — all local tools
+- `github-review` — adds PR evidence and review workflow
+
+## Trust boundaries
+
+- Cost and token values include provenance: actual, estimated, or unavailable.
+- A verifier proves only the commands you configured, not every product requirement.
+- Receipt integrity must be verified before evidence is trusted externally.
+- Unknown or missing evidence never passes silently.
+- MartinLoop does not guarantee that an agent will produce correct code; it makes execution bounded, verification explicit, and failure reviewable.
 
-Publishing supports multiple authentication methods:
-- **GitHub OAuth** - For publishing by logging into GitHub
-- **GitHub OIDC** - For publishing from GitHub Actions
-- **DNS verification** - For proving ownership of a domain and its subdomains
-- **HTTP verification** - For proving ownership of a domain
+## Requirements
 
-The registry validates namespace ownership when publishing. E.g. to publish...:
-- `io.github.domdomegg/my-cool-mcp` you must login to GitHub as `domdomegg`, or be in a GitHub Action on domdomegg's repos
-- `me.adamjones/my-cool-mcp` you must prove ownership of `adamjones.me` via DNS or HTTP challenge
+- Node.js 20+
+- One supported coding-agent CLI for live execution: Claude Code, Codex, Gemini CLI, or an OpenAI-compatible route
+- Git repository for rollback-aware and changed-file workflows
 
-## Community Projects
+## Links
 
-Check out [community projects](docs/community-projects.md) to explore notable registry-related work created by the community.
+- [Glama server page](https://glama.ai/mcp/servers/Keesan12/martin-loop)
+- [npm: @martinloop/mcp](https://www.npmjs.com/package/@martinloop/mcp)
+- [GitHub source and issues](https://github.com/Keesan12/martin-loop)
+- [MCP setup guide](https://github.com/Keesan12/martin-loop/blob/main/docs/getting-started/mcp.md)
+- [MCP tool reference](https://github.com/Keesan12/martin-loop/blob/main/docs/reference/mcp-tools.md)
+- [martinloop.com](https://martinloop.com)
 
-## More documentation
+## License
 
-See the [documentation](./docs) for more details if your question has not been answered here!
+Apache-2.0.

package/dist/resources.js

@@ -769,174 +769,174 @@ function inferAgentNextStep(loop, verification) {
 }
 function buildMcpUsageGuide(runsRoot) {
     const metadata = buildMartinDiscoveryMetadata(MARTIN_MCP_PACKAGE_VERSION);
-    return `# Martin Loop MCP Usage
-
-Discovery revision: \`${metadata.discoveryRevision}\`
-Server version: \`${metadata.serverVersion}\`
-Runs root: \`${runsRoot}\`
-
-Martin Loop exposes governed coding workflows over MCP. Use the server health and run-store views to decide when to preflight, execute, inspect, or escalate.
-
-## Recommended Flow
-
-1. Read \`${MARTIN_STATIC_RESOURCE_URIS.serverHealth}\` or call \`martin_doctor\` to confirm the environment and run-store visibility.
-2. Use the \`martin_governed_coding_kickoff\` prompt to frame a governed coding request.
-3. Call \`martin_preflight\` before \`martin_run\` when the task or safety envelope is non-trivial.
-4. After execution, inspect \`${MARTIN_STATIC_RESOURCE_URIS.recentRuns}\`, \`martin://runs/{loopId}\`, and \`martin://runs/{loopId}/verification\`.
-5. For low-context agents, read \`${MARTIN_STATIC_RESOURCE_URIS.agentNextStep}\`, \`${MARTIN_STATIC_RESOURCE_URIS.latestSummary}\`, or \`${MARTIN_STATIC_RESOURCE_URIS.latestReceipt}\` before asking for full JSON. Treat \`${MARTIN_STATIC_RESOURCE_URIS.latestProofCard}\` as an optional derived view.
-6. Read \`${MARTIN_STATIC_RESOURCE_URIS.triage}\` or call \`martin_triage_runs\` to prioritize which run needs attention first.
-7. Use \`martin_debug_failed_run\` when a loop exits failed, budget-bound, or escalated.
-
-## Current Martin MCP Surface
-
-- Tools: \`martin_run\`, \`martin_inspect\`, \`martin_status\`, \`martin_doctor\`, \`martin_preflight\`, \`martin_list_runs\`, \`martin_triage_runs\`, \`martin_get_run\`, \`martin_get_attempt\`, \`martin_get_verification_results\`, \`martin_run_dossier\`
-- Static resources: \`${MARTIN_STATIC_RESOURCE_URIS.serverHealth}\`, \`${MARTIN_STATIC_RESOURCE_URIS.recentRuns}\`, \`${MARTIN_STATIC_RESOURCE_URIS.triage}\`, \`${MARTIN_STATIC_RESOURCE_URIS.latestSummary}\`, \`${MARTIN_STATIC_RESOURCE_URIS.latestReceipt}\`, \`${MARTIN_STATIC_RESOURCE_URIS.latestProofCard}\`, \`${MARTIN_STATIC_RESOURCE_URIS.latestBudgetStatus}\`, \`${MARTIN_STATIC_RESOURCE_URIS.latestVerifierEvidence}\`, \`${MARTIN_STATIC_RESOURCE_URIS.latestRollbackEvidence}\`, \`${MARTIN_STATIC_RESOURCE_URIS.agentNextStep}\`, \`${MARTIN_STATIC_RESOURCE_URIS.mcpUsageGuide}\`, \`${MARTIN_STATIC_RESOURCE_URIS.agentStartGuide}\`, \`${MARTIN_STATIC_RESOURCE_URIS.publishReadinessGuide}\`
-- Resource templates: \`martin://runs/{loopId}\`, \`martin://runs/{loopId}/attempts/{attemptIndex}\`, \`martin://runs/{loopId}/verification\`
-- Prompts: \`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\`
-
-## Notes
-
-- Discovery helpers read the existing Martin run-store; they do not create new schema.
-- Verification history is derived from persisted \`verification.completed\` evidence in loop records and ledgers.
-- Attempt inspection stays aligned with the same loop selectors used by \`martin_status\` and \`martin_inspect\`.
+    return `# Martin Loop MCP Usage
+
+Discovery revision: \`${metadata.discoveryRevision}\`
+Server version: \`${metadata.serverVersion}\`
+Runs root: \`${runsRoot}\`
+
+Martin Loop exposes governed coding workflows over MCP. Use the server health and run-store views to decide when to preflight, execute, inspect, or escalate.
+
+## Recommended Flow
+
+1. Read \`${MARTIN_STATIC_RESOURCE_URIS.serverHealth}\` or call \`martin_doctor\` to confirm the environment and run-store visibility.
+2. Use the \`martin_governed_coding_kickoff\` prompt to frame a governed coding request.
+3. Call \`martin_preflight\` before \`martin_run\` when the task or safety envelope is non-trivial.
+4. After execution, inspect \`${MARTIN_STATIC_RESOURCE_URIS.recentRuns}\`, \`martin://runs/{loopId}\`, and \`martin://runs/{loopId}/verification\`.
+5. For low-context agents, read \`${MARTIN_STATIC_RESOURCE_URIS.agentNextStep}\`, \`${MARTIN_STATIC_RESOURCE_URIS.latestSummary}\`, or \`${MARTIN_STATIC_RESOURCE_URIS.latestReceipt}\` before asking for full JSON. Treat \`${MARTIN_STATIC_RESOURCE_URIS.latestProofCard}\` as an optional derived view.
+6. Read \`${MARTIN_STATIC_RESOURCE_URIS.triage}\` or call \`martin_triage_runs\` to prioritize which run needs attention first.
+7. Use \`martin_debug_failed_run\` when a loop exits failed, budget-bound, or escalated.
+
+## Current Martin MCP Surface
+
+- Tools: \`martin_run\`, \`martin_inspect\`, \`martin_status\`, \`martin_doctor\`, \`martin_preflight\`, \`martin_list_runs\`, \`martin_triage_runs\`, \`martin_get_run\`, \`martin_get_attempt\`, \`martin_get_verification_results\`, \`martin_run_dossier\`
+- Static resources: \`${MARTIN_STATIC_RESOURCE_URIS.serverHealth}\`, \`${MARTIN_STATIC_RESOURCE_URIS.recentRuns}\`, \`${MARTIN_STATIC_RESOURCE_URIS.triage}\`, \`${MARTIN_STATIC_RESOURCE_URIS.latestSummary}\`, \`${MARTIN_STATIC_RESOURCE_URIS.latestReceipt}\`, \`${MARTIN_STATIC_RESOURCE_URIS.latestProofCard}\`, \`${MARTIN_STATIC_RESOURCE_URIS.latestBudgetStatus}\`, \`${MARTIN_STATIC_RESOURCE_URIS.latestVerifierEvidence}\`, \`${MARTIN_STATIC_RESOURCE_URIS.latestRollbackEvidence}\`, \`${MARTIN_STATIC_RESOURCE_URIS.agentNextStep}\`, \`${MARTIN_STATIC_RESOURCE_URIS.mcpUsageGuide}\`, \`${MARTIN_STATIC_RESOURCE_URIS.agentStartGuide}\`, \`${MARTIN_STATIC_RESOURCE_URIS.publishReadinessGuide}\`
+- Resource templates: \`martin://runs/{loopId}\`, \`martin://runs/{loopId}/attempts/{attemptIndex}\`, \`martin://runs/{loopId}/verification\`
+- Prompts: \`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\`
+
+## Notes
+
+- Discovery helpers read the existing Martin run-store; they do not create new schema.
+- Verification history is derived from persisted \`verification.completed\` evidence in loop records and ledgers.
+- Attempt inspection stays aligned with the same loop selectors used by \`martin_status\` and \`martin_inspect\`.
 `;
 }
 function buildAgentStartGuide(runsRoot) {
     const metadata = buildMartinDiscoveryMetadata(MARTIN_MCP_PACKAGE_VERSION);
-    return `# Agent Start Here
-
-Discovery revision: \`${metadata.discoveryRevision}\`
-Server version: \`${metadata.serverVersion}\`
-Runs root: \`${runsRoot}\`
-
-Use Martin Loop as the local governor before you spend agent tokens or retry a failed coding loop.
-
-## Cheap Default Flow
-
-1. Read \`${MARTIN_STATIC_RESOURCE_URIS.agentNextStep}\` first. It is the smallest "what should I do now?" payload.
-2. If no runs exist, call \`martin_doctor\`, then \`martin_preflight\`.
-3. If a run exists, read \`${MARTIN_STATIC_RESOURCE_URIS.latestSummary}\` before reading full run JSON.
-4. If the verifier failed, use prompt \`martin_debug_failed_run\` or \`martin_triage\`.
-5. If you need a shareable receipt, read \`${MARTIN_STATIC_RESOURCE_URIS.latestReceipt}\` first. Generate or inspect \`${MARTIN_STATIC_RESOURCE_URIS.latestProofCard}\` only when a visual artifact is explicitly required.
-
-## Install Profiles
-
-- \`minimal\` (default): doctor, preflight, list, triage, dossier. Good for low tool bloat.
-- \`diagnostic\`: read-only inspection tools for debugging without execution.
-- \`full-local\`: all local tools, including \`martin_run\`.
-- \`github-review\`: review-oriented local profile for PR drafting and reviewer evidence.
-- \`starter\` and \`full\`: compatibility aliases.
-
-## Copy-Paste Agent Rule
-
-Before running or retrying an autonomous coding task, call Martin. Prefer compact resources first, then full dossiers only when the compact receipt says more evidence is needed. Never claim success unless Martin shows verifier-backed completion or a clear blocked reason.
+    return `# Agent Start Here
+
+Discovery revision: \`${metadata.discoveryRevision}\`
+Server version: \`${metadata.serverVersion}\`
+Runs root: \`${runsRoot}\`
+
+Use Martin Loop as the local governor before you spend agent tokens or retry a failed coding loop.
+
+## Cheap Default Flow
+
+1. Read \`${MARTIN_STATIC_RESOURCE_URIS.agentNextStep}\` first. It is the smallest "what should I do now?" payload.
+2. If no runs exist, call \`martin_doctor\`, then \`martin_preflight\`.
+3. If a run exists, read \`${MARTIN_STATIC_RESOURCE_URIS.latestSummary}\` before reading full run JSON.
+4. If the verifier failed, use prompt \`martin_debug_failed_run\` or \`martin_triage\`.
+5. If you need a shareable receipt, read \`${MARTIN_STATIC_RESOURCE_URIS.latestReceipt}\` first. Generate or inspect \`${MARTIN_STATIC_RESOURCE_URIS.latestProofCard}\` only when a visual artifact is explicitly required.
+
+## Install Profiles
+
+- \`minimal\` (default): doctor, preflight, list, triage, dossier. Good for low tool bloat.
+- \`diagnostic\`: read-only inspection tools for debugging without execution.
+- \`full-local\`: all local tools, including \`martin_run\`.
+- \`github-review\`: review-oriented local profile for PR drafting and reviewer evidence.
+- \`starter\` and \`full\`: compatibility aliases.
+
+## Copy-Paste Agent Rule
+
+Before running or retrying an autonomous coding task, call Martin. Prefer compact resources first, then full dossiers only when the compact receipt says more evidence is needed. Never claim success unless Martin shows verifier-backed completion or a clear blocked reason.
 `;
 }
 function buildCommandMapGuide(runsRoot) {
     const metadata = buildMartinDiscoveryMetadata(MARTIN_MCP_PACKAGE_VERSION);
-    return `# Martin Command Map
-
-Discovery revision: \`${metadata.discoveryRevision}\`
-Server version: \`${metadata.serverVersion}\`
-Runs root: \`${runsRoot}\`
-
-Use this guide when an IDE or agent needs to know which Martin surface to call next.
-
-## Default Governed Sequence
-
-1. \`martin_doctor\` — confirm environment and visibility.
-2. \`martin_plan\` — propose the bounded approach without spending a run.
-3. \`martin_preflight\` — turn the plan into an explicit contract.
-4. \`martin_run\` — execute only after the contract is safe.
-5. \`martin_dossier\` — inspect what happened and what Martin prevented.
-6. \`martin_eval\` — convert the result into review posture when needed.
-
-## When To Use Which Surface
-
-- Need the smallest next action: \`${MARTIN_STATIC_RESOURCE_URIS.agentNextStep}\`
-- Need a quick receipt: \`${MARTIN_STATIC_RESOURCE_URIS.latestSummary}\`
-- Need the structured receipt source of truth: \`${MARTIN_STATIC_RESOURCE_URIS.latestReceipt}\`
-- Need an optional visual proof object: \`${MARTIN_STATIC_RESOURCE_URIS.latestProofCard}\`
-- Need a full run review: \`martin_dossier\`
-- Need to decide whether to retry: \`martin_triage_runs\`
-- Need IDE setup guidance: \`${MARTIN_STATIC_RESOURCE_URIS.ideOnboardingGuide}\`
+    return `# Martin Command Map
+
+Discovery revision: \`${metadata.discoveryRevision}\`
+Server version: \`${metadata.serverVersion}\`
+Runs root: \`${runsRoot}\`
+
+Use this guide when an IDE or agent needs to know which Martin surface to call next.
+
+## Default Governed Sequence
+
+1. \`martin_doctor\` — confirm environment and visibility.
+2. \`martin_plan\` — propose the bounded approach without spending a run.
+3. \`martin_preflight\` — turn the plan into an explicit contract.
+4. \`martin_run\` — execute only after the contract is safe.
+5. \`martin_dossier\` — inspect what happened and what Martin prevented.
+6. \`martin_eval\` — convert the result into review posture when needed.
+
+## When To Use Which Surface
+
+- Need the smallest next action: \`${MARTIN_STATIC_RESOURCE_URIS.agentNextStep}\`
+- Need a quick receipt: \`${MARTIN_STATIC_RESOURCE_URIS.latestSummary}\`
+- Need the structured receipt source of truth: \`${MARTIN_STATIC_RESOURCE_URIS.latestReceipt}\`
+- Need an optional visual proof object: \`${MARTIN_STATIC_RESOURCE_URIS.latestProofCard}\`
+- Need a full run review: \`martin_dossier\`
+- Need to decide whether to retry: \`martin_triage_runs\`
+- Need IDE setup guidance: \`${MARTIN_STATIC_RESOURCE_URIS.ideOnboardingGuide}\`
 `;
 }
 function buildIdeOnboardingGuide(runsRoot) {
     const metadata = buildMartinDiscoveryMetadata(MARTIN_MCP_PACKAGE_VERSION);
-    return `# Martin IDE Onboarding
-
-Discovery revision: \`${metadata.discoveryRevision}\`
-Server version: \`${metadata.serverVersion}\`
-Runs root: \`${runsRoot}\`
-
-Use this guide after the MCP server is installed so the host naturally uses MartinLoop during real work.
-
-## IDE Default Flow
-
-1. Read \`${MARTIN_STATIC_RESOURCE_URIS.agentStartGuide}\`
-2. Read \`${MARTIN_STATIC_RESOURCE_URIS.operatingRulesGuide}\`
-3. Use prompt \`martin_start\` or \`martin_governed_coding_kickoff\`
-4. Call \`martin_doctor\`
-5. Call \`martin_plan\`
-6. Call \`martin_preflight\`
-7. Only then call \`martin_run\`
-
-## Goal
-
-MartinLoop should become the normal path for coding work in the host, not a manual extra step the human has to remember.
+    return `# Martin IDE Onboarding
+
+Discovery revision: \`${metadata.discoveryRevision}\`
+Server version: \`${metadata.serverVersion}\`
+Runs root: \`${runsRoot}\`
+
+Use this guide after the MCP server is installed so the host naturally uses MartinLoop during real work.
+
+## IDE Default Flow
+
+1. Read \`${MARTIN_STATIC_RESOURCE_URIS.agentStartGuide}\`
+2. Read \`${MARTIN_STATIC_RESOURCE_URIS.operatingRulesGuide}\`
+3. Use prompt \`martin_start\` or \`martin_governed_coding_kickoff\`
+4. Call \`martin_doctor\`
+5. Call \`martin_plan\`
+6. Call \`martin_preflight\`
+7. Only then call \`martin_run\`
+
+## Goal
+
+MartinLoop should become the normal path for coding work in the host, not a manual extra step the human has to remember.
 `;
 }
 function buildOperatingRulesGuide(runsRoot) {
     const metadata = buildMartinDiscoveryMetadata(MARTIN_MCP_PACKAGE_VERSION);
-    return `# Martin Operating Rules
-
-Discovery revision: \`${metadata.discoveryRevision}\`
-Server version: \`${metadata.serverVersion}\`
-Runs root: \`${runsRoot}\`
-
-Use these rules inside the IDE or MCP host as the default MartinLoop operating posture.
-
-## Required Sequence Before Real Work
-
-1. \`martin_doctor\`
-2. \`martin_plan\`
-3. \`martin_preflight\`
-4. \`martin_run\`
-5. \`martin_dossier\`
-
-## Enforcement Rule
-
-Do not execute real coding work through MartinLoop until doctor and preflight have both been used for the current task.
-
-## Completion Rule
-
-Do not claim success until MartinLoop shows verifier-backed completion or an explicit blocked reason backed by evidence.
+    return `# Martin Operating Rules
+
+Discovery revision: \`${metadata.discoveryRevision}\`
+Server version: \`${metadata.serverVersion}\`
+Runs root: \`${runsRoot}\`
+
+Use these rules inside the IDE or MCP host as the default MartinLoop operating posture.
+
+## Required Sequence Before Real Work
+
+1. \`martin_doctor\`
+2. \`martin_plan\`
+3. \`martin_preflight\`
+4. \`martin_run\`
+5. \`martin_dossier\`
+
+## Enforcement Rule
+
+Do not execute real coding work through MartinLoop until doctor and preflight have both been used for the current task.
+
+## Completion Rule
+
+Do not claim success until MartinLoop shows verifier-backed completion or an explicit blocked reason backed by evidence.
 `;
 }
 function buildPublishReadinessGuide(runsRoot) {
     const metadata = buildMartinDiscoveryMetadata(MARTIN_MCP_PACKAGE_VERSION);
-    return `# Martin MCP Publish Readiness
-
-Discovery revision: \`${metadata.discoveryRevision}\`
-Server version: \`${metadata.serverVersion}\`
-Runs root: \`${runsRoot}\`
-
-Use this guide when reviewing whether the public MCP package is ready to publish, promote, or hand off for registry submission.
-
-## Review Areas
-
-1. Environment health: confirm \`${MARTIN_STATIC_RESOURCE_URIS.serverHealth}\` shows a sane working directory, runs root, and engine availability for the target mode.
-2. Discovery surface: verify tools, prompts, static resources, and resource templates are all discoverable and named consistently.
-3. Run evidence: inspect \`${MARTIN_STATIC_RESOURCE_URIS.recentRuns}\` and, when relevant, \`martin://runs/{loopId}/verification\` to confirm verification outcomes are explainable from persisted data.
-4. Packaging lane: run the MCP package test, build, and smoke-pack commands before calling the package publish-ready.
-5. Findings-first reporting: call out missing schema, integration gaps, triage-critical runs, and verification blockers before summarizing strengths.
-
-## Evidence Expectations
-
-- Prefer concrete run IDs, attempt indices, and verification summaries over vague statements.
-- Distinguish local package validation from live registry readiness.
-- If a discovery helper exists but is not yet wired into the server, report that as an integration gap instead of treating the capability as fully shipped.
+    return `# Martin MCP Publish Readiness
+
+Discovery revision: \`${metadata.discoveryRevision}\`
+Server version: \`${metadata.serverVersion}\`
+Runs root: \`${runsRoot}\`
+
+Use this guide when reviewing whether the public MCP package is ready to publish, promote, or hand off for registry submission.
+
+## Review Areas
+
+1. Environment health: confirm \`${MARTIN_STATIC_RESOURCE_URIS.serverHealth}\` shows a sane working directory, runs root, and engine availability for the target mode.
+2. Discovery surface: verify tools, prompts, static resources, and resource templates are all discoverable and named consistently.
+3. Run evidence: inspect \`${MARTIN_STATIC_RESOURCE_URIS.recentRuns}\` and, when relevant, \`martin://runs/{loopId}/verification\` to confirm verification outcomes are explainable from persisted data.
+4. Packaging lane: run the MCP package test, build, and smoke-pack commands before calling the package publish-ready.
+5. Findings-first reporting: call out missing schema, integration gaps, triage-critical runs, and verification blockers before summarizing strengths.
+
+## Evidence Expectations
+
+- Prefer concrete run IDs, attempt indices, and verification summaries over vague statements.
+- Distinguish local package validation from live registry readiness.
+- If a discovery helper exists but is not yet wired into the server, report that as an integration gap instead of treating the capability as fully shipped.
 `;
 }
 async function buildModeStatusResource() {