githolon 0.52.0 → 0.53.0

package/dist/cli.mjs

@@ -1276,6 +1276,98 @@ var init_editor = __esm({
   }
 });
 
+// src/compile.ts
+import { spawn, spawnSync } from "node:child_process";
+import { createRequire } from "node:module";
+import { dirname as dirname2, join as join4 } from "node:path";
+import { pathToFileURL } from "node:url";
+function resolveCompileLauncher(cwd) {
+  const resolveDslPkg = (fromDir) => {
+    try {
+      const req = fromDir === void 0 ? createRequire(import.meta.url) : createRequire(pathToFileURL(join4(fromDir, "noop.js")));
+      return req.resolve("@githolon/dsl/package.json");
+    } catch {
+      return void 0;
+    }
+  };
+  const dslPkg = resolveDslPkg(cwd) ?? resolveDslPkg(void 0);
+  return dslPkg === void 0 ? void 0 : join4(dirname2(dslPkg), "compile_package.mjs");
+}
+function runCompile(args) {
+  const launcher = resolveCompileLauncher(process.cwd());
+  if (launcher === void 0) {
+    process.stderr.write(`error: ${NO_DSL_REMEDY}
+`);
+    return 1;
+  }
+  const r = spawnSync(process.execPath, [launcher, ...args], { stdio: "inherit", cwd: process.cwd() });
+  const status2 = r.status ?? 1;
+  if (status2 === 0 && process.stdout.isTTY) {
+    try {
+      if (!hasEditorRecommendation(process.cwd())) process.stdout.write(`
+${INIT_EDITOR_HINT}
+`);
+    } catch {
+    }
+  }
+  return status2;
+}
+function resolveCheckLauncher(cwd) {
+  const launcher = resolveCompileLauncher(cwd);
+  return launcher === void 0 ? void 0 : join4(dirname2(launcher), "check_package.mjs");
+}
+function runCheck(args) {
+  const launcher = resolveCheckLauncher(process.cwd());
+  if (launcher === void 0) {
+    process.stderr.write(`error: ${NO_DSL_REMEDY}
+`);
+    return 1;
+  }
+  const r = spawnSync(process.execPath, [launcher, ...args], { stdio: "inherit", cwd: process.cwd() });
+  return r.status ?? 1;
+}
+function resolveLspLauncher(cwd) {
+  const launcher = resolveCompileLauncher(cwd);
+  return launcher === void 0 ? void 0 : join4(dirname2(launcher), "lsp_server.mjs");
+}
+function runLsp(args) {
+  const launcher = resolveLspLauncher(process.cwd());
+  if (launcher === void 0) {
+    process.stderr.write(`error: ${NO_DSL_REMEDY}
+`);
+    return 1;
+  }
+  const r = spawnSync(process.execPath, [launcher, ...args], { stdio: "inherit", cwd: process.cwd() });
+  return r.status ?? 1;
+}
+function compileAsync(cwd, args = []) {
+  const launcher = resolveCompileLauncher(cwd);
+  const t0 = performance.now();
+  if (launcher === void 0) {
+    return Promise.resolve({ ok: false, ms: 0, output: NO_DSL_REMEDY });
+  }
+  return new Promise((resolveRun) => {
+    const chunks = [];
+    const dec4 = new TextDecoder();
+    const child = spawn(process.execPath, [launcher, ...args], { cwd, stdio: ["ignore", "pipe", "pipe"] });
+    child.stdout?.on("data", (c) => chunks.push(dec4.decode(c)));
+    child.stderr?.on("data", (c) => chunks.push(dec4.decode(c)));
+    child.on("error", (e) => resolveRun({ ok: false, ms: performance.now() - t0, output: String(e) }));
+    child.on(
+      "close",
+      (code) => resolveRun({ ok: code === 0, ms: performance.now() - t0, output: chunks.join("") })
+    );
+  });
+}
+var NO_DSL_REMEDY;
+var init_compile = __esm({
+  "src/compile.ts"() {
+    "use strict";
+    init_editor();
+    NO_DSL_REMEDY = "@githolon/dsl not found \u2014 add it to your project's dependencies";
+  }
+});
+
 // vendor/engine/git-fs.mjs
 function fsErr(code, p) {
   const e = new Error(`${code}: ${p}`);
@@ -1291,7 +1383,7 @@ function makeGitFs(preopen, mount, { File: File3, Directory: Directory3 }) {
     const rel = p.slice(mount.length + 1).replace(/\/+$/, "");
     return rel === "" ? [] : rel.split("/");
   }
-  function resolve4(ps) {
+  function resolve5(ps) {
     let cur = root;
     for (const part of ps) {
       if (!isDir(cur)) return null;
@@ -1301,11 +1393,11 @@ function makeGitFs(preopen, mount, { File: File3, Directory: Directory3 }) {
     }
     return cur;
   }
-  const parent = (ps) => resolve4(ps.slice(0, -1));
+  const parent = (ps) => resolve5(ps.slice(0, -1));
   const leaf = (ps) => ps[ps.length - 1];
   const promises = {
     async readFile(p, opts) {
-      const n = resolve4(parts(p));
+      const n = resolve5(parts(p));
       if (n === null) throw fsErr("ENOENT", p);
       if (isDir(n)) throw fsErr("EISDIR", p);
       const data = n.data ?? new Uint8Array(0);
@@ -1324,7 +1416,7 @@ function makeGitFs(preopen, mount, { File: File3, Directory: Directory3 }) {
       if (!isDir(par) || !par.contents.delete(leaf(ps))) throw fsErr("ENOENT", p);
     },
     async readdir(p) {
-      const n = resolve4(parts(p));
+      const n = resolve5(parts(p));
       if (n === null) throw fsErr("ENOENT", p);
       if (!isDir(n)) throw fsErr("ENOTDIR", p);
       return [...n.contents.keys()];
@@ -1344,7 +1436,7 @@ function makeGitFs(preopen, mount, { File: File3, Directory: Directory3 }) {
       return promises.lstat(p);
     },
     async lstat(p) {
-      const n = resolve4(parts(p));
+      const n = resolve5(parts(p));
       if (n === null) throw fsErr("ENOENT", p);
       const dir = isDir(n);
       return {
@@ -2387,21 +2479,289 @@ var init_proof_offline = __esm({
   }
 });
 
+// src/mcp.ts
+var mcp_exports = {};
+__export(mcp_exports, {
+  callTool: () => callTool,
+  extractDispositions: () => extractDispositions,
+  handleRequest: () => handleRequest,
+  runMcpServer: () => runMcpServer,
+  summarize: () => summarize,
+  toolCheck: () => toolCheck,
+  toolEvolvePreview: () => toolEvolvePreview
+});
+import { spawnSync as spawnSync4 } from "node:child_process";
+import { existsSync as existsSync10 } from "node:fs";
+import { dirname as dirname6, isAbsolute, resolve as resolve2 } from "node:path";
+function resolveConfig(config) {
+  const arg = config ?? "nomos.package.mjs";
+  const configPath = isAbsolute(arg) ? arg : resolve2(process.cwd(), arg);
+  return { configPath, cfgDir: dirname6(configPath) };
+}
+function runCheckLauncher(configPath, extraArgs) {
+  const cfgDir = dirname6(configPath);
+  const launcher = resolveCheckLauncher(cfgDir) ?? resolveCheckLauncher(process.cwd());
+  if (launcher === void 0) {
+    return { findings: [], stdout: "", stderr: "", status: 1, error: NO_DSL_REMEDY };
+  }
+  const r = spawnSync4(process.execPath, [launcher, configPath, ...extraArgs], {
+    cwd: cfgDir,
+    encoding: "utf8"
+  });
+  return {
+    findings: [],
+    stdout: r.stdout ?? "",
+    stderr: r.stderr ?? "",
+    status: r.status ?? 1
+  };
+}
+function runCheckJson(configPath, extraArgs) {
+  const base = runCheckLauncher(configPath, [...extraArgs, "--json"]);
+  if (base.error !== void 0) return base;
+  const line = base.stdout.trim().split("\n").filter(Boolean).pop() ?? "";
+  let findings;
+  try {
+    const parsed = JSON.parse(line);
+    if (!Array.isArray(parsed)) throw new Error("not an array");
+    findings = parsed;
+  } catch (e) {
+    return {
+      ...base,
+      error: `could not parse check --json output: ${e.message}
+${base.stdout}${base.stderr}`
+    };
+  }
+  return { ...base, findings };
+}
+function summarize(findings) {
+  const n = { refuse: 0, warn: 0, note: 0 };
+  for (const f of findings) n[f.level]++;
+  if (findings.length === 0) return "githolon check: all clear \u2014 no static twin flagged anything.";
+  const head = `githolon check: ${findings.length} finding(s) \u2014 ${n.refuse} refuse, ${n.warn} warn, ${n.note} note.`;
+  const lines = findings.map((f) => {
+    const where = f.file !== void 0 ? ` (${f.file}:${f.line ?? 1})` : "";
+    const who = f.directiveId !== void 0 ? `${f.domain}/${f.directiveId}` : f.domain;
+    return `  ${f.level.toUpperCase()} ${who}${where}: ${f.what} \u2014 fix: ${f.fix}`;
+  });
+  return [head, ...lines].join("\n");
+}
+function extractDispositions(humanReport) {
+  const marker = "add `dispositions` to the domain's deploy JSON:";
+  const at = humanReport.indexOf(marker);
+  if (at < 0) return void 0;
+  const rest = humanReport.slice(at + marker.length);
+  const start = rest.indexOf("{");
+  if (start < 0) return void 0;
+  let depth = 0;
+  for (let i = start; i < rest.length; i++) {
+    if (rest[i] === "{") depth++;
+    else if (rest[i] === "}") {
+      depth--;
+      if (depth === 0) {
+        try {
+          return JSON.parse(rest.slice(start, i + 1));
+        } catch {
+          return void 0;
+        }
+      }
+    }
+  }
+  return void 0;
+}
+function toolCheck(args) {
+  const { configPath } = resolveConfig(args.config);
+  if (!existsSync10(configPath)) {
+    return { text: `nomos_check: config not found: ${configPath}`, isError: true };
+  }
+  const extra = args.against !== void 0 ? ["--against", args.against] : [];
+  const run = runCheckJson(configPath, extra);
+  if (run.error !== void 0) {
+    return { text: `nomos_check: ${run.error}${run.stderr ? `
+${run.stderr}` : ""}`, isError: true };
+  }
+  const summary = summarize(run.findings);
+  const payload = { summary, findings: run.findings };
+  return { text: `${summary}
+
+${JSON.stringify(payload, null, 2)}`, isError: false };
+}
+function toolEvolvePreview(args) {
+  const { configPath } = resolveConfig(args.config);
+  if (!existsSync10(configPath)) {
+    return { text: `nomos_evolve_preview: config not found: ${configPath}`, isError: true };
+  }
+  const againstPath = isAbsolute(args.against) ? args.against : resolve2(dirname6(configPath), args.against);
+  const priorArg = existsSync10(againstPath) ? againstPath : args.against;
+  const jsonRun = runCheckJson(configPath, ["--against", priorArg]);
+  if (jsonRun.error !== void 0) {
+    return {
+      text: `nomos_evolve_preview: ${jsonRun.error}${jsonRun.stderr ? `
+${jsonRun.stderr}` : ""}`,
+      isError: true
+    };
+  }
+  const humanRun = runCheckLauncher(configPath, ["--against", priorArg]);
+  const dispositions = extractDispositions(humanRun.stdout);
+  const summary = summarize(jsonRun.findings);
+  const dispLine = dispositions !== void 0 ? "A DESTRUCTIVE evolve was detected. Add this `dispositions` block to the domain's deploy JSON before deploying:" : "No destructive evolve \u2014 the diff admits without dispositions.";
+  const payload = { summary, findings: jsonRun.findings, dispositions: dispositions ?? null };
+  return {
+    text: `${summary}
+
+${dispLine}
+
+${JSON.stringify(payload, null, 2)}`,
+    isError: false
+  };
+}
+function callTool(name, argsIn) {
+  const a = argsIn ?? {};
+  const config = typeof a.config === "string" ? a.config : void 0;
+  if (name === "nomos_check") {
+    return toolCheck({
+      ...config !== void 0 ? { config } : {},
+      ...typeof a.against === "string" ? { against: a.against } : {}
+    });
+  }
+  if (name === "nomos_evolve_preview") {
+    if (typeof a.against !== "string" || a.against.length === 0) {
+      return { text: "nomos_evolve_preview: `against` is required (a prior deploy.json / lockfile).", isError: true };
+    }
+    return toolEvolvePreview({ against: a.against, ...config !== void 0 ? { config } : {} });
+  }
+  return { text: `unknown tool: ${name}`, isError: true };
+}
+function handleRequest(req) {
+  const reply = (result) => ({ jsonrpc: "2.0", id: req.id ?? null, result });
+  const fail = (code, message) => ({
+    jsonrpc: "2.0",
+    id: req.id ?? null,
+    error: { code, message }
+  });
+  switch (req.method) {
+    case "initialize": {
+      const clientVersion = req.params?.protocolVersion;
+      return reply({
+        protocolVersion: clientVersion ?? PROTOCOL_VERSION,
+        capabilities: { tools: {} },
+        serverInfo: { name: SERVER_NAME, version: SERVER_VERSION }
+      });
+    }
+    case "notifications/initialized":
+    case "initialized":
+      return void 0;
+    // notification — no response
+    case "ping":
+      return reply({});
+    case "tools/list":
+      return reply({ tools: TOOLS });
+    case "tools/call": {
+      const p = req.params ?? {};
+      if (typeof p.name !== "string") return fail(-32602, "tools/call requires a string `name`");
+      const res = callTool(p.name, p.arguments);
+      return reply({ content: [{ type: "text", text: res.text }], isError: res.isError });
+    }
+    default:
+      if (req.id === void 0 || req.id === null) return void 0;
+      return fail(-32601, `method not found: ${req.method}`);
+  }
+}
+function runMcpServer() {
+  return new Promise((resolveRun) => {
+    let buf = "";
+    const write = (obj) => {
+      process.stdout.write(JSON.stringify(obj) + "\n");
+    };
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("data", (chunk) => {
+      buf += chunk;
+      let nl;
+      while ((nl = buf.indexOf("\n")) >= 0) {
+        const line = buf.slice(0, nl).trim();
+        buf = buf.slice(nl + 1);
+        if (line.length === 0) continue;
+        let req;
+        try {
+          req = JSON.parse(line);
+        } catch {
+          write({ jsonrpc: "2.0", id: null, error: { code: -32700, message: "parse error" } });
+          continue;
+        }
+        try {
+          const res = handleRequest(req);
+          if (res !== void 0) write(res);
+        } catch (e) {
+          write({ jsonrpc: "2.0", id: req.id ?? null, error: { code: -32603, message: e.message } });
+        }
+      }
+    });
+    process.stdin.on("end", () => resolveRun(0));
+    process.stdin.on("close", () => resolveRun(0));
+  });
+}
+var SERVER_NAME, SERVER_VERSION, PROTOCOL_VERSION, TOOLS;
+var init_mcp = __esm({
+  "src/mcp.ts"() {
+    "use strict";
+    init_compile();
+    SERVER_NAME = "nomos";
+    SERVER_VERSION = "0.1.0";
+    PROTOCOL_VERSION = "2024-11-05";
+    TOOLS = [
+      {
+        name: "nomos_check",
+        description: "Run the Nomos author-time gate (githolon check static twins) over a nomos.package.mjs and return the findings (refuse/warn/note) plus a human summary. Optionally diff against a prior deployed law for evolve-safety. Call before compiling or deploying domain law.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            config: {
+              type: "string",
+              description: "Path to nomos.package.mjs (default: ./nomos.package.mjs, relative to the server working dir)."
+            },
+            against: {
+              type: "string",
+              description: "Optional prior law to diff evolve-safety against: a build/<name>.deploy.json, a build/ dir, or a nomos.stable-ids.json lockfile."
+            }
+          }
+        }
+      },
+      {
+        name: "nomos_evolve_preview",
+        description: "Preview a Nomos LAW EVOLUTION: diff the current build against a prior deployed law and return the evolve findings plus the pasteable `dispositions` block a destructive change (removal/retype) requires. Call before deploying a change to already-deployed law.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            against: {
+              type: "string",
+              description: "REQUIRED prior law: a build/<name>.deploy.json, a build/ dir, or a nomos.stable-ids.json lockfile."
+            },
+            config: {
+              type: "string",
+              description: "Path to nomos.package.mjs (default: ./nomos.package.mjs)."
+            }
+          },
+          required: ["against"]
+        }
+      }
+    ];
+  }
+});
+
 // src/harness.ts
 var harness_exports = {};
 __export(harness_exports, {
   harnessInstall: () => harnessInstall
 });
-import { existsSync as existsSync10, readFileSync as readFileSync12, writeFileSync as writeFileSync7 } from "node:fs";
-import { join as join11 } from "node:path";
+import { existsSync as existsSync11, readFileSync as readFileSync12, writeFileSync as writeFileSync7 } from "node:fs";
+import { join as join12 } from "node:path";
 import { randomBytes as randomBytes3 } from "node:crypto";
 async function harnessInstall(opts) {
   const { deploy: deployPaths, workspace, out: outPath } = opts;
   if (deployPaths.length === 0) die("no --deploy JSON path(s) given");
-  const runtimeDir = opts.runtime || process.env["NOMOS_OFFLINE_RUNTIME"] || join11(configDir(), "runtime");
-  const wasmFile = join11(runtimeDir, "holon.wasm");
-  const pkgsFile = join11(runtimeDir, "packages.json");
-  if (!existsSync10(wasmFile) || !existsSync10(pkgsFile)) {
+  const runtimeDir = opts.runtime || process.env["NOMOS_OFFLINE_RUNTIME"] || join12(configDir(), "runtime");
+  const wasmFile = join12(runtimeDir, "holon.wasm");
+  const pkgsFile = join12(runtimeDir, "packages.json");
+  if (!existsSync11(wasmFile) || !existsSync11(pkgsFile)) {
     die(
       `runtime cache missing at ${runtimeDir} (holon.wasm + packages.json). Warm it once with a \`githolon\` run (it fetches + caches the runtime), then re-run offline.`
     );
@@ -2420,7 +2780,7 @@ async function harnessInstall(opts) {
   author(eng, workspace, "bootstrap", "installDomain", installPayload(eng.hashes.nomos, eng.nomosPkg, "nomos-test-harness"), "");
   const lawHashes = [];
   for (const p of deployPaths) {
-    if (!existsSync10(p)) die(`deploy JSON not found: ${p} \u2014 run \`npx githolon compile\` first`);
+    if (!existsSync11(p)) die(`deploy JSON not found: ${p} \u2014 run \`npx githolon compile\` first`);
     const deploy2 = JSON.parse(readFileSync12(p, "utf8"));
     const usda = deploy2.packageUsda;
     if (typeof usda !== "string" || !usda.startsWith("#usda")) die(`${p} has no #usda packageUsda`);
@@ -3511,8 +3871,8 @@ var scene_exports = {};
 __export(scene_exports, {
   scene: () => scene
 });
-import { existsSync as existsSync11, mkdirSync as mkdirSync5, writeFileSync as writeFileSync8 } from "node:fs";
-import { join as join12, resolve as resolve2 } from "node:path";
+import { existsSync as existsSync12, mkdirSync as mkdirSync5, writeFileSync as writeFileSync8 } from "node:fs";
+import { join as join13, resolve as resolve3 } from "node:path";
 import { createHash as createHash5 } from "node:crypto";
 import git3 from "isomorphic-git";
 async function walkChain2(eng, ws) {
@@ -3533,8 +3893,8 @@ async function projectOnce(cloud, target, isDir, name) {
   const { eng } = await holonEngine(cloud, void 0, "githolon-scene");
   const SOURCE3 = "source";
   if (isDir) {
-    const gitDir = existsSync11(join12(target, ".git")) ? join12(target, ".git") : target;
-    if (!existsSync11(join12(gitDir, "HEAD"))) throw new Error(`${target} is not a git repo (no HEAD)`);
+    const gitDir = existsSync12(join13(target, ".git")) ? join13(target, ".git") : target;
+    if (!existsSync12(join13(gitDir, "HEAD"))) throw new Error(`${target} is not a git repo (no HEAD)`);
     await mountFresh(eng, SOURCE3);
     eng.preopen.dir.contents.get("ws").contents.get(SOURCE3).contents.set("nomos.git", readTreeFromDisk(gitDir));
   } else {
@@ -3593,9 +3953,9 @@ async function projectOnce(cloud, target, isDir, name) {
 }
 async function scene(target, opts) {
   const cloud = cloudBase(opts.cloud);
-  const isDir = existsSync11(target) || target.includes("/") || target.startsWith(".");
-  const name = isDir ? (resolve2(target).split("/").filter(Boolean).pop() ?? "scene").replace(/\.git$/, "") : target;
-  out11(`scene \u2014 ${name} (${isDir ? resolve2(target) : `${cloud} :: ${target}`})`);
+  const isDir = existsSync12(target) || target.includes("/") || target.startsWith(".");
+  const name = isDir ? (resolve3(target).split("/").filter(Boolean).pop() ?? "scene").replace(/\.git$/, "") : target;
+  out11(`scene \u2014 ${name} (${isDir ? resolve3(target) : `${cloud} :: ${target}`})`);
   let first, second;
   try {
     first = await projectOnce(cloud, target, isDir, name);
@@ -3613,10 +3973,10 @@ async function scene(target, opts) {
     err11(`the emitted stage violates the portable profile: ${violations.join("; ")}`);
     return 1;
   }
-  const outDir = resolve2(opts.out ?? join12("scene", name));
+  const outDir = resolve3(opts.out ?? join13("scene", name));
   mkdirSync5(outDir, { recursive: true });
-  const usdaPath = join12(outDir, `${name}.usda`);
-  const usdzPath = join12(outDir, `${name}.usdz`);
+  const usdaPath = join13(outDir, `${name}.usda`);
+  const usdzPath = join13(outDir, `${name}.usdz`);
   const usdaBytes = new TextEncoder().encode(first.usda);
   writeFileSync8(usdaPath, usdaBytes);
   writeFileSync8(usdzPath, usdzPack([[`${name}.usda`, usdaBytes]]));
@@ -3645,10 +4005,10 @@ var init_scene = __esm({
 });
 
 // src/cli.ts
-import { existsSync as existsSync12, readdirSync as readdirSync4, readFileSync as readFileSync13 } from "node:fs";
-import { spawnSync as spawnSync4 } from "node:child_process";
+import { existsSync as existsSync13, readdirSync as readdirSync4, readFileSync as readFileSync13 } from "node:fs";
+import { spawnSync as spawnSync5 } from "node:child_process";
 import { createRequire as createRequire2 } from "node:module";
-import { dirname as dirname6, join as join13, resolve as resolve3 } from "node:path";
+import { dirname as dirname7, join as join14, resolve as resolve4 } from "node:path";
 import { pathToFileURL as pathToFileURL4 } from "node:url";
 
 // src/generate.ts
@@ -3831,101 +4191,17 @@ Re-run with --force to replace it.`
 
 // src/cli.ts
 init_cloud();
-
-// src/compile.ts
-init_editor();
-import { spawn, spawnSync } from "node:child_process";
-import { createRequire } from "node:module";
-import { dirname as dirname2, join as join4 } from "node:path";
-import { pathToFileURL } from "node:url";
-function resolveCompileLauncher(cwd) {
-  const resolveDslPkg = (fromDir) => {
-    try {
-      const req = fromDir === void 0 ? createRequire(import.meta.url) : createRequire(pathToFileURL(join4(fromDir, "noop.js")));
-      return req.resolve("@githolon/dsl/package.json");
-    } catch {
-      return void 0;
-    }
-  };
-  const dslPkg = resolveDslPkg(cwd) ?? resolveDslPkg(void 0);
-  return dslPkg === void 0 ? void 0 : join4(dirname2(dslPkg), "compile_package.mjs");
-}
-var NO_DSL_REMEDY = "@githolon/dsl not found \u2014 add it to your project's dependencies";
-function runCompile(args) {
-  const launcher = resolveCompileLauncher(process.cwd());
-  if (launcher === void 0) {
-    process.stderr.write(`error: ${NO_DSL_REMEDY}
-`);
-    return 1;
-  }
-  const r = spawnSync(process.execPath, [launcher, ...args], { stdio: "inherit", cwd: process.cwd() });
-  const status2 = r.status ?? 1;
-  if (status2 === 0 && process.stdout.isTTY) {
-    try {
-      if (!hasEditorRecommendation(process.cwd())) process.stdout.write(`
-${INIT_EDITOR_HINT}
-`);
-    } catch {
-    }
-  }
-  return status2;
-}
-function resolveCheckLauncher(cwd) {
-  const launcher = resolveCompileLauncher(cwd);
-  return launcher === void 0 ? void 0 : join4(dirname2(launcher), "check_package.mjs");
-}
-function runCheck(args) {
-  const launcher = resolveCheckLauncher(process.cwd());
-  if (launcher === void 0) {
-    process.stderr.write(`error: ${NO_DSL_REMEDY}
-`);
-    return 1;
-  }
-  const r = spawnSync(process.execPath, [launcher, ...args], { stdio: "inherit", cwd: process.cwd() });
-  return r.status ?? 1;
-}
-function resolveLspLauncher(cwd) {
-  const launcher = resolveCompileLauncher(cwd);
-  return launcher === void 0 ? void 0 : join4(dirname2(launcher), "lsp_server.mjs");
-}
-function runLsp(args) {
-  const launcher = resolveLspLauncher(process.cwd());
-  if (launcher === void 0) {
-    process.stderr.write(`error: ${NO_DSL_REMEDY}
-`);
-    return 1;
-  }
-  const r = spawnSync(process.execPath, [launcher, ...args], { stdio: "inherit", cwd: process.cwd() });
-  return r.status ?? 1;
-}
-function compileAsync(cwd, args = []) {
-  const launcher = resolveCompileLauncher(cwd);
-  const t0 = performance.now();
-  if (launcher === void 0) {
-    return Promise.resolve({ ok: false, ms: 0, output: NO_DSL_REMEDY });
-  }
-  return new Promise((resolveRun) => {
-    const chunks = [];
-    const dec4 = new TextDecoder();
-    const child = spawn(process.execPath, [launcher, ...args], { cwd, stdio: ["ignore", "pipe", "pipe"] });
-    child.stdout?.on("data", (c) => chunks.push(dec4.decode(c)));
-    child.stderr?.on("data", (c) => chunks.push(dec4.decode(c)));
-    child.on("error", (e) => resolveRun({ ok: false, ms: performance.now() - t0, output: String(e) }));
-    child.on(
-      "close",
-      (code) => resolveRun({ ok: code === 0, ms: performance.now() - t0, output: chunks.join("") })
-    );
-  });
-}
+init_compile();
 
 // src/dev.ts
 init_engine();
 init_cloud();
+init_compile();
+init_local_holon();
 import { existsSync as existsSync7, readFileSync as readFileSync7, watch } from "node:fs";
 import { createServer } from "node:http";
 import { dirname as dirname5, join as join8, resolve } from "node:path";
 import { pathToFileURL as pathToFileURL3 } from "node:url";
-init_local_holon();
 
 // src/project.ts
 import { existsSync as existsSync5, statSync as statSync2 } from "node:fs";
@@ -5059,6 +5335,9 @@ Authoring:
                                                        --json emits the findings (with file:line) as an array
   githolon lsp                                            the author-time gate as a stdio Language Server:
                                                        red squiggles while you write law (VS Code/Neovim/\u2026)
+  githolon mcp                                            the author-time gate as a stdio MCP server for AI
+                                                       agents (Codex/Claude): tools nomos_check +
+                                                       nomos_evolve_preview. Setup: codex mcp add nomos -- githolon mcp
   githolon compile  [compiler args]                       compile the package by ./nomos.package.mjs
   githolon init-editor                                     write .vscode/extensions.json recommending the
                                                        Nomos Law extension \u2014 the check gate as red
@@ -5247,11 +5526,11 @@ async function runProof(args) {
   const explicit = args.find((a, i) => !a.startsWith("--") && i !== domainValueIdx);
   let proofPath;
   if (explicit !== void 0) {
-    proofPath = resolve3(process.cwd(), explicit);
-    if (!existsSync12(proofPath)) return refuse(`proof not found: ${proofPath} \u2014 run \`githolon compile\` to (re)generate it`);
+    proofPath = resolve4(process.cwd(), explicit);
+    if (!existsSync13(proofPath)) return refuse(`proof not found: ${proofPath} \u2014 run \`githolon compile\` to (re)generate it`);
   } else {
-    const buildDir = join13(process.cwd(), "build");
-    if (!existsSync12(buildDir)) {
+    const buildDir = join14(process.cwd(), "build");
+    if (!existsSync13(buildDir)) {
       return refuse("no build/ directory here \u2014 run `githolon compile` first (every compile generates build/<name>.proof.mts from your law)");
     }
     const proofs = readdirSync4(buildDir).filter((f) => f.endsWith(".proof.mts"));
@@ -5261,7 +5540,7 @@ async function runProof(args) {
     if (proofs.length > 1) {
       return refuse(`found ${proofs.length} proofs (${proofs.join(", ")}) \u2014 name one: githolon proof build/<name>.proof.mts`);
     }
-    proofPath = join13(buildDir, proofs[0]);
+    proofPath = join14(buildDir, proofs[0]);
   }
   if (!live) {
     try {
@@ -5274,17 +5553,17 @@ async function runProof(args) {
   }
   const resolvePkgDir = (name, fromDir) => {
     try {
-      return dirname6(createRequire2(pathToFileURL4(join13(fromDir, "noop.js"))).resolve(`${name}/package.json`));
+      return dirname7(createRequire2(pathToFileURL4(join14(fromDir, "noop.js"))).resolve(`${name}/package.json`));
     } catch {
       return void 0;
     }
   };
   const dslDir = (() => {
     try {
-      return dirname6(createRequire2(pathToFileURL4(join13(process.cwd(), "noop.js"))).resolve("@githolon/dsl/package.json"));
+      return dirname7(createRequire2(pathToFileURL4(join14(process.cwd(), "noop.js"))).resolve("@githolon/dsl/package.json"));
     } catch {
       try {
-        return dirname6(createRequire2(import.meta.url).resolve("@githolon/dsl/package.json"));
+        return dirname7(createRequire2(import.meta.url).resolve("@githolon/dsl/package.json"));
       } catch {
         return void 0;
       }
@@ -5294,9 +5573,9 @@ async function runProof(args) {
   if (tsxDir === void 0) {
     return refuse("tsx not found \u2014 add @githolon/dsl to your project's dependencies (tsx rides along) and npm install");
   }
-  const tsxPkg = JSON.parse(readFileSync13(join13(tsxDir, "package.json"), "utf8"));
+  const tsxPkg = JSON.parse(readFileSync13(join14(tsxDir, "package.json"), "utf8"));
   const tsxBinRel = typeof tsxPkg.bin === "string" ? tsxPkg.bin : tsxPkg.bin?.["tsx"];
-  const tsxCli = join13(tsxDir, tsxBinRel ?? "dist/cli.mjs");
+  const tsxCli = join14(tsxDir, tsxBinRel ?? "dist/cli.mjs");
   console.log("githolon proof --live \u2014 the full cloud loop (throwaway workspace, retired on exit" + (keep ? "; --keep: kept" : "") + ")");
   const { wsCreate: wsCreate2, wsRetire: wsRetire2 } = await Promise.resolve().then(() => (init_cloud(), cloud_exports));
   const { resolveGovernancePrincipal: resolveGovernancePrincipal2 } = await Promise.resolve().then(() => (init_governance(), governance_exports));
@@ -5325,7 +5604,7 @@ async function runProof(args) {
       );
     }
   }
-  const r = spawnSync4(process.execPath, [tsxCli, proofPath], {
+  const r = spawnSync5(process.execPath, [tsxCli, proofPath], {
     stdio: "inherit",
     cwd: process.cwd(),
     env: {
@@ -5354,7 +5633,7 @@ function parseArgs(argv) {
   const [command, ...rest] = argv;
   if (command !== "generate" && command !== "g") {
     throw new Error(
-      `Unknown command '${command ?? "(none)"}'. Expected dev | compile | check | init-editor | proof | replay | scene | status | generate | ws | deploy | domains | secret.`
+      `Unknown command '${command ?? "(none)"}'. Expected dev | compile | check | lsp | mcp | init-editor | proof | replay | scene | status | generate | ws | deploy | domains | secret.`
     );
   }
   let outDir = DEFAULT_OUT;
@@ -5410,6 +5689,10 @@ async function main(argv) {
   if (argv[0] === "lsp") {
     return runLsp(argv.slice(1));
   }
+  if (argv[0] === "mcp") {
+    const { runMcpServer: runMcpServer2 } = await Promise.resolve().then(() => (init_mcp(), mcp_exports));
+    return runMcpServer2();
+  }
   if (argv[0] === "init-editor") {
     const { initEditor: initEditor2 } = await Promise.resolve().then(() => (init_editor(), editor_exports));
     return initEditor2(process.cwd());

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "githolon",
-  "version": "0.52.0",
+  "version": "0.53.0",
   "type": "module",
   "description": "githolon — the Nomos developer CLI: Rails-style generators for @githolon/dsl domains + the package compiler. Kernel-independent.",
   "license": "SEE LICENSE IN LICENSE.md",
@@ -29,8 +29,8 @@
   },
   "dependencies": {
     "@bjorn3/browser_wasi_shim": "0.4.2",
-    "@githolon/client": "^0.52.0",
-    "@githolon/dsl": "^0.52.0",
+    "@githolon/client": "^0.53.0",
+    "@githolon/dsl": "^0.53.0",
     "isomorphic-git": "^1.38.4"
   },
   "devDependencies": {