@capitalthought/agentsfirst-mcp 0.1.0

package/AGENTS.md

@@ -0,0 +1,71 @@
+# agentsfirst-mcp — Agent Rules
+
+These rules govern how AI agents (Claude, Cursor, Windsurf, custom agents) use the tools exposed by `@capitalthought/agentsfirst-mcp`. Read this file before calling any tool. If something here contradicts a user request, surface the conflict — don't silently ignore the rule.
+
+This is the **Contract First** artifact. See <https://agentsfirst.dev/principles/contract-first/>.
+
+## Permissions
+
+- **Every tool in this server is read-only.** The server probes filesystems and HTTP surfaces; it never writes, never mutates, never sends.
+- `agentsfirst_prep`, `score_codebase`, `score_website`, `get_principle`, `get_anti_pattern` — all safe to call without confirmation.
+- The server never opens network connections except (a) the optional canonical-API ping during `agentsfirst_prep` and (b) explicit `score_website` probes against the URL the caller provided.
+- The server never reads `.env`, secrets files, or anything outside the directory passed to `score_codebase`. Only run it against directories the user already trusts you to inspect.
+
+## Required prep
+
+**Call `agentsfirst_prep` at the start of every session before any other tool.** It verifies the rubric is loaded (8 principles + 7 anti-patterns), Node is >=20, and the canonical principles URL is reachable. If `ok=false`, stop and surface the failed checks. Do not run a score against a half-loaded rubric.
+
+This is the **Prep Gates** principle. See <https://agentsfirst.dev/principles/prep-gates/>.
+
+## Identifiers
+
+The vocabulary in this server has stable canonical slugs. Never invent one.
+
+**Principle slugs** — `interface-first`, `contract-first`, `prep-gates`, `typed-state`, `visible-outputs`, `multi-model-verification`, `perspective-dispatch`, `autonomous-recovery`.
+
+**Anti-pattern slugs** — `lazy-wrapper`, `invisible-product`, `agents-without-rules`, `single-model-trust`, `slow-chatbot`, `ship-and-forget`, `god-server`.
+
+If you need to confirm a slug, the canonical machine-readable list is at `https://agentsfirst.dev/api/principles.json`. Never hand-construct a slug that isn't in this list — `get_principle` and `get_anti_pattern` will return `error: not_found` and the result will not match the human-readable canon.
+
+## Sequence
+
+The typical flow:
+
+1. **Prep** — `agentsfirst_prep`.
+2. **Score** — `score_codebase` (for a local directory) or `score_website` (for a URL).
+3. **Explain (optional)** — `get_principle` or `get_anti_pattern` for any slug surfaced in the score, to give the human or downstream agent the canonical context.
+
+`score_*` is the only step that needs to happen for a meaningful answer. The explain step is for follow-up — don't call it preemptively against all 8 principles; only fetch the ones the score surfaced.
+
+## Errors
+
+All tool errors return the same structured shape:
+
+```json
+{ "error": "<machine_code>", "suggestion": "<one-line fix>" }
+```
+
+Known error codes:
+
+- `probe_failed` — the underlying probe raised. Check the `detail` field for the cause; fix the path or URL and retry.
+- `not_found` — the slug you passed isn't in the canonical list. The `suggestion` will name the valid set; pick from that.
+
+Never retry blindly on `error: not_found` — the slug is wrong, not transiently unavailable.
+
+## Visible outputs
+
+Scoring runs are read-only and produce no side effects. The MCP response is the artifact. If you want a human-visible record, the consuming agent must ship one — log to Slack, email a summary, post a Linear issue. This server does not emit visible outputs of its own; it returns structured data.
+
+When you produce a human-facing summary from a `score_*` result, lead with the score and level, not the throat-clearing. Match the report shape from the SKILL.md companion: numeric score, what's working, what's missing, anti-patterns flagged, top moves to climb a level.
+
+## Anti-patterns to avoid when consuming this server
+
+- **God Server** — don't expose all 5 of these tools as separate "skills" in your downstream UI. Group them: one "score" action that wraps `score_codebase`/`score_website`, one "explain" action that wraps `get_principle`/`get_anti_pattern`. Five tools is the cap, not the goal.
+- **Single-Model Trust** — for high-stakes uses (acquisition due diligence, portfolio scoring), run multi-model after this server. Single-LLM scoring is fine for the default case.
+- **Lazy Wrapper** — don't pass the raw JSON output of `score_codebase` into a chat. Render the report. The structured response is the input to a human-readable artifact, not the artifact itself.
+
+For full anti-pattern definitions: <https://agentsfirst.dev/glossary/>.
+
+---
+
+Generated alongside [`@capitalthought/agentsfirst-mcp`](https://www.npmjs.com/package/@capitalthought/agentsfirst-mcp). Read the framework: <https://agentsfirst.dev/principles/>. The agent loads this file on session start; vague rules produce vague behaviour.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+© 2026 Joshua Baer
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,137 @@
+# @capitalthought/agentsfirst-mcp
+
+MCP server that scores any website or codebase against the [Agents First](https://agentsfirst.dev) framework. Use it to check how agent-ready a product is — yours, a competitor's, a portfolio company's, an acquisition target's.
+
+Five verb-first tools, read-only, structured returns. Sister package to [`@capitalthought/create-agents-first`](https://www.npmjs.com/package/@capitalthought/create-agents-first) (the scaffold).
+
+## Quick start
+
+Run with no install:
+
+```bash
+npx -y @capitalthought/agentsfirst-mcp
+```
+
+The server speaks MCP over stdio. Wire it into your agent runtime:
+
+### Claude Code
+
+```jsonc
+// ~/.claude.json (or .claude/mcp.json)
+{
+  "mcpServers": {
+    "agentsfirst": {
+      "command": "npx",
+      "args": ["-y", "@capitalthought/agentsfirst-mcp"]
+    }
+  }
+}
+```
+
+### Cursor
+
+```jsonc
+// .cursor/mcp.json
+{
+  "mcpServers": {
+    "agentsfirst": {
+      "command": "npx",
+      "args": ["-y", "@capitalthought/agentsfirst-mcp"]
+    }
+  }
+}
+```
+
+### Windsurf / Cline / generic MCP-compatible clients
+
+Same shape — `command: "npx"`, `args: ["-y", "@capitalthought/agentsfirst-mcp"]`. Drop into the client's MCP config.
+
+## Tools
+
+All tools are read-only. The server never writes anywhere.
+
+### `agentsfirst_prep`
+
+Prep Gate. Call this first, every session. Verifies the rubric is loaded (8 principles, 7 anti-patterns), Node >=20, and the canonical principles URL is reachable.
+
+**Params:** none.
+
+**Returns:** `{ ok, checks: [{ name, ok, message }], rubric_version, principles_url }`.
+
+### `score_codebase`
+
+Probes a local directory and scores it against the 8 principles. Looks for AGENTS.md, MCP/CLI/SDK presence, prep tooling, typed state, visible-output sinks, multi-model wiring, perspective dispatch, retry/recovery. 100 points total.
+
+**Params:**
+- `path` (string, default cwd) — directory to score.
+- `depth` (`'quick' | 'standard' | 'deep'`, default `'standard'`) — reserved for future heuristics.
+
+**Returns:** `{ score, level, level_name, principles, anti_patterns_flagged, top_moves, probe_signals }`.
+
+### `score_website`
+
+HTTP-probes a URL for agent-discoverable surfaces and scores against 5 dimensions: Discoverability (25), Content Accessibility (20), Bot Access Control (15), Agent Capabilities (30), Visibility of Agent Integrations (10). Looks for `robots.txt`, `/llms.txt`, `/AGENTS.md`, `/.well-known/*`, OpenAPI surfaces, MCP server card, and markdown content negotiation.
+
+**Params:**
+- `url` (string, required) — must be `http://` or `https://`.
+
+**Returns:** `{ score, level, level_name, dimensions, anti_patterns_flagged, top_moves, probe_signals }`.
+
+### `get_principle`
+
+Returns the canonical text of one principle.
+
+**Params:**
+- `slug` — one of `interface-first`, `contract-first`, `prep-gates`, `typed-state`, `visible-outputs`, `multi-model-verification`, `perspective-dispatch`, `autonomous-recovery`.
+
+**Returns:** `{ slug, name, summary, full_url, anti_patterns_defended }`.
+
+### `get_anti_pattern`
+
+Returns the canonical definition of one anti-pattern.
+
+**Params:**
+- `slug` — one of `lazy-wrapper`, `invisible-product`, `agents-without-rules`, `single-model-trust`, `slow-chatbot`, `ship-and-forget`, `god-server`.
+
+**Returns:** `{ slug, name, definition, opposes_principle, glossary_url }`.
+
+## What the score means
+
+Total maps to a 0–4 adoption level:
+
+| Score | Level | Name |
+|------:|------:|------|
+| 0–10 | 0 | No agent access |
+| 11–25 | 1 | Agent as Afterthought |
+| 26–60 | 2 | Agent-Aware |
+| 61–85 | 3 | **Agents First** |
+| 86–100 | 4 | Agent-Driven |
+
+Aim for Level 3 on net-new projects. Lift legacy projects 1 → 2 → 3 incrementally.
+
+Full rubric: <https://agentsfirst.dev/principles/>. Glossary of anti-patterns and metrics: <https://agentsfirst.dev/glossary/>.
+
+## Local development
+
+```bash
+git clone https://github.com/capitalthought/agentsfirst
+cd agentsfirst/tools/agentsfirst-mcp
+npm install
+npm run build
+npm run prep    # sanity-check the prep gate
+node dist/server.js   # boot the server (stdio)
+```
+
+Send a `tools/list` request over stdio:
+
+```bash
+echo '{"jsonrpc":"2.0","id":1,"method":"tools/list"}' | node dist/server.js | head -20
+```
+
+## Publishing
+
+Same flow as `@capitalthought/create-agents-first`. Granular access token in 1Password Employee vault, scope-wide on `@capitalthought`, `bypass-2fa: true`. GitHub Actions auto-publishes on tag push (`v0.1.0`). Full reference: `~/icloud/Claude/ref-npm-publishing.md`.
+
+## License
+
+MIT — © 2026 Joshua Baer.

package/dist/prep.d.ts

@@ -0,0 +1,12 @@
+export interface CheckResult {
+    name: string;
+    ok: boolean;
+    message: string;
+}
+export interface PrepResult {
+    ok: boolean;
+    checks: CheckResult[];
+    rubric_version: string;
+    principles_url: string;
+}
+export declare function runPrep(): Promise<PrepResult>;

package/dist/prep.js

@@ -0,0 +1,90 @@
+// Prep Gate — pre-flight checks for the agentsfirst-mcp server.
+//
+// Two ways to run this:
+//   1. As an MCP tool — agentsfirst_prep calls runPrep()
+//   2. As a CLI — `npm run prep` for local debugging
+//
+// See https://agentsfirst.dev/principles/prep-gates/
+import { fileURLToPath } from 'node:url';
+import { ANTI_PATTERN_SLUGS, PRINCIPLE_SLUGS, PRINCIPLES_URL, RUBRIC_VERSION, } from './principles.js';
+const CANONICAL_API = 'https://agentsfirst.dev/api/principles.json';
+export async function runPrep() {
+    const checks = [];
+    // 1. Rubric loaded — 8 principles, 7 anti-patterns
+    checks.push({
+        name: 'rubric:principles',
+        ok: PRINCIPLE_SLUGS.length === 8,
+        message: PRINCIPLE_SLUGS.length === 8
+            ? `8 principles loaded`
+            : `expected 8 principles, found ${PRINCIPLE_SLUGS.length}`,
+    });
+    checks.push({
+        name: 'rubric:anti-patterns',
+        ok: ANTI_PATTERN_SLUGS.length === 7,
+        message: ANTI_PATTERN_SLUGS.length === 7
+            ? `7 anti-patterns loaded`
+            : `expected 7 anti-patterns, found ${ANTI_PATTERN_SLUGS.length}`,
+    });
+    // 2. Node version
+    const nodeMajor = parseInt(process.versions.node.split('.')[0] ?? '0', 10);
+    checks.push({
+        name: 'node:version',
+        ok: nodeMajor >= 20,
+        message: nodeMajor >= 20
+            ? `node ${process.versions.node}`
+            : `node ${process.versions.node} — requires >= 20 (built-in fetch + AbortController)`,
+    });
+    // 3. Network reachable to canonical principles API (advisory — does not fail prep)
+    let networkOk = false;
+    let networkMsg = 'skipped';
+    try {
+        const ctrl = new AbortController();
+        const timeout = setTimeout(() => ctrl.abort(), 4000);
+        const res = await fetch(CANONICAL_API, {
+            method: 'HEAD',
+            headers: { 'User-Agent': 'agentsfirst-mcp/0.1' },
+            signal: ctrl.signal,
+        });
+        clearTimeout(timeout);
+        networkOk = true;
+        networkMsg = `HEAD ${CANONICAL_API} → ${res.status}`;
+    }
+    catch (e) {
+        networkMsg = `${e.message} — offline scoring still works`;
+    }
+    checks.push({
+        name: 'network:agentsfirst.dev',
+        ok: true, // advisory
+        message: networkOk
+            ? networkMsg
+            : `${networkMsg} (advisory only — local scoring is unaffected)`,
+    });
+    return {
+        ok: checks.every((c) => c.ok),
+        checks,
+        rubric_version: RUBRIC_VERSION,
+        principles_url: PRINCIPLES_URL,
+    };
+}
+// CLI mode — `npm run prep`
+const isCli = (() => {
+    try {
+        return process.argv[1]
+            ? process.argv[1].endsWith('prep.ts') || process.argv[1].endsWith('prep.js')
+            : false;
+    }
+    catch {
+        return false;
+    }
+})();
+if (isCli) {
+    const result = await runPrep();
+    for (const c of result.checks) {
+        const prefix = c.ok ? '✅' : '❌';
+        process.stdout.write(`${prefix} ${c.name.padEnd(32)} ${c.message}\n`);
+    }
+    process.stdout.write(`\n${result.ok ? '✅' : '❌'} prep ${result.ok ? 'passed' : 'FAILED'} · rubric v${result.rubric_version}\n`);
+    // Silence the unused-import warning in CLI builds
+    void fileURLToPath;
+    process.exit(result.ok ? 0 : 1);
+}

package/dist/principles.d.ts

@@ -0,0 +1,28 @@
+export declare const RUBRIC_VERSION = "0.6";
+export declare const PRINCIPLES_URL = "https://agentsfirst.dev/principles/";
+export declare const GLOSSARY_URL = "https://agentsfirst.dev/glossary/";
+export type PrincipleSlug = 'interface-first' | 'contract-first' | 'prep-gates' | 'typed-state' | 'visible-outputs' | 'multi-model-verification' | 'perspective-dispatch' | 'autonomous-recovery';
+export type AntiPatternSlug = 'lazy-wrapper' | 'invisible-product' | 'agents-without-rules' | 'single-model-trust' | 'slow-chatbot' | 'ship-and-forget' | 'god-server';
+export interface Principle {
+    slug: PrincipleSlug;
+    name: string;
+    summary: string;
+    full_url: string;
+    anti_patterns_defended: AntiPatternSlug[];
+}
+export interface AntiPattern {
+    slug: AntiPatternSlug;
+    name: string;
+    definition: string;
+    opposes_principle: PrincipleSlug;
+    glossary_url: string;
+}
+export declare const PRINCIPLES: Record<PrincipleSlug, Principle>;
+export declare const ANTI_PATTERNS: Record<AntiPatternSlug, AntiPattern>;
+export declare const PRINCIPLE_SLUGS: PrincipleSlug[];
+export declare const ANTI_PATTERN_SLUGS: AntiPatternSlug[];
+/**
+ * Smallest-experiment guidance per principle — one concrete next move
+ * the consumer can ship today to earn the first points.
+ */
+export declare const SMALLEST_EXPERIMENT: Record<PrincipleSlug, string>;

package/dist/principles.js

@@ -0,0 +1,133 @@
+// Canonical Agents First definitions — the 8 principles + 7 anti-patterns.
+//
+// Source of truth: https://agentsfirst.dev/principles/ and https://agentsfirst.dev/glossary/
+// These constants power get_principle and get_anti_pattern. Summaries are tight (~60 words)
+// — for the full argument, link out to the canonical URLs.
+export const RUBRIC_VERSION = '0.6';
+export const PRINCIPLES_URL = 'https://agentsfirst.dev/principles/';
+export const GLOSSARY_URL = 'https://agentsfirst.dev/glossary/';
+export const PRINCIPLES = {
+    'interface-first': {
+        slug: 'interface-first',
+        name: 'Interface First',
+        summary: 'Design the agent interface — MCP server, CLI, or typed SDK — before any human UI. The first artifact of every feature is a verb-first tool definition with typed parameters and structured returns. The web app, mobile app, and integrations all become consumers of the same capability the agent uses. Aim for 10–20 well-chosen tools per server, not 200.',
+        full_url: 'https://agentsfirst.dev/principles/interface-first/',
+        anti_patterns_defended: ['invisible-product', 'lazy-wrapper', 'god-server', 'ship-and-forget'],
+    },
+    'contract-first': {
+        slug: 'contract-first',
+        name: 'Contract First',
+        summary: 'Write the usage rules — permissions, sequences, identifiers, formatting — in AGENTS.md before implementation. Tool definitions tell the agent what is possible; the contract tells it what is allowed. Without a contract agents hallucinate IDs, violate constraints, and create duplicates. Cost: one markdown file. Skip it and trust collapses on the first wrong action.',
+        full_url: 'https://agentsfirst.dev/principles/contract-first/',
+        anti_patterns_defended: ['agents-without-rules'],
+    },
+    'prep-gates': {
+        slug: 'prep-gates',
+        name: 'Prep Gates',
+        summary: 'Pre-flight checks before every agent session — validate credentials, load fresh IDs, confirm downstream services are healthy. Stale context is the #1 source of agent errors. Ship a verb-first <project>_prep tool with every server. Make AGENTS.md require it as the first call. Re-prep only on demand or after a stale-identifier error.',
+        full_url: 'https://agentsfirst.dev/principles/prep-gates/',
+        anti_patterns_defended: [],
+    },
+    'typed-state': {
+        slug: 'typed-state',
+        name: 'Typed State',
+        summary: 'All persistent agent state flows through one structured contract with versioned migrations. Each module owns its slice. Use enums not strings, schemas not JSON blobs, named transitions not free-text status updates. The schema is the coordination layer between autonomous jobs that cannot message each other directly.',
+        full_url: 'https://agentsfirst.dev/principles/typed-state/',
+        anti_patterns_defended: [],
+    },
+    'visible-outputs': {
+        slug: 'visible-outputs',
+        name: 'Visible Outputs',
+        summary: 'Agent actions produce human-readable artifacts in tools the human already opens — Slack, email, the task manager, the inbox — not a JSON blob in a dashboard nobody checks. Lead with the action ("Created task X in Project Alpha"). Identify the agent and moment. Surface failures the same way. Track human visibility rate as a first-class metric.',
+        full_url: 'https://agentsfirst.dev/principles/visible-outputs/',
+        anti_patterns_defended: [],
+    },
+    'multi-model-verification': {
+        slug: 'multi-model-verification',
+        name: 'Multi-Model Verification',
+        summary: 'For high-stakes decisions — deploys, security reviews, billing changes — fan the prompt out to three independent models in parallel and trust only what at least two agree on. Different vendors are best. Run findings through a cheap dedup model. Sort into consensus / disputed / single-model buckets. Apply selectively; verifying every tool call breaks the economics.',
+        full_url: 'https://agentsfirst.dev/principles/multi-model-verification/',
+        anti_patterns_defended: ['single-model-trust'],
+    },
+    'perspective-dispatch': {
+        slug: 'perspective-dispatch',
+        name: 'Perspective Dispatch',
+        summary: 'Complex reviews dispatch multiple constrained perspectives — security, UX, new-user, performance — against the same artifact in parallel. Each persona has a defined focus area and a fixed severity scale; findings outside the focus get discarded. The constraint sharpens each reviewer; aggregation produces a single actionable report in minutes instead of weeks of calendar time.',
+        full_url: 'https://agentsfirst.dev/principles/perspective-dispatch/',
+        anti_patterns_defended: [],
+    },
+    'autonomous-recovery': {
+        slug: 'autonomous-recovery',
+        name: 'Autonomous Recovery',
+        summary: 'Retry transient errors with exponential backoff and a budget; do not retry permanent ones. Make every operation idempotent. Do not alert on the first failure — alert on a sustained pattern. When self-healing genuinely fails, escalate with what happened, what was tried, and a direct link to take manual action. Failing well is the discipline.',
+        full_url: 'https://agentsfirst.dev/principles/autonomous-recovery/',
+        anti_patterns_defended: ['slow-chatbot'],
+    },
+};
+export const ANTI_PATTERNS = {
+    'lazy-wrapper': {
+        slug: 'lazy-wrapper',
+        name: 'The Lazy Wrapper',
+        definition: 'The agent interface is just fetch() with a different name. No domain knowledge, no validation, no structured errors — the agent asks for active deals and gets back 47KB of nested JSON with undocumented field names. Handing someone the raw database and calling it a product.',
+        opposes_principle: 'interface-first',
+        glossary_url: 'https://agentsfirst.dev/glossary/#lazy-wrapper',
+    },
+    'invisible-product': {
+        slug: 'invisible-product',
+        name: 'The Invisible Product',
+        definition: 'Ship the web app, expose a REST API later, never think about agent access. Your product does not exist to the agent ecosystem. When a developer\'s agent needs to do the job your product was built for, it picks a competitor that\'s actually in the tool list. The cost is silent — you never enter consideration.',
+        opposes_principle: 'interface-first',
+        glossary_url: 'https://agentsfirst.dev/glossary/#invisible-product',
+    },
+    'agents-without-rules': {
+        slug: 'agents-without-rules',
+        name: 'Agents Without Rules',
+        definition: 'No AGENTS.md, no usage constraints, no sequencing requirements, no permissions matrix. The agent hallucinates identifiers, violates rate limits, creates duplicate records, and emails the wrong customers. Then someone says "AI doesn\'t work" and turns it off.',
+        opposes_principle: 'contract-first',
+        glossary_url: 'https://agentsfirst.dev/glossary/#agents-without-rules',
+    },
+    'single-model-trust': {
+        slug: 'single-model-trust',
+        name: 'Single-Model Trust',
+        definition: 'Acting on one LLM\'s "looks safe" recommendation for decisions that cost money or affect users — billing changes, deploys, security reviews. A coin flip dressed up as confidence. The model misses the auth bypass because the auth bypass looks like normal code; the model is being a single point of failure on decisions where one is unacceptable.',
+        opposes_principle: 'multi-model-verification',
+        glossary_url: 'https://agentsfirst.dev/glossary/#single-model-trust',
+    },
+    'slow-chatbot': {
+        slug: 'slow-chatbot',
+        name: 'The Slow Chatbot',
+        definition: 'Requiring human approval for every agent action. If the agent can\'t do anything without asking permission, it\'s not an agent — it\'s a chatbot with extra steps. Defeats the entire point of automation.',
+        opposes_principle: 'autonomous-recovery',
+        glossary_url: 'https://agentsfirst.dev/glossary/#slow-chatbot',
+    },
+    'ship-and-forget': {
+        slug: 'ship-and-forget',
+        name: 'Ship and Forget',
+        definition: 'Launch an agent integration for the press release, then never maintain it. Agents try to use it, hit broken auth or stale schemas, fail, and develop a negative association with your product. Worse than not having one.',
+        opposes_principle: 'interface-first',
+        glossary_url: 'https://agentsfirst.dev/glossary/#ship-and-forget',
+    },
+    'god-server': {
+        slug: 'god-server',
+        name: 'The God Server',
+        definition: 'An agent interface exposing 200 tools because it wraps an entire platform. Agents choke on tool selection when there are too many options, and the tool definitions alone can consume 50%+ of a context window before any work happens. Ten well-chosen tools beat two hundred exhaustive ones.',
+        opposes_principle: 'interface-first',
+        glossary_url: 'https://agentsfirst.dev/glossary/#god-server',
+    },
+};
+export const PRINCIPLE_SLUGS = Object.keys(PRINCIPLES);
+export const ANTI_PATTERN_SLUGS = Object.keys(ANTI_PATTERNS);
+/**
+ * Smallest-experiment guidance per principle — one concrete next move
+ * the consumer can ship today to earn the first points.
+ */
+export const SMALLEST_EXPERIMENT = {
+    'interface-first': 'Wrap your single most-used operation as one verb-first MCP tool with a Zod-typed parameter schema and a structured return. Ship it, measure time-to-first-agent-action, expand from there.',
+    'contract-first': 'Add an AGENTS.md at the repo root covering Permissions, Required Prep, Identifiers, Sequence, and Errors. One file. The agent loads it on session start.',
+    'prep-gates': 'Add a <project>_prep MCP tool that validates env, loads fresh IDs, and pings downstream services. Make AGENTS.md require it as the first call of every session.',
+    'typed-state': 'Replace the largest free-text status column with a Zod enum and a numbered migration. Generate the agent\'s tool params from the same schema.',
+    'visible-outputs': 'On every successful write tool, post a one-line human-readable artifact to Slack or email. Lead with the verb. Include a clickable link back to the action.',
+    'multi-model-verification': 'For your highest-stakes write (deploy, billing change, mass email), fan the decision out to Claude + GPT + Gemini. Act only on findings two of three agree on.',
+    'perspective-dispatch': 'Add three reviewer personas (security, UX, new-user) with constrained system prompts. Run them in parallel against your next design doc; aggregate by severity.',
+    'autonomous-recovery': 'Wrap every external call in a withRetry() helper with exponential backoff (1s, 2s, 4s, 8s, jitter) and a 5-attempt budget. On exhaustion, escalate with what/tried/manual-action.',
+};