@horizon36596/zenith-mcp 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Horizon (FTC 36596)
+
+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/NOTICE

@@ -0,0 +1,18 @@
+Zenith
+Copyright (c) 2026 Horizon (FTC 36596)
+
+Zenith is licensed under the MIT License; see LICENSE.
+
+Third-party assets
+
+- BIOBUZZ field images (apps/web/public/fields/biobuzz/*.webp) by Team Juice 16236, from the r/FTC
+  post "BIOBUZZ custom field images (MeepMeep compatible)". Used with the credit the author asks for.
+
+Bundled fonts
+
+The following fonts are bundled in apps/web/public/fonts/. Each is licensed under the SIL Open Font
+License, Version 1.1. The full licence text ships next to each font file.
+
+- Jost, licensed under the SIL Open Font License 1.1 (jost-OFL.txt).
+- IBM Plex Sans, licensed under the SIL Open Font License 1.1 (ibm-plex-sans-OFL.txt).
+- JetBrains Mono, licensed under the SIL Open Font License 1.1 (jetbrains-mono-OFL.txt).

package/README.md

@@ -0,0 +1,129 @@
+# @horizon36596/zenith-mcp
+
+The MCP server for [Zenith](https://libraries.horizon36596.org/zenith/), the FTC autonomous planner
+by Horizon (FTC 36596). It gives an agent the same verbs as the `zenith` CLI, plus structural edit
+tools, over stdio, so the agent can write and fix an auto without hand-editing JSON.
+
+Add it to a robot repository's `.mcp.json`:
+
+```json
+{
+  "mcpServers": {
+    "zenith": {
+      "command": "npx",
+      "args": ["-y", "@horizon36596/zenith-mcp"]
+    }
+  }
+}
+```
+
+Requires Node 22 or newer. The PNG render and sim tools run the `zenith` CLI from
+`@horizon36596/zenith-cli`, which installs with this package. Documentation:
+https://libraries.horizon36596.org/zenith/. Licence: MIT.
+
+## Package reference
+
+The Zenith MCP server: the same verbs `packages/cli` has, plus structural edit tools, exposed over
+stdio so an agent (Claude Code, or any other MCP-capable client) can author and edit an auto end
+to end without hand-editing JSON. The usage guide, written for the agent side, is the docs site's
+Agents and MCP page (https://libraries.horizon36596.org/zenith/agents-mcp/); this file is the package's own reference.
+
+### Running it
+
+```
+npx -y @horizon36596/zenith-mcp
+```
+
+or, inside this workspace, `node packages/mcp/dist/index.js` after `pnpm build`, or
+`pnpm exec tsx packages/mcp/src/index.ts` straight from source. It speaks the MCP stdio protocol
+and expects to be launched by a client (an `.mcp.json` entry, an SDK `StdioClientTransport`), not
+run interactively. The Agents and MCP page's Setup section has the `.mcp.json` snippet.
+
+The server finds its project by walking up from its own working directory looking for
+`zenith.json`, the same way `zenith validate` does; run it from inside the robot repo, or pass
+`project` (`dir` on `zenith.project.open`) on each call.
+
+### Tools
+
+| tool | does |
+|---|---|
+| `zenith.project.open` | Robot/field/waypoints summary and the autos list. |
+| `zenith.auto.read` | Reads and schema-validates one auto file. |
+| `zenith.validate` | Schema + feasibility findings for one auto. |
+| `zenith.estimate` | Per-step timing table and total. |
+| `zenith.render` | Renders to SVG or PNG. |
+| `zenith.diff` | Structural diff between two autos. |
+| `zenith.sim` | Runs the robot repo's simulator via the CLI. |
+| `zenith.registry` | `robot.json`'s `commands`/`conditions` in full. |
+| `zenith.waypoints` | `waypoints.json`'s named poses in full. |
+| `zenith.edit.*` | One tool per structural edit primitive in `@horizon36596/zenith-core`'s `edit/` — see the Agents and MCP page. |
+
+Every tool takes structured JSON input (a precise `zod` schema per tool — `src/schemas.ts`) and
+returns structured JSON text. Every tool above is implemented and exercised end to end
+(`src/integration.test.ts`, `test/flowB.test.ts`); a call still comes back as
+a tool error (`isError: true`) rather than crashing the server when the input is bad or an edit is
+rejected.
+
+Every tool that calls `check`/`ledger` (`zenith.validate`, `zenith.render`, `zenith.edit.*`) resolves
+season rules through `@horizon36596/zenith-seasons` and includes a `seasonWarnings` array (full sentences,
+usually empty) in its result — see the Agents and MCP page's Seasons section.
+
+### Resources
+
+- `zenith://spec/file-format` — the File format page (https://libraries.horizon36596.org/zenith/file-format/).
+- `zenith://spec/checks` — the Checks and findings page (https://libraries.horizon36596.org/zenith/checks-and-findings/), every finding code.
+
+`spec/*.md` in this package are byte-for-byte copies of `site/docs/file-format.md` and
+`site/docs/checks-and-findings.md` (not symlinks, for a clean publish and a clean Windows checkout), so
+they ship with the published package. `src/specCopies.test.ts` fails when they drift; re-copy them
+whenever those pages change.
+
+### Layout
+
+```
+src/
+  project.ts       find zenith.json, load the robot/field/waypoints it points at, resolve an
+                    "auto" argument (name, relative path, or absolute path) to a file
+  findings.ts       resolve -> plan -> check for a parsed Auto, robot/field override included
+  editIo.ts         read-current / write-canonical-and-findings, the common tail of every
+                    zenith.edit.* tool
+  schemas.ts        zod (v4, the MCP SDK's peer version) input schemas mirroring
+                    @horizon36596/zenith-schema's (zod 3) auto.ts shapes structurally
+  spawnCli.ts       spawns the zenith CLI's own built entry point (resolved via `require.resolve`,
+                    not `npx`, so it works offline against this workspace's build) for the
+                    render --png and sim tools, so this server's own stdout (the MCP transport)
+                    never receives the CLI's output directly
+  result.ts         jsonResult / errorResult / guarded (turn a thrown error into a tool error)
+  resources.ts      the two zenith://spec/* resources
+  specCopies.test.ts  checks spec/*.md still match the docs pages they copy
+  tools/            one module per tool group: project, auto, analysis, edit
+  server.ts         createServer(): wires every tool and resource onto an McpServer
+  index.ts          the stdio binary entry point; also re-exports createServer for embedding
+```
+
+`@horizon36596/zenith-mcp` may depend on `@horizon36596/zenith-core`, `@horizon36596/zenith-schema`, `@horizon36596/zenith-seasons` and Node.
+It never touches `apps/web` or `@horizon36596/zenith-github`, and it reaches a
+season's rules only through `@horizon36596/zenith-seasons`'s registry, never by depending on a `season-*`
+package directly.
+
+Note on `zod`: this package's own tool-input schemas (`src/schemas.ts`) are written against `zod`
+4 (the MCP SDK's peer dependency) and are a structural, not nominal, mirror of `@horizon36596/zenith-schema`'s
+`zod` 3 definitions. A value that passes the MCP-facing schema still re-validates fully inside the
+`@horizon36596/zenith-core` edit primitive it reaches (`parseAuto`, via `finish()`), so the two schemas are a
+convenience for precise tool descriptions and early rejection, not the sole source of truth.
+
+### Testing
+
+`pnpm exec vitest run --project mcp` (or `pnpm test` for the whole workspace).
+`src/integration.test.ts` spawns the real server over stdio with the MCP SDK's own client — not
+`createServer()` called in-process — against the example project, so it exercises the actual stdio
+framing an agent host uses: it lists tools and resources, validates an example auto, and
+runs `zenith.edit.setPose` on a temporary copy, asserting the returned findings shape and that the
+file it wrote round-trips through `canonicalize` byte for byte.
+
+`test/flowB.test.ts` drives the agent flow (an agent authoring a new auto from nothing)
+against a small clean fixture, also over real stdio: `newAutoFromTemplate`, a path step added
+without a heading (so there is a real `HEADING_MISSING` error to fix), `setHeadingMode`, a
+`shootAll` command step, `validate`, an edit loop until the auto has zero errors, a PNG render (the
+one test in this repository that exercises `spawnCli.ts`'s child-process path end to end) and an
+`estimate` — asserting zero errors at the end and that the file on disk is canonical.

package/dist/editIo.d.ts

@@ -0,0 +1,15 @@
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import type { Auto } from "@horizon36596/zenith-schema";
+import { type Project } from "./project.js";
+/** Reads and schema-validates the auto a `zenith.edit.*` tool is about to change. */
+export declare function loadCurrent(project: Project, autoRef: string): {
+    path: string;
+    auto: Auto;
+};
+/**
+ * The common tail of every `zenith.edit.*` tool: write the edit's result back in canonical form,
+ * then run the same validate pipeline `zenith.validate` does, so the agent sees the effect of its
+ * edit immediately instead of having to call `zenith.validate` separately.
+ */
+export declare function writeEditResult(project: Project, path: string, updated: Auto, extra?: Record<string, unknown>): CallToolResult;
+//# sourceMappingURL=editIo.d.ts.map

package/dist/editIo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"editIo.d.ts","sourceRoot":"","sources":["../src/editIo.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oCAAoC,CAAC;AAEzE,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,6BAA6B,CAAC;AAExD,OAAO,EAA8D,KAAK,OAAO,EAAE,MAAM,cAAc,CAAC;AAGxG,qFAAqF;AACrF,wBAAgB,WAAW,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,IAAI,CAAA;CAAE,CAG3F;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAC7B,OAAO,EAAE,OAAO,EAChB,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,IAAI,EACb,KAAK,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,GAClC,cAAc,CAgBhB"}

package/dist/editIo.js

@@ -0,0 +1,33 @@
+import { writeFileSync } from "node:fs";
+import { canonicalize, loadAuto } from "@horizon36596/zenith-core";
+import { errorCount, findingsForAuto, helpFor, warningCount } from "./findings.js";
+import { confinePath, readJsonFile, relativeToRoot, resolveAutoPath } from "./project.js";
+import { jsonResult } from "./result.js";
+/** Reads and schema-validates the auto a `zenith.edit.*` tool is about to change. */
+export function loadCurrent(project, autoRef) {
+    const path = resolveAutoPath(project, autoRef);
+    return { path, auto: loadAuto(readJsonFile(path)) };
+}
+/**
+ * The common tail of every `zenith.edit.*` tool: write the edit's result back in canonical form,
+ * then run the same validate pipeline `zenith.validate` does, so the agent sees the effect of its
+ * edit immediately instead of having to call `zenith.validate` separately.
+ */
+export function writeEditResult(project, path, updated, extra = {}) {
+    // `path` normally already came from `resolveAutoPath` (itself confined), but this is the actual
+    // write call, so it is confined again here too: the one place every `zenith.edit.*` primitive's
+    // output reaches disk is the one place that must refuse to write outside the project on its own.
+    writeFileSync(confinePath(project.root, path), canonicalize("auto", updated), "utf8");
+    const { findings, seasonWarnings } = findingsForAuto(updated, project);
+    return jsonResult({
+        written: relativeToRoot(project, path),
+        auto: updated,
+        findings,
+        errors: errorCount(findings),
+        warnings: warningCount(findings),
+        seasonWarnings,
+        help: helpFor(findings),
+        ...extra,
+    });
+}
+//# sourceMappingURL=editIo.js.map

package/dist/editIo.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"editIo.js","sourceRoot":"","sources":["../src/editIo.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAExC,OAAO,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,2BAA2B,CAAC;AAEnE,OAAO,EAAE,UAAU,EAAE,eAAe,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AACnF,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,cAAc,EAAE,eAAe,EAAgB,MAAM,cAAc,CAAC;AACxG,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAEzC,qFAAqF;AACrF,MAAM,UAAU,WAAW,CAAC,OAAgB,EAAE,OAAe;IAC3D,MAAM,IAAI,GAAG,eAAe,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;IAC/C,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,QAAQ,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC;AACtD,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,eAAe,CAC7B,OAAgB,EAChB,IAAY,EACZ,OAAa,EACb,QAAiC,EAAE;IAEnC,gGAAgG;IAChG,gGAAgG;IAChG,iGAAiG;IACjG,aAAa,CAAC,WAAW,CAAC,OAAO,CAAC,IAAI,EAAE,IAAI,CAAC,EAAE,YAAY,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,CAAC;IACtF,MAAM,EAAE,QAAQ,EAAE,cAAc,EAAE,GAAG,eAAe,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;IACvE,OAAO,UAAU,CAAC;QAChB,OAAO,EAAE,cAAc,CAAC,OAAO,EAAE,IAAI,CAAC;QACtC,IAAI,EAAE,OAAO;QACb,QAAQ;QACR,MAAM,EAAE,UAAU,CAAC,QAAQ,CAAC;QAC5B,QAAQ,EAAE,YAAY,CAAC,QAAQ,CAAC;QAChC,cAAc;QACd,IAAI,EAAE,OAAO,CAAC,QAAQ,CAAC;QACvB,GAAG,KAAK;KACT,CAAC,CAAC;AACL,CAAC"}

package/dist/findings.d.ts

@@ -0,0 +1,35 @@
+import { type Finding, type FindingCode, type FindingHelp, type Plan } from "@horizon36596/zenith-core";
+import type { Auto, Field, Robot } from "@horizon36596/zenith-schema";
+import { type Project } from "./project.js";
+export interface AutoFindings {
+    findings: Finding[];
+    /** Full sentences from `@horizon36596/zenith-seasons` when the field names no plugin this build carries. */
+    seasonWarnings: string[];
+}
+/** Everything `zenith.estimate` and `zenith.render` need, planned once against the robot and field
+ * the auto actually resolves to (its own `robot`/`field` override, when it has one). */
+export interface LoadedAuto {
+    plan: Plan;
+    robot: Robot;
+    field: Field;
+    findings: Finding[];
+    seasonWarnings: string[];
+}
+/**
+ * Resolves `auto.robot`/`auto.field` (falling back to the project's), plans, and runs `check()` —
+ * the one shared load every MCP tool that needs a `Plan` should go through, so `zenith.estimate`
+ * and `zenith.render` can no longer quietly plan against the project's robot/field while
+ * `zenith.validate` (via `findingsForAuto` below) honours the auto's own override.
+ */
+export declare function loadAutoAndPlan(auto: Auto, project: Project): LoadedAuto;
+/** Schema plus feasibility findings for a parsed `Auto`, against a project's robot and field. */
+export declare function findingsForAuto(auto: Auto, project: Project): AutoFindings;
+export declare const errorCount: (findings: readonly Finding[]) => number;
+export declare const warningCount: (findings: readonly Finding[]) => number;
+/**
+ * What each finding code present means and how to fix it (core's `FINDING_HELP`), keyed by code,
+ * so an agent explaining a finding to a person uses the same words the editor and
+ * `zenith validate --explain` do.
+ */
+export declare function helpFor(findings: readonly Finding[]): Partial<Record<FindingCode, FindingHelp>>;
+//# sourceMappingURL=findings.d.ts.map

package/dist/findings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"findings.d.ts","sourceRoot":"","sources":["../src/findings.ts"],"names":[],"mappings":"AAAA,OAAO,EAQL,KAAK,OAAO,EACZ,KAAK,WAAW,EAChB,KAAK,WAAW,EAChB,KAAK,IAAI,EACV,MAAM,2BAA2B,CAAC;AAEnC,OAAO,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,6BAA6B,CAAC;AAEtE,OAAO,EAAgB,KAAK,OAAO,EAAE,MAAM,cAAc,CAAC;AA6B1D,MAAM,WAAW,YAAY;IAC3B,QAAQ,EAAE,OAAO,EAAE,CAAC;IACpB,4GAA4G;IAC5G,cAAc,EAAE,MAAM,EAAE,CAAC;CAC1B;AAED;wFACwF;AACxF,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,IAAI,CAAC;IACX,KAAK,EAAE,KAAK,CAAC;IACb,KAAK,EAAE,KAAK,CAAC;IACb,QAAQ,EAAE,OAAO,EAAE,CAAC;IACpB,cAAc,EAAE,MAAM,EAAE,CAAC;CAC1B;AAWD;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,OAAO,GAAG,UAAU,CAgBxE;AAED,iGAAiG;AACjG,wBAAgB,eAAe,CAAC,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,OAAO,GAAG,YAAY,CAG1E;AAED,eAAO,MAAM,UAAU,GAAI,UAAU,SAAS,OAAO,EAAE,KAAG,MACS,CAAC;AAEpE,eAAO,MAAM,YAAY,GAAI,UAAU,SAAS,OAAO,EAAE,KAAG,MACS,CAAC;AAEtE;;;;GAIG;AACH,wBAAgB,OAAO,CAAC,QAAQ,EAAE,SAAS,OAAO,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,WAAW,EAAE,WAAW,CAAC,CAAC,CAI/F"}

package/dist/findings.js

@@ -0,0 +1,76 @@
+import { check, estimate, FINDING_HELP, loadField, loadRobot, plan, resolve, } from "@horizon36596/zenith-core";
+import { resolveSeason } from "@horizon36596/zenith-seasons";
+import { isAbsolute, join } from "node:path";
+import { readJsonFile } from "./project.js";
+/**
+ * An auto may name its own robot or field file (`auto.robot`/`auto.field`); when it does, that
+ * file wins over `zenith.json`'s, and a broken override becomes a SCHEMA finding rather than a
+ * thrown error, the same as `zenith validate` (`packages/cli/src/commands/validate.ts`).
+ */
+function override(project, path, load, fallback, findings) {
+    if (path === undefined)
+        return fallback;
+    const full = isAbsolute(path) ? path : join(project.root, path);
+    try {
+        return load(readJsonFile(full));
+    }
+    catch (error) {
+        findings.push({
+            severity: "error",
+            stepId: "(file)",
+            code: "SCHEMA",
+            message: `Cannot use ${path}: ${error.message.split("\n")[0] ?? ""}`,
+        });
+        return fallback;
+    }
+}
+/**
+ * `auto.name` ends up in filesystem paths and (via `zenith sim`, `packages/cli/src/commands/sim.ts`)
+ * a shell command; the CLI enforces this at load time, and every MCP tool that plans an auto goes
+ * through `loadAutoAndPlan` below, so the same charset is enforced here too
+ * — as an error finding rather than a thrown error, so
+ * an agent editing the file sees exactly why, the same as any other SCHEMA problem.
+ */
+const AUTO_NAME_PATTERN = /^[A-Za-z0-9._-]+$/;
+/**
+ * Resolves `auto.robot`/`auto.field` (falling back to the project's), plans, and runs `check()` —
+ * the one shared load every MCP tool that needs a `Plan` should go through, so `zenith.estimate`
+ * and `zenith.render` can no longer quietly plan against the project's robot/field while
+ * `zenith.validate` (via `findingsForAuto` below) honours the auto's own override.
+ */
+export function loadAutoAndPlan(auto, project) {
+    const findings = [];
+    if (!AUTO_NAME_PATTERN.test(auto.name)) {
+        findings.push({
+            severity: "error",
+            stepId: "(file)",
+            code: "SCHEMA",
+            message: `"name" must match ${AUTO_NAME_PATTERN.source} (letters, digits, ".", "_", "-" only); got ${JSON.stringify(auto.name)}.`,
+        });
+    }
+    const robot = override(project, auto.robot, loadRobot, project.robot, findings);
+    const field = override(project, auto.field, loadField, project.field, findings);
+    const planned = plan(resolve(auto, project.waypoints), robot, field);
+    const season = resolveSeason(field);
+    findings.push(...check(planned, estimate(planned, robot), robot, field, season.rules));
+    return { plan: planned, robot, field, findings, seasonWarnings: [...season.warnings] };
+}
+/** Schema plus feasibility findings for a parsed `Auto`, against a project's robot and field. */
+export function findingsForAuto(auto, project) {
+    const { findings, seasonWarnings } = loadAutoAndPlan(auto, project);
+    return { findings, seasonWarnings };
+}
+export const errorCount = (findings) => findings.filter((finding) => finding.severity === "error").length;
+export const warningCount = (findings) => findings.filter((finding) => finding.severity === "warning").length;
+/**
+ * What each finding code present means and how to fix it (core's `FINDING_HELP`), keyed by code,
+ * so an agent explaining a finding to a person uses the same words the editor and
+ * `zenith validate --explain` do.
+ */
+export function helpFor(findings) {
+    const help = {};
+    for (const finding of findings)
+        help[finding.code] = FINDING_HELP[finding.code];
+    return help;
+}
+//# sourceMappingURL=findings.js.map

package/dist/findings.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"findings.js","sourceRoot":"","sources":["../src/findings.ts"],"names":[],"mappings":"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"}

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+import { createServer, SERVER_NAME, SERVER_VERSION } from "./server.js";
+export { createServer, SERVER_NAME, SERVER_VERSION };
+/**
+ * The `@horizon36596/zenith-mcp` binary: runs the server over stdio, the transport Claude Code's
+ * `.mcp.json` and every other MCP host speak (site/docs/agents-mcp.md). `createServer()` is
+ * exported separately so a test, or a host that wants to embed the server in-process, does not have
+ * to spawn a subprocess.
+ */
+export declare function main(): Promise<void>;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAGA,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAExE,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,cAAc,EAAE,CAAC;AAErD;;;;;GAKG;AACH,wBAAsB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAI1C"}

package/dist/index.js

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+import { pathToFileURL } from "node:url";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { createServer, SERVER_NAME, SERVER_VERSION } from "./server.js";
+export { createServer, SERVER_NAME, SERVER_VERSION };
+/**
+ * The `@horizon36596/zenith-mcp` binary: runs the server over stdio, the transport Claude Code's
+ * `.mcp.json` and every other MCP host speak (site/docs/agents-mcp.md). `createServer()` is
+ * exported separately so a test, or a host that wants to embed the server in-process, does not have
+ * to spawn a subprocess.
+ */
+export async function main() {
+    const server = createServer();
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}
+const entry = process.argv[1];
+if (entry !== undefined && import.meta.url === pathToFileURL(entry).href) {
+    await main();
+}
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AACA,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AACzC,OAAO,EAAE,oBAAoB,EAAE,MAAM,2CAA2C,CAAC;AACjF,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAExE,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,cAAc,EAAE,CAAC;AAErD;;;;;GAKG;AACH,MAAM,CAAC,KAAK,UAAU,IAAI;IACxB,MAAM,MAAM,GAAG,YAAY,EAAE,CAAC;IAC9B,MAAM,SAAS,GAAG,IAAI,oBAAoB,EAAE,CAAC;IAC7C,MAAM,MAAM,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;AAClC,CAAC;AAED,MAAM,KAAK,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;AAC9B,IAAI,KAAK,KAAK,SAAS,IAAI,MAAM,CAAC,IAAI,CAAC,GAAG,KAAK,aAAa,CAAC,KAAK,CAAC,CAAC,IAAI,EAAE,CAAC;IACzE,MAAM,IAAI,EAAE,CAAC;AACf,CAAC"}

package/dist/project.d.ts

@@ -0,0 +1,46 @@
+import type { Field, Link, Robot, Waypoints } from "@horizon36596/zenith-schema";
+export declare const LINK_FILE = "zenith.json";
+export declare class ProjectError extends Error {
+    constructor(message: string);
+}
+/**
+ * Resolves `target` (relative to `root`, or absolute) and asserts it lands inside `root`. Every
+ * path an MCP tool derives from its own input — a `name`, an `out`, an `auto` reference — must go
+ * through this before it is read or written: an agent's tool call is untrusted input in exactly
+ * the way a hand-typed CLI argument is not. Throws
+ * `ProjectError` rather than silently clamping the path, so the refusal is visible to the caller.
+ */
+export declare function confinePath(root: string, target: string): string;
+export interface Project {
+    /** The directory holding `zenith.json`. Every path in the link file is relative to it. */
+    root: string;
+    link: Link;
+    robot: Robot;
+    field: Field;
+    waypoints: Waypoints | undefined;
+}
+/** Walks up from a directory looking for `zenith.json`, the way `git` looks for `.git`. */
+export declare function findProjectRoot(from: string): string | null;
+export declare function readJsonFile(path: string): unknown;
+/**
+ * Loads `zenith.json` and the robot, field and waypoints files it points at, starting the search
+ * for the link file at `dir` (an explicit `project` argument, when a tool call gives one) or at
+ * the server process's own working directory otherwise — an MCP server is normally started from
+ * inside the robot repo (site/docs/agents-mcp.md), the same way `zenith validate` finds a project by
+ * walking up from the shell's current directory.
+ */
+export declare function resolveProject(dir?: string): Project;
+/** A path relative to `project.root`, with forward slashes so it reads the same on every OS. */
+export declare function relativeToRoot(project: Project, absolute: string): string;
+/**
+ * Resolves the `auto` argument every tool takes to an absolute path. It accepts three forms: an
+ * absolute path, a path (containing a slash or ending `.auto.json`) relative to the project root,
+ * or a bare name — the common case, matching `zenith new <name>` — resolved against the project's
+ * `autosDir`. Every form is confined to the project root (finding 2): a tool call is untrusted
+ * input, so `"../../../../outside/.gitconfig"` or an absolute path outside the project is
+ * refused here rather than followed, for a read as much as a write.
+ */
+export declare function resolveAutoPath(project: Project, auto: string): string;
+/** Every `*.auto.json` file name (without the extension) in the project's `autosDir`. */
+export declare function listAutoNames(project: Project): string[];
+//# sourceMappingURL=project.d.ts.map

package/dist/project.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"project.d.ts","sourceRoot":"","sources":["../src/project.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,6BAA6B,CAAC;AAEjF,eAAO,MAAM,SAAS,gBAAgB,CAAC;AAEvC,qBAAa,YAAa,SAAQ,KAAK;gBACzB,OAAO,EAAE,MAAM;CAI5B;AAED;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAOhE;AAED,MAAM,WAAW,OAAO;IACtB,0FAA0F;IAC1F,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,IAAI,CAAC;IACX,KAAK,EAAE,KAAK,CAAC;IACb,KAAK,EAAE,KAAK,CAAC;IACb,SAAS,EAAE,SAAS,GAAG,SAAS,CAAC;CAClC;AAED,2FAA2F;AAC3F,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAQ3D;AAED,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAYlD;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,OAAO,CAsBpD;AAED,gGAAgG;AAChG,wBAAgB,cAAc,CAAC,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAEzE;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAKtE;AAED,yFAAyF;AACzF,wBAAgB,aAAa,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,EAAE,CAOxD"}

package/dist/project.js

@@ -0,0 +1,106 @@
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { dirname, isAbsolute, join, relative, resolve as resolvePath } from "node:path";
+import { loadField, loadLink, loadRobot, loadWaypoints } from "@horizon36596/zenith-core";
+export const LINK_FILE = "zenith.json";
+export class ProjectError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "ProjectError";
+    }
+}
+/**
+ * Resolves `target` (relative to `root`, or absolute) and asserts it lands inside `root`. Every
+ * path an MCP tool derives from its own input — a `name`, an `out`, an `auto` reference — must go
+ * through this before it is read or written: an agent's tool call is untrusted input in exactly
+ * the way a hand-typed CLI argument is not. Throws
+ * `ProjectError` rather than silently clamping the path, so the refusal is visible to the caller.
+ */
+export function confinePath(root, target) {
+    const resolved = isAbsolute(target) ? resolvePath(target) : resolvePath(root, target);
+    const rel = relative(root, resolved);
+    if (rel === ".." || rel.startsWith("../") || rel.startsWith("..\\") || isAbsolute(rel)) {
+        throw new ProjectError(`"${target}" resolves outside the project root (${root}); refusing to use it.`);
+    }
+    return resolved;
+}
+/** Walks up from a directory looking for `zenith.json`, the way `git` looks for `.git`. */
+export function findProjectRoot(from) {
+    let current = resolvePath(from);
+    for (;;) {
+        if (existsSync(join(current, LINK_FILE)))
+            return current;
+        const parent = dirname(current);
+        if (parent === current)
+            return null;
+        current = parent;
+    }
+}
+export function readJsonFile(path) {
+    let text;
+    try {
+        text = readFileSync(path, "utf8");
+    }
+    catch {
+        throw new ProjectError(`Cannot read ${path}.`);
+    }
+    try {
+        return JSON.parse(text);
+    }
+    catch (error) {
+        throw new ProjectError(`${path} is not valid JSON: ${error.message}`);
+    }
+}
+/**
+ * Loads `zenith.json` and the robot, field and waypoints files it points at, starting the search
+ * for the link file at `dir` (an explicit `project` argument, when a tool call gives one) or at
+ * the server process's own working directory otherwise — an MCP server is normally started from
+ * inside the robot repo (site/docs/agents-mcp.md), the same way `zenith validate` finds a project by
+ * walking up from the shell's current directory.
+ */
+export function resolveProject(dir) {
+    const from = dir === undefined ? process.cwd() : resolvePath(dir);
+    const root = findProjectRoot(from);
+    if (root === null) {
+        throw new ProjectError(`No ${LINK_FILE} in ${from} or any directory above it. Pass "project" with the robot repo's ` +
+            "directory, or run the MCP server from inside that repo.");
+    }
+    const linkPath = join(root, LINK_FILE);
+    const link = loadLink(readJsonFile(linkPath));
+    const inRoot = (relativePath) => isAbsolute(relativePath) ? relativePath : join(root, relativePath);
+    return {
+        root,
+        link,
+        robot: loadRobot(readJsonFile(inRoot(link.robot))),
+        field: loadField(readJsonFile(inRoot(link.field))),
+        waypoints: link.waypoints === undefined ? undefined : loadWaypoints(readJsonFile(inRoot(link.waypoints))),
+    };
+}
+/** A path relative to `project.root`, with forward slashes so it reads the same on every OS. */
+export function relativeToRoot(project, absolute) {
+    return relative(project.root, absolute).split("\\").join("/");
+}
+/**
+ * Resolves the `auto` argument every tool takes to an absolute path. It accepts three forms: an
+ * absolute path, a path (containing a slash or ending `.auto.json`) relative to the project root,
+ * or a bare name — the common case, matching `zenith new <name>` — resolved against the project's
+ * `autosDir`. Every form is confined to the project root (finding 2): a tool call is untrusted
+ * input, so `"../../../../outside/.gitconfig"` or an absolute path outside the project is
+ * refused here rather than followed, for a read as much as a write.
+ */
+export function resolveAutoPath(project, auto) {
+    if (isAbsolute(auto) || auto.includes("/") || auto.includes("\\") || auto.endsWith(".auto.json")) {
+        return confinePath(project.root, auto);
+    }
+    return confinePath(project.root, join(project.link.autosDir, `${auto}.auto.json`));
+}
+/** Every `*.auto.json` file name (without the extension) in the project's `autosDir`. */
+export function listAutoNames(project) {
+    const dir = join(project.root, project.link.autosDir);
+    if (!existsSync(dir))
+        return [];
+    return readdirSync(dir)
+        .filter((entry) => entry.endsWith(".auto.json"))
+        .map((entry) => entry.slice(0, -".auto.json".length))
+        .sort();
+}
+//# sourceMappingURL=project.js.map

package/dist/project.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"project.js","sourceRoot":"","sources":["../src/project.ts"],"names":[],"mappings":"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"}

package/dist/resources.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerResources(server: McpServer): void;
+//# sourceMappingURL=resources.d.ts.map

package/dist/resources.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resources.d.ts","sourceRoot":"","sources":["../src/resources.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAmBzE,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CA8BzD"}

package/dist/resources.js

@@ -0,0 +1,37 @@
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+/**
+ * `zenith://spec/file-format` and `zenith://spec/checks`: the two reference pages an agent needs to
+ * know the file format's rules and the check codes, served as MCP resources so a client can read them
+ * without the docs site or a clone of this repository.
+ *
+ * `packages/mcp/spec/file-format.md` and `packages/mcp/spec/checks.md` are byte-for-byte copies of the
+ * public docs pages `site/docs/file-format.md` and `site/docs/checks-and-findings.md`, kept next to
+ * the package's own source (not symlinked, for a clean Windows checkout and a clean npm publish) so
+ * they ship with the published `@horizon36596/zenith-mcp` package. `specCopies.test.ts` fails when
+ * they drift; re-copy them when the pages change.
+ */
+const specDir = join(dirname(fileURLToPath(import.meta.url)), "../spec");
+function readSpec(file) {
+    return readFileSync(join(specDir, file), "utf8");
+}
+export function registerResources(server) {
+    server.registerResource("file-format", "zenith://spec/file-format", {
+        title: "Zenith file format",
+        description: "The file format reference: the five file kinds, canonical form, and every field of " +
+            "*.auto.json — step kinds, segments, heading modes, markers.",
+        mimeType: "text/markdown",
+    }, (uri) => ({
+        contents: [{ uri: uri.href, mimeType: "text/markdown", text: readSpec("file-format.md") }],
+    }));
+    server.registerResource("checks", "zenith://spec/checks", {
+        title: "Zenith checks and findings",
+        description: "The checks and findings reference: every finding code zenith.validate can raise, with " +
+            "what causes it and how to fix it.",
+        mimeType: "text/markdown",
+    }, (uri) => ({
+        contents: [{ uri: uri.href, mimeType: "text/markdown", text: readSpec("checks.md") }],
+    }));
+}
+//# sourceMappingURL=resources.js.map

package/dist/resources.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resources.js","sourceRoot":"","sources":["../src/resources.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AACvC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAC1C,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAGzC;;;;;;;;;;GAUG;AACH,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC;AAEzE,SAAS,QAAQ,CAAC,IAAY;IAC5B,OAAO,YAAY,CAAC,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,CAAC;AACnD,CAAC;AAED,MAAM,UAAU,iBAAiB,CAAC,MAAiB;IACjD,MAAM,CAAC,gBAAgB,CACrB,aAAa,EACb,2BAA2B,EAC3B;QACE,KAAK,EAAE,oBAAoB;QAC3B,WAAW,EACT,qFAAqF;YACrF,6DAA6D;QAC/D,QAAQ,EAAE,eAAe;KAC1B,EACD,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC;QACR,QAAQ,EAAE,CAAC,EAAE,GAAG,EAAE,GAAG,CAAC,IAAI,EAAE,QAAQ,EAAE,eAAe,EAAE,IAAI,EAAE,QAAQ,CAAC,gBAAgB,CAAC,EAAE,CAAC;KAC3F,CAAC,CACH,CAAC;IAEF,MAAM,CAAC,gBAAgB,CACrB,QAAQ,EACR,sBAAsB,EACtB;QACE,KAAK,EAAE,4BAA4B;QACnC,WAAW,EACT,wFAAwF;YACxF,mCAAmC;QACrC,QAAQ,EAAE,eAAe;KAC1B,EACD,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC;QACR,QAAQ,EAAE,CAAC,EAAE,GAAG,EAAE,GAAG,CAAC,IAAI,EAAE,QAAQ,EAAE,eAAe,EAAE,IAAI,EAAE,QAAQ,CAAC,WAAW,CAAC,EAAE,CAAC;KACtF,CAAC,CACH,CAAC;AACJ,CAAC"}

package/dist/result.d.ts

@@ -0,0 +1,14 @@
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+/** Every tool returns structured JSON text, pretty-printed so a human reading a transcript can too. */
+export declare function jsonResult(data: unknown): CallToolResult;
+/**
+ * Turns a thrown error into an MCP tool error result instead of letting it crash the server. The
+ * known error types this project throws (`ProjectError`, core's `EditError` and
+ * `NotImplementedError`, schema's `SchemaError`) all carry a message written for whoever is
+ * holding the file; anything else is reported by its message too, since a stack trace is not
+ * useful to an agent reading a tool result.
+ */
+export declare function errorResult(error: unknown): CallToolResult;
+/** Wraps a tool handler so anything it throws becomes a tool error result instead of crashing the server. */
+export declare function guarded<Args extends unknown[]>(handler: (...args: Args) => Promise<CallToolResult> | CallToolResult): (...args: Args) => Promise<CallToolResult>;
+//# sourceMappingURL=result.d.ts.map