mastermind-md 0.1.0

package/dist/cli/index.js

@@ -0,0 +1,1284 @@
+// src/cli/index.ts
+import { Command } from "commander";
+import { spawn as spawn2 } from "child_process";
+import fs6 from "fs";
+import path5 from "path";
+import os2 from "os";
+
+// package.json
+var package_default = {
+  name: "mastermind-md",
+  version: "0.1.0",
+  type: "module",
+  description: "Review Markdown with your coding agent \u2014 local-first, CriticMarkup review loop, bilingual, the file is the protocol",
+  license: "MIT",
+  author: "Kevin Ding <kevincentding@gmail.com>",
+  homepage: "https://github.com/Jingquank/Mastermind#readme",
+  repository: {
+    type: "git",
+    url: "git+https://github.com/Jingquank/Mastermind.git"
+  },
+  bugs: {
+    url: "https://github.com/Jingquank/Mastermind/issues"
+  },
+  keywords: [
+    "markdown",
+    "review",
+    "criticmarkup",
+    "ai-agents",
+    "claude",
+    "cli",
+    "bilingual",
+    "local-first"
+  ],
+  engines: {
+    node: ">=20"
+  },
+  bin: {
+    mastermind: "bin/mastermind.js",
+    "mastermind-md": "bin/mastermind.js"
+  },
+  files: [
+    "dist/",
+    "bin/",
+    "themes/",
+    ".claude/skills/",
+    "assets/agent/",
+    "README.md",
+    "LICENSE"
+  ],
+  scripts: {
+    build: "rm -rf dist && vite build && tsup",
+    dev: 'concurrently -k "MASTERMIND_PORT=5199 tsx watch src/server/index.ts" "vite"',
+    test: "vitest run",
+    "test:watch": "vitest",
+    typecheck: "tsc -p tsconfig.json && tsc -p tsconfig.node.json",
+    prepare: "npm run build",
+    prepack: "npm run build"
+  },
+  dependencies: {
+    "@codemirror/lang-markdown": "^6.5.0",
+    "@codemirror/language": "^6.12.3",
+    "@codemirror/state": "^6.6.0",
+    "@codemirror/view": "^6.43.1",
+    "@hono/node-server": "^2.0.4",
+    "@lezer/highlight": "^1.2.3",
+    "@radix-ui/react-icons": "^1.3.2",
+    chokidar: "^5.0.0",
+    codemirror: "^6.0.2",
+    commander: "^15.0.0",
+    diff: "^9.0.0",
+    hono: "^4.12.25",
+    "mdast-util-to-markdown": "^2.1.2",
+    "radix-ui": "^1.5.0",
+    react: "^19.2.7",
+    "react-dom": "^19.2.7",
+    "remark-gfm": "^4.0.1",
+    "remark-parse": "^11.0.0",
+    "remark-stringify": "^11.0.0",
+    "slot-text": "^0.2.2",
+    unified: "^11.0.5",
+    "unist-util-visit": "^5.1.0",
+    zustand: "^5.0.14"
+  },
+  devDependencies: {
+    "@types/mdast": "^4.0.4",
+    "@types/node": "^25.9.3",
+    "@types/react": "^19.2.17",
+    "@types/react-dom": "^19.2.3",
+    "@types/unist": "^3.0.3",
+    "@vitejs/plugin-react": "^6.0.2",
+    concurrently: "^10.0.3",
+    jsdom: "^29.1.1",
+    tsup: "^8.5.1",
+    tsx: "^4.22.4",
+    typescript: "^6.0.3",
+    vite: "^8.0.16",
+    vitest: "^4.1.8"
+  }
+};
+
+// src/server/paths.ts
+import { fileURLToPath } from "url";
+import path from "path";
+import os from "os";
+import fs from "fs";
+var pkgRoot = fileURLToPath(new URL("../../", import.meta.url));
+var uiDir = path.join(pkgRoot, "dist", "ui");
+var themesDir = path.join(pkgRoot, "themes");
+function configDir() {
+  return process.env.MASTERMIND_CONFIG_DIR ?? path.join(os.homedir(), ".config", "mastermind");
+}
+function ensureConfigDir() {
+  const dir = configDir();
+  fs.mkdirSync(dir, { recursive: true });
+  return dir;
+}
+function stateFilePath() {
+  return path.join(configDir(), "server.json");
+}
+function serverLogPath() {
+  return path.join(configDir(), "server.log");
+}
+function configFilePath() {
+  return path.join(configDir(), "config.json");
+}
+
+// src/server/statefile.ts
+import fs2 from "fs";
+import path2 from "path";
+function readServerState() {
+  try {
+    const raw = fs2.readFileSync(stateFilePath(), "utf8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed === "object" && parsed !== null && typeof parsed.port === "number" && typeof parsed.pid === "number" && typeof parsed.version === "string" && typeof parsed.startedAt === "number") {
+      return parsed;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function clearServerState(onlyIfPid) {
+  if (onlyIfPid !== void 0) {
+    const current = readServerState();
+    if (current && current.pid !== onlyIfPid) return;
+  }
+  try {
+    fs2.unlinkSync(stateFilePath());
+  } catch {
+  }
+}
+function pidIsAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/cli/daemon.ts
+import { spawn } from "child_process";
+import fs3 from "fs";
+import { fileURLToPath as fileURLToPath2 } from "url";
+
+// src/cli/http.ts
+function isConnRefused(err) {
+  const cause = err.cause;
+  if (!cause) return false;
+  const code = cause.code;
+  if (code === "ECONNREFUSED") return true;
+  const errors = cause.errors;
+  return Array.isArray(errors) && errors.some((e) => e.code === "ECONNREFUSED");
+}
+async function probeHealth(port) {
+  try {
+    const res = await fetch(`http://127.0.0.1:${port}/api/health`, { signal: AbortSignal.timeout(1500) });
+    if (!res.ok) return "foreign";
+    const j = await res.json();
+    if (j.ok === true && typeof j.pid === "number" && typeof j.version === "string") {
+      return j;
+    }
+    return "foreign";
+  } catch (err) {
+    return isConnRefused(err) ? "free" : "foreign";
+  }
+}
+async function postJson(port, pathName, body) {
+  const res = await fetch(`http://127.0.0.1:${port}${pathName}`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify(body),
+    signal: AbortSignal.timeout(5e3)
+  });
+  if (!res.ok) {
+    let detail = `${res.status}`;
+    try {
+      const j = await res.json();
+      if (j.error) detail = j.error;
+    } catch {
+    }
+    throw new Error(detail);
+  }
+  return await res.json();
+}
+async function postNoContent(port, pathName, body) {
+  const res = await fetch(`http://127.0.0.1:${port}${pathName}`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify(body),
+    signal: AbortSignal.timeout(5e3)
+  });
+  if (!res.ok) {
+    let detail = `${res.status}`;
+    try {
+      const j = await res.json();
+      if (j.error) detail = j.error;
+    } catch {
+    }
+    throw new Error(detail);
+  }
+}
+async function getJson(port, pathName) {
+  const res = await fetch(`http://127.0.0.1:${port}${pathName}`, { signal: AbortSignal.timeout(5e3) });
+  if (!res.ok) throw new Error(`${res.status}`);
+  return await res.json();
+}
+async function putJson(port, pathName, body) {
+  const res = await fetch(`http://127.0.0.1:${port}${pathName}`, {
+    method: "PUT",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify(body),
+    signal: AbortSignal.timeout(5e3)
+  });
+  if (!res.ok) {
+    let detail = `${res.status}`;
+    try {
+      const j = await res.json();
+      if (j.error) detail = j.error;
+    } catch {
+    }
+    throw new Error(detail);
+  }
+  return await res.json();
+}
+async function requestShutdown(port) {
+  try {
+    await fetch(`http://127.0.0.1:${port}/api/admin/shutdown`, {
+      method: "POST",
+      signal: AbortSignal.timeout(1500)
+    });
+  } catch {
+  }
+}
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+
+// src/cli/daemon.ts
+var serverEntry = fileURLToPath2(new URL("../server/index.js", import.meta.url));
+var CliError = class extends Error {
+  constructor(message, exitCode) {
+    super(message);
+    this.exitCode = exitCode;
+  }
+  exitCode;
+};
+function spawnDaemon(opts) {
+  ensureConfigDir();
+  const logPath = serverLogPath();
+  try {
+    const st = fs3.statSync(logPath);
+    if (st.size > 5 * 1024 * 1024) fs3.renameSync(logPath, `${logPath}.1`);
+  } catch {
+  }
+  const logFd = fs3.openSync(logPath, "a");
+  const child = spawn(process.execPath, [serverEntry], {
+    detached: true,
+    stdio: ["ignore", logFd, logFd],
+    cwd: pkgRoot,
+    env: {
+      ...process.env,
+      MASTERMIND_PORT: opts.port !== void 0 ? String(opts.port) : "",
+      MASTERMIND_PINNED: opts.pinned ? "1" : ""
+    }
+  });
+  child.unref();
+  fs3.closeSync(logFd);
+}
+async function awaitReady(deadlineMs) {
+  const until = Date.now() + deadlineMs;
+  while (Date.now() < until) {
+    const state = readServerState();
+    if (state && state.version === package_default.version) {
+      const probe = await probeHealth(state.port);
+      if (probe !== "free" && probe !== "foreign" && probe.version === package_default.version) return state.port;
+    }
+    await sleep(120);
+  }
+  throw new CliError(`daemon did not become ready \u2014 check ${serverLogPath()}`, 1);
+}
+async function shutdownAndWait(port) {
+  await requestShutdown(port);
+  const until = Date.now() + 4e3;
+  while (Date.now() < until) {
+    if (await probeHealth(port) === "free") return;
+    await sleep(100);
+  }
+}
+async function ensureServer(opts = {}) {
+  const pinned = opts.pinnedPort;
+  const state = readServerState();
+  if (state) {
+    const probe = await probeHealth(state.port);
+    if (probe !== "free" && probe !== "foreign") {
+      if (probe.version !== package_default.version) {
+        process.stderr.write(`mastermind: restarting daemon (v${probe.version} \u2192 v${package_default.version})
+`);
+        await shutdownAndWait(state.port);
+      } else if (pinned !== void 0 && state.port !== pinned) {
+        process.stderr.write(`mastermind: daemon already running on port ${state.port}; reusing it (ignoring --port ${pinned})
+`);
+        return state.port;
+      } else {
+        return state.port;
+      }
+    } else {
+      if (pidIsAlive(state.pid)) {
+        process.stderr.write(`mastermind: unresponsive daemon (pid ${state.pid}) \u2014 abandoning it
+`);
+      }
+      clearServerState(state.pid);
+    }
+  }
+  if (pinned !== void 0) {
+    const probe = await probeHealth(pinned);
+    if (probe === "foreign") {
+      throw new CliError(`port ${pinned} is in use by something that isn't mastermind`, 2);
+    }
+    if (probe !== "free") {
+      if (probe.version === package_default.version) return pinned;
+      await shutdownAndWait(pinned);
+    }
+    spawnDaemon({ port: pinned, pinned: true });
+  } else {
+    spawnDaemon({ pinned: false });
+  }
+  return awaitReady(6e3);
+}
+
+// src/cli/sse.ts
+async function* sseRecords(url, signal) {
+  const res = await fetch(url, { headers: { accept: "text/event-stream" }, signal });
+  if (!res.ok || !res.body) throw new Error(`sse connect failed: ${res.status}`);
+  const decoder = new TextDecoder();
+  let buf = "";
+  for await (const chunk of res.body) {
+    buf += decoder.decode(chunk, { stream: true });
+    let idx;
+    while ((idx = buf.indexOf("\n\n")) !== -1) {
+      const record = buf.slice(0, idx);
+      buf = buf.slice(idx + 2);
+      if (record.startsWith(":")) continue;
+      let event = "message";
+      let data = "";
+      for (const line of record.split("\n")) {
+        if (line.startsWith("event:")) event = line.slice(6).trim();
+        else if (line.startsWith("data:")) data += line.slice(5).trim();
+      }
+      yield { event, data };
+    }
+  }
+}
+
+// src/cli/wait.ts
+var CLOSE_MESSAGES = {
+  "tabs-closed": "tab closed without hand-back",
+  "never-opened": "browser never connected",
+  shutdown: "server shut down"
+};
+async function drainAssistPending(port, sessionId) {
+  try {
+    const res = await fetch(`http://127.0.0.1:${port}/api/assist/pending?sessionId=${sessionId}`, {
+      signal: AbortSignal.timeout(2e3)
+    });
+    if (!res.ok) return;
+    const { requests } = await res.json();
+    for (const req of requests) process.stdout.write(`mastermind-assist: ${JSON.stringify(req)}
+`);
+  } catch {
+  }
+}
+async function serveAssist(port, sessionId) {
+  process.on("SIGINT", () => process.exit(130));
+  process.on("SIGTERM", () => process.exit(143));
+  process.stderr.write("mastermind: assist listener ready \u2014 answer with `mastermind assist-result|assist-error`\n");
+  let attempts = 0;
+  for (; ; ) {
+    try {
+      await drainAssistPending(port, sessionId);
+      const url = `http://127.0.0.1:${port}/api/sessions/${sessionId}/events?role=cli&assist=1`;
+      for await (const evt of sseRecords(url)) {
+        attempts = 0;
+        if (evt.event === "assist-request") {
+          process.stdout.write(`mastermind-assist: ${evt.data}
+`);
+        } else if (evt.event === "session-closed") {
+          const { reason } = JSON.parse(evt.data);
+          process.stderr.write(`mastermind: ${CLOSE_MESSAGES[reason] ?? reason}
+`);
+          process.exit(0);
+        }
+      }
+    } catch {
+    }
+    attempts++;
+    if (await probeHealth(port) === "free") {
+      process.stderr.write("mastermind: daemon is gone\n");
+      process.exit(1);
+    }
+    await sleep(Math.min(1e3 * attempts, 1e4));
+  }
+}
+async function waitForHandback(port, sessionId, opts = {}) {
+  process.on("SIGINT", () => process.exit(130));
+  process.on("SIGTERM", () => process.exit(143));
+  let attempts = 0;
+  for (; ; ) {
+    try {
+      const q = opts.serveAssist ? "role=cli&assist=1" : "role=cli";
+      const url = `http://127.0.0.1:${port}/api/sessions/${sessionId}/events?${q}`;
+      if (opts.serveAssist) await drainAssistPending(port, sessionId);
+      for await (const evt of sseRecords(url)) {
+        attempts = 0;
+        if (evt.event === "handback") {
+          const payload = JSON.parse(evt.data);
+          process.stdout.write(`${payload.summaryLine}
+`);
+          process.exit(0);
+        }
+        if (evt.event === "session-closed") {
+          const { reason } = JSON.parse(evt.data);
+          process.stderr.write(`mastermind: ${CLOSE_MESSAGES[reason] ?? reason}
+`);
+          process.exit(1);
+        }
+        if (opts.serveAssist && evt.event === "assist-request") {
+          process.stdout.write(`mastermind-assist: ${evt.data}
+`);
+        }
+      }
+    } catch {
+    }
+    attempts++;
+    if (attempts > 3) {
+      process.stderr.write("mastermind: lost connection to the daemon\n");
+      process.exit(1);
+    }
+    await sleep(1e3 * attempts);
+    const probe = await probeHealth(port);
+    if (probe === "free" || probe === "foreign") {
+      process.stderr.write("mastermind: daemon is gone\n");
+      process.exit(1);
+    }
+    const sessionAlive = await fetch(`http://127.0.0.1:${port}/api/sessions/${sessionId}`, {
+      signal: AbortSignal.timeout(2e3)
+    }).then((r) => r.ok).catch(() => false);
+    if (!sessionAlive) {
+      process.stderr.write("mastermind: session is gone\n");
+      process.exit(1);
+    }
+  }
+}
+
+// src/server/config.ts
+import fs4 from "fs";
+import path3 from "path";
+
+// src/shared/constants.ts
+var DAEMON_IDLE_EXIT_MS = 30 * 6e4;
+var DEFAULT_AUTHOR_TAG = "ke";
+
+// src/server/config.ts
+var DEFAULT_CONFIG = {
+  version: 1,
+  theme: "grid",
+  fontSize: 16,
+  lineHeight: 1.6,
+  contentWidth: 736,
+  authorTag: DEFAULT_AUTHOR_TAG,
+  typeSet: "grid",
+  monoFont: "geist",
+  codeTheme: "none",
+  uiLang: "en",
+  langPair: { a: "English", b: "Simplified Chinese" },
+  browser: "",
+  grain: {}
+};
+function readConfig() {
+  try {
+    const raw = fs4.readFileSync(configFilePath(), "utf8");
+    const parsed = JSON.parse(raw);
+    return { ...DEFAULT_CONFIG, ...parsed, version: 1 };
+  } catch {
+    return { ...DEFAULT_CONFIG };
+  }
+}
+function persist(config) {
+  const dir = ensureConfigDir();
+  const tmp = path3.join(dir, `.config.json.${process.pid}.tmp`);
+  fs4.writeFileSync(tmp, JSON.stringify(config, null, 2));
+  fs4.renameSync(tmp, configFilePath());
+}
+function updateConfig(patch) {
+  const next = { ...readConfig(), ...patch, version: 1 };
+  persist(next);
+  return next;
+}
+
+// src/shared/critic/scanner.ts
+var OPENERS = [
+  ["{++", "ins"],
+  ["{--", "del"],
+  ["{~~", "sub"],
+  ["{==", "highlight"],
+  ["{>>", "comment"]
+];
+var CLOSERS = {
+  ins: "++}",
+  del: "--}",
+  sub: "~~}",
+  highlight: "==}",
+  comment: "<<}"
+};
+function blankBreaks(text) {
+  const out = [];
+  const re = /\r?\n[ \t]*\r?\n/g;
+  let m;
+  while ((m = re.exec(text)) !== null) {
+    out.push(m.index);
+    re.lastIndex = m.index + 1;
+  }
+  return out;
+}
+function makeExcludeLookup(exclude) {
+  const sorted = [...exclude].sort((a, b) => a.start - b.start);
+  return (pos) => {
+    let lo = 0;
+    let hi = sorted.length - 1;
+    while (lo <= hi) {
+      const mid = lo + hi >> 1;
+      const r = sorted[mid];
+      if (pos < r.start) hi = mid - 1;
+      else if (pos >= r.end) lo = mid + 1;
+      else return r;
+    }
+    return null;
+  };
+}
+function escapedAt(text, bracePos) {
+  let backslashes = 0;
+  while (bracePos - 1 - backslashes >= 0 && text[bracePos - 1 - backslashes] === "\\") backslashes++;
+  return backslashes % 2 === 1;
+}
+function scan(text, exclude = []) {
+  const spans = [];
+  const breaks = blankBreaks(text);
+  const excludeAt = makeExcludeLookup(exclude);
+  let breakIdx = 0;
+  const findToken = (token, from, limit) => {
+    let k = from;
+    while (k < limit) {
+      const j = text.indexOf(token, k);
+      if (j === -1 || j >= limit) return -1;
+      const ex = excludeAt(j);
+      if (ex) {
+        k = ex.end;
+        continue;
+      }
+      return j;
+    }
+    return -1;
+  };
+  let i = 0;
+  while (i < text.length) {
+    const brace = text.indexOf("{", i);
+    if (brace === -1) break;
+    i = brace;
+    const ex = excludeAt(i);
+    if (ex) {
+      i = ex.end;
+      continue;
+    }
+    if (escapedAt(text, i)) {
+      i += 1;
+      continue;
+    }
+    const opener = OPENERS.find(([tok]) => text.startsWith(tok, i));
+    if (!opener) {
+      i += 1;
+      continue;
+    }
+    const kind = opener[1];
+    const innerStart = i + 3;
+    while (breakIdx < breaks.length && breaks[breakIdx] < innerStart) breakIdx++;
+    const limit = breakIdx < breaks.length ? breaks[breakIdx] : text.length;
+    if (kind === "sub") {
+      const firstCloser = findToken(CLOSERS.sub, innerStart, limit);
+      const sep = findToken("~>", innerStart, limit);
+      if (firstCloser === -1 || sep === -1 || sep >= firstCloser) {
+        i += 1;
+        continue;
+      }
+      spans.push({
+        kind,
+        start: i,
+        end: firstCloser + 3,
+        innerStart,
+        innerEnd: firstCloser,
+        oldStart: innerStart,
+        oldEnd: sep,
+        newStart: sep + 2,
+        newEnd: firstCloser
+      });
+      i = firstCloser + 3;
+      continue;
+    }
+    const closer = findToken(CLOSERS[kind], innerStart, limit);
+    if (closer === -1) {
+      i += 1;
+      continue;
+    }
+    spans.push({ kind, start: i, end: closer + 3, innerStart, innerEnd: closer });
+    i = closer + 3;
+  }
+  return spans;
+}
+
+// src/shared/markdown/processor.ts
+import remarkGfm from "remark-gfm";
+import remarkParse from "remark-parse";
+import { unified } from "unified";
+var processor = unified().use(remarkParse).use(remarkGfm).freeze();
+function parseMarkdown(text) {
+  const tree = processor.parse(text);
+  return processor.runSync(tree);
+}
+
+// src/shared/markdown/exclusions.ts
+var EXCLUDED_TYPES = /* @__PURE__ */ new Set(["code", "inlineCode", "html"]);
+function codeRanges(text) {
+  const tree = parseMarkdown(text);
+  const out = [];
+  const visit = (node) => {
+    const start = node.position?.start?.offset;
+    const end = node.position?.end?.offset;
+    if (EXCLUDED_TYPES.has(node.type) && start !== void 0 && end !== void 0) {
+      out.push({ start, end });
+      return;
+    }
+    const children = node.children;
+    if (children) for (const child of children) visit(child);
+  };
+  visit(tree);
+  return out.sort((a, b) => a.start - b.start);
+}
+
+// src/shared/blocks.ts
+var UNTRANSLATABLE = /* @__PURE__ */ new Set(["code", "html", "thematicBreak", "definition"]);
+async function hashBlock(kind, text) {
+  const data = new TextEncoder().encode(`${kind}\0${text}`);
+  const digest = await globalThis.crypto.subtle.digest("SHA-256", data);
+  return [...new Uint8Array(digest)].map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+async function segmentBlocks(text) {
+  const tree = parseMarkdown(text);
+  const out = [];
+  const push = async (node, kind) => {
+    const start = node.position?.start?.offset;
+    const end = node.position?.end?.offset;
+    if (start === void 0 || end === void 0 || end <= start) return;
+    const slice = text.slice(start, end);
+    out.push({
+      hash: await hashBlock(kind, slice),
+      text: slice,
+      start,
+      end,
+      kind,
+      translatable: !UNTRANSLATABLE.has(kind)
+    });
+  };
+  for (const node of tree.children) {
+    if (node.type === "list") {
+      for (const item of node.children) await push(item, "listItem");
+      continue;
+    }
+    await push(node, node.type);
+  }
+  return out;
+}
+function validateTranslatedBlock(original, translated) {
+  const kinds = (t) => scan(t, codeRanges(t)).map((s) => s.kind).join(",");
+  return kinds(original) === kinds(translated);
+}
+function detectDocScript(text) {
+  const sample = text.slice(0, 4e3);
+  let cjk = 0;
+  let letters = 0;
+  for (const ch of sample) {
+    const code = ch.codePointAt(0);
+    if (code >= 19968 && code <= 40959) cjk++;
+    if (code >= 65 && code <= 122 || code >= 19968 && code <= 40959) letters++;
+  }
+  return letters > 0 && cjk / letters > 0.25 ? "cjk" : "latin";
+}
+
+// src/shared/languages.ts
+var LANGUAGES = [
+  { code: "en", name: "English", native: "English" },
+  { code: "zh-CN", name: "Simplified Chinese", native: "\u7B80\u4F53\u4E2D\u6587", cjk: true },
+  { code: "zh-TW", name: "Traditional Chinese", native: "\u7E41\u9AD4\u4E2D\u6587", cjk: true },
+  { code: "ja", name: "Japanese", native: "\u65E5\u672C\u8A9E", cjk: true },
+  { code: "ko", name: "Korean", native: "\uD55C\uAD6D\uC5B4", cjk: true },
+  { code: "es", name: "Spanish", native: "Espa\xF1ol" },
+  { code: "fr", name: "French", native: "Fran\xE7ais" },
+  { code: "de", name: "German", native: "Deutsch" },
+  { code: "it", name: "Italian", native: "Italiano" },
+  { code: "pt", name: "Portuguese", native: "Portugu\xEAs" },
+  { code: "ru", name: "Russian", native: "\u0420\u0443\u0441\u0441\u043A\u0438\u0439" },
+  { code: "ar", name: "Arabic", native: "\u0627\u0644\u0639\u0631\u0628\u064A\u0629" },
+  { code: "hi", name: "Hindi", native: "\u0939\u093F\u0928\u094D\u0926\u0940" },
+  { code: "bn", name: "Bengali", native: "\u09AC\u09BE\u0982\u09B2\u09BE" },
+  { code: "pa", name: "Punjabi", native: "\u0A2A\u0A70\u0A1C\u0A3E\u0A2C\u0A40" },
+  { code: "id", name: "Indonesian", native: "Bahasa Indonesia" },
+  { code: "ms", name: "Malay", native: "Bahasa Melayu" },
+  { code: "vi", name: "Vietnamese", native: "Ti\u1EBFng Vi\u1EC7t" },
+  { code: "th", name: "Thai", native: "\u0E44\u0E17\u0E22" },
+  { code: "tr", name: "Turkish", native: "T\xFCrk\xE7e" },
+  { code: "nl", name: "Dutch", native: "Nederlands" },
+  { code: "pl", name: "Polish", native: "Polski" },
+  { code: "uk", name: "Ukrainian", native: "\u0423\u043A\u0440\u0430\u0457\u043D\u0441\u044C\u043A\u0430" },
+  { code: "sv", name: "Swedish", native: "Svenska" },
+  { code: "fi", name: "Finnish", native: "Suomi" },
+  { code: "el", name: "Greek", native: "\u0395\u03BB\u03BB\u03B7\u03BD\u03B9\u03BA\u03AC" },
+  { code: "he", name: "Hebrew", native: "\u05E2\u05D1\u05E8\u05D9\u05EA" },
+  { code: "fa", name: "Persian", native: "\u0641\u0627\u0631\u0633\u06CC" },
+  { code: "cs", name: "Czech", native: "\u010Ce\u0161tina" },
+  { code: "ro", name: "Romanian", native: "Rom\xE2n\u0103" },
+  { code: "hu", name: "Hungarian", native: "Magyar" }
+];
+var norm = (s) => s.trim().toLowerCase();
+function findLanguage(value) {
+  const v = norm(value);
+  if (!v) return void 0;
+  return LANGUAGES.find((l) => norm(l.name) === v || norm(l.code) === v || norm(l.native) === v);
+}
+function isCjkLang(value) {
+  const hit = findLanguage(value);
+  if (hit) return !!hit.cjk;
+  return /^(zh|ja|ko|cjk|中文|日本|한국)/i.test(value.trim()) || /[一-鿿぀-ヿ가-힯]/.test(value);
+}
+
+// src/shared/translate-direction.ts
+function pickTarget(source, pair) {
+  const docIsCjk = detectDocScript(source) === "cjk";
+  const aIsCjk = isCjkLang(pair.a);
+  if (docIsCjk) {
+    return aIsCjk ? { sourceLang: pair.a, targetLang: pair.b } : { sourceLang: pair.b, targetLang: pair.a };
+  }
+  return aIsCjk ? { sourceLang: pair.b, targetLang: pair.a } : { sourceLang: pair.a, targetLang: pair.b };
+}
+
+// src/server/translate/cache.ts
+import path4 from "path";
+import fs5 from "fs/promises";
+function cacheFile(realPath, targetLang) {
+  const safeLang = targetLang.replace(/[^a-zA-Z0-9_-]/g, "_") || "x";
+  return path4.join(path4.dirname(realPath), ".mastermind", "translations", `${path4.basename(realPath)}.${safeLang}.json`);
+}
+async function loadCache(realPath, targetLang) {
+  try {
+    const raw = await fs5.readFile(cacheFile(realPath, targetLang), "utf8");
+    const parsed = JSON.parse(raw);
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+async function saveCache(realPath, targetLang, entries) {
+  if (Object.keys(entries).length === 0) return;
+  const file = cacheFile(realPath, targetLang);
+  try {
+    await fs5.mkdir(path4.dirname(file), { recursive: true });
+    const merged = { ...await loadCache(realPath, targetLang), ...entries };
+    await fs5.writeFile(file, JSON.stringify(merged));
+  } catch {
+  }
+}
+
+// src/server/translate/pretranslate.ts
+async function planPretranslate(realPath, source, langPair) {
+  const { sourceLang, targetLang } = pickTarget(source, langPair);
+  const cached = await loadCache(realPath, targetLang);
+  const blocks = (await segmentBlocks(source)).filter((b) => b.translatable && cached[b.hash] === void 0).map((b) => ({ hash: b.hash, text: b.text }));
+  return { sourceLang, targetLang, cachePath: cacheFile(realPath, targetLang), blocks };
+}
+async function writePretranslations(realPath, source, langPair, entries) {
+  const { targetLang } = pickTarget(source, langPair);
+  const originals = new Map((await segmentBlocks(source)).map((b) => [b.hash, b.text]));
+  const valid = {};
+  let skippedUnknownHash = 0;
+  let skippedMarkMismatch = 0;
+  for (const { hash, text } of entries) {
+    const original = originals.get(hash);
+    if (original === void 0) skippedUnknownHash++;
+    else if (!validateTranslatedBlock(original, text)) skippedMarkMismatch++;
+    else valid[hash] = text;
+  }
+  await saveCache(realPath, targetLang, valid);
+  return {
+    targetLang,
+    cachePath: cacheFile(realPath, targetLang),
+    written: Object.keys(valid).length,
+    skipped: skippedUnknownHash + skippedMarkMismatch,
+    skippedUnknownHash,
+    skippedMarkMismatch
+  };
+}
+
+// src/cli/config-edit.ts
+var CONFIG_KEYS = /* @__PURE__ */ new Set([
+  "theme",
+  "fontSize",
+  "lineHeight",
+  "contentWidth",
+  "authorTag",
+  "typeSet",
+  "monoFont",
+  "codeTheme",
+  "uiLang",
+  "langPair",
+  "browser",
+  "grain"
+]);
+var NUMERIC_KEYS = /* @__PURE__ */ new Set(["fontSize", "lineHeight", "contentWidth"]);
+function parseAssignment(arg) {
+  const eq = arg.indexOf("=");
+  if (eq < 1) throw new Error(`expected key=value, got: ${arg}`);
+  return { key: arg.slice(0, eq), value: arg.slice(eq + 1) };
+}
+function coerceConfigValue(key, value) {
+  if (!NUMERIC_KEYS.has(key.split(".")[0])) return value;
+  const n = Number(value);
+  if (value.trim() === "" || !Number.isFinite(n) || n <= 0) {
+    throw new Error(`${key} must be a positive number, got: ${value === "" ? "(empty)" : value}`);
+  }
+  return n;
+}
+function setDotted(obj, dotted, value) {
+  const parts = dotted.split(".");
+  let cur = obj;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const k = parts[i];
+    const existing = cur[k];
+    if (existing === void 0 || existing === null) cur[k] = {};
+    else if (typeof existing !== "object") {
+      throw new Error(`cannot set ${dotted}: ${parts.slice(0, i + 1).join(".")} is not a nested object`);
+    }
+    cur = cur[k];
+  }
+  cur[parts[parts.length - 1]] = value;
+}
+function getDotted(obj, dotted) {
+  return dotted.split(".").reduce((acc, k) => acc == null ? void 0 : acc[k], obj);
+}
+function applyAssignments(current, assignments) {
+  const next = structuredClone(current);
+  for (const { key, value } of assignments) {
+    const top = key.split(".")[0];
+    if (!CONFIG_KEYS.has(top)) throw new Error(`unknown config key: ${top}`);
+    setDotted(next, key, coerceConfigValue(key, value));
+  }
+  const patch = {};
+  for (const top of new Set(assignments.map((a) => a.key.split(".")[0]))) patch[top] = next[top];
+  return { patch };
+}
+
+// src/cli/browser-open.ts
+function browserOpenArgs(url, override, configBrowser) {
+  const app = (override ?? configBrowser).trim();
+  return app ? ["-a", app, url] : [url];
+}
+
+// src/cli/install-agents.ts
+var MM_BEGIN = "<!-- mastermind:begin -->";
+var MM_END = "<!-- mastermind:end -->";
+var AGENT_TARGETS = [
+  { id: "claude", dir: ".claude", globalFile: "CLAUDE.md", version: false, license: false },
+  { id: "cursor", dir: ".cursor", globalFile: null, version: true, license: true },
+  { id: "gemini", dir: ".gemini", globalFile: "GEMINI.md", version: true, license: false },
+  { id: "agents", dir: ".agents", globalFile: null, version: false, license: false }
+];
+function escapeRe(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function stripFrontmatter(md) {
+  if (!md.startsWith("---\n")) return md;
+  const end = md.indexOf("\n---", 4);
+  if (end === -1) return md;
+  const after = md.indexOf("\n", end + 1);
+  return after === -1 ? "" : md.slice(after + 1).replace(/^\n+/, "");
+}
+function skillFile(t, name, description, body, version) {
+  const lines = ["---", `name: ${name}`, `description: ${description.replace(/\n+/g, " ").trim()}`];
+  if (t.version) lines.push(`version: ${version}`);
+  if (t.license) lines.push("license: Apache-2.0");
+  lines.push("---", "");
+  return `${lines.join("\n")}
+${body.trim()}
+`;
+}
+function wrapGlobalBlock(body) {
+  return `${MM_BEGIN}
+${body.trim()}
+${MM_END}`;
+}
+function upsertMarkedBlock(existing, body) {
+  const block = wrapGlobalBlock(body);
+  const re = new RegExp(`${escapeRe(MM_BEGIN)}[\\s\\S]*?${escapeRe(MM_END)}`);
+  if (re.test(existing)) return existing.replace(re, block);
+  if (existing.trim() === "") return `${block}
+`;
+  return `${existing.replace(/\n*$/, "")}
+
+${block}
+`;
+}
+function removeMarkedBlock(existing) {
+  const re = new RegExp(`\\n*${escapeRe(MM_BEGIN)}[\\s\\S]*?${escapeRe(MM_END)}\\n*`, "g");
+  return existing.replace(re, "\n").replace(/^\n+/, "").replace(/\n{3,}/g, "\n\n");
+}
+
+// src/cli/index.ts
+var program = new Command();
+function die(code, message) {
+  process.stderr.write(`mastermind: ${message}
+`);
+  process.exit(code);
+}
+function parsePort(value) {
+  if (value === void 0) return void 0;
+  const n = Number(value);
+  if (!Number.isInteger(n) || n < 1 || n > 65535) die(2, `invalid port: ${value}`);
+  return n;
+}
+async function openBrowser(url, override) {
+  if (process.platform !== "darwin") return;
+  const args = browserOpenArgs(url, override, readConfig().browser);
+  if (args.length === 1) {
+    spawn2("open", args, { stdio: "ignore", detached: true }).unref();
+    return;
+  }
+  const ok = await new Promise((resolve) => {
+    const child = spawn2("open", args, { stdio: "ignore" });
+    child.on("error", () => resolve(false));
+    child.on("exit", (code) => resolve(code === 0));
+  });
+  if (!ok) {
+    process.stderr.write(`mastermind: couldn't open ${args[1]} \u2014 using the default browser
+`);
+    spawn2("open", [url], { stdio: "ignore", detached: true }).unref();
+  }
+}
+async function createSession(port, filePath) {
+  return postJson(port, "/api/sessions", { path: filePath });
+}
+async function createWorkspace(port, dir) {
+  return postJson(port, "/api/workspaces", { root: dir });
+}
+program.name("mastermind").description("Local-first markdown review for humans and AI agents \u2014 the file is the protocol").version(package_default.version).option("--port <n>", "port override (default 5173 or next free)");
+program.command("open").argument("<file>", "markdown file to open").option("--wait", 'block until the user clicks "Save & hand back", then exit 0').option("--serve-assist", "answer translation/suggestion requests for this session (on by default with --wait)").option("--no-assist", "with --wait, review only \u2014 do not serve the assist channel (translation/suggestions)").option("--no-browser", "print the URL without opening a browser tab").option("--in <browser>", 'open in a specific browser app, e.g. "Google Chrome" (overrides the configured default)').description("start the server if not running and open a browser tab for this file").action(async (file, opts) => {
+  const pinnedPort = parsePort(program.opts().port);
+  const abs = path5.resolve(file);
+  let st;
+  try {
+    st = fs6.statSync(abs);
+  } catch {
+    die(2, `file not found: ${abs}`);
+  }
+  if (!st.isFile()) die(2, `not a file: ${abs}`);
+  const port = await ensureServer({ pinnedPort });
+  const session = await createSession(port, abs);
+  process.stdout.write(`${session.url}
+`);
+  if (opts.browser) await openBrowser(session.url, opts.in);
+  const serve = !!opts.serveAssist || !!opts.wait && opts.assist;
+  if (opts.wait) {
+    await waitForHandback(port, session.sessionId, { serveAssist: serve });
+  } else if (serve) {
+    await serveAssist(port, session.sessionId);
+  }
+  process.exit(0);
+});
+program.command("workspace").alias("ws").argument("[dir]", "directory to browse (default: current directory)").option("--no-browser", "print the URL without opening a browser tab").description("open a file-tree workspace rooted at a directory").action(async (dirArg, opts) => {
+  const pinnedPort = parsePort(program.opts().port);
+  const abs = path5.resolve(dirArg ?? process.cwd());
+  let st;
+  try {
+    st = fs6.statSync(abs);
+  } catch {
+    die(2, `directory not found: ${abs}`);
+  }
+  if (!st.isDirectory()) die(2, `not a directory: ${abs}`);
+  const port = await ensureServer({ pinnedPort });
+  const ws = await createWorkspace(port, abs);
+  process.stdout.write(`${ws.url}
+`);
+  if (opts.browser) await openBrowser(ws.url);
+  process.exit(0);
+});
+program.command("assist").argument("<file>", "markdown file under review").description("listen for translation/suggestion requests and stream them as JSON lines (agent-channel)").action(async (file) => {
+  const pinnedPort = parsePort(program.opts().port);
+  const abs = path5.resolve(file);
+  if (!fs6.existsSync(abs)) die(2, `file not found: ${abs}`);
+  const port = await ensureServer({ pinnedPort });
+  const session = await createSession(port, abs);
+  await serveAssist(port, session.sessionId);
+});
+program.command("assist-result").argument("<id>", "the request id from the assist-request line").option("--blocks <json>", "translate result: JSON [{hash,text}]").option("--markup <md>", "suggest result: the selection rewritten with CriticMarkup").description("deliver an agent-channel result back to Mastermind").action(async (id, opts) => {
+  const state = readServerState();
+  if (!state) die(1, "no daemon running");
+  let payload;
+  if (opts.blocks !== void 0) {
+    let blocks;
+    try {
+      blocks = JSON.parse(opts.blocks);
+    } catch {
+      die(2, "--blocks must be valid JSON");
+    }
+    payload = { kind: "translate", blocks };
+  } else if (opts.markup !== void 0) {
+    payload = { kind: "suggest", markup: opts.markup };
+  } else {
+    die(2, "provide --blocks or --markup");
+  }
+  try {
+    await postNoContent(state.port, `/api/assist/${id}/result`, payload);
+    process.exit(0);
+  } catch (err) {
+    die(1, `result rejected: ${err instanceof Error ? err.message : String(err)}`);
+  }
+});
+program.command("assist-error").argument("<id>", "the request id").option("--reason <text>", "why the request could not be fulfilled").description("decline an agent-channel request").action(async (id, opts) => {
+  const state = readServerState();
+  if (!state) die(1, "no daemon running");
+  try {
+    await postNoContent(state.port, `/api/assist/${id}/error`, { reason: opts.reason ?? "declined" });
+    process.exit(0);
+  } catch (err) {
+    die(1, `error rejected: ${err instanceof Error ? err.message : String(err)}`);
+  }
+});
+program.command("new").argument("[path]", "optional path for the new draft").option("--no-browser", "print the URL without opening a browser tab").description("create a blank draft and open it (prompts for a name on first save)").action(async (pathArg, opts) => {
+  const pinnedPort = parsePort(program.opts().port);
+  const port = await ensureServer({ pinnedPort });
+  let session;
+  if (pathArg) {
+    const abs = path5.resolve(pathArg);
+    if (!fs6.existsSync(abs)) {
+      fs6.mkdirSync(path5.dirname(abs), { recursive: true });
+      fs6.writeFileSync(abs, "", { flag: "wx" });
+    }
+    session = await postJson(port, "/api/sessions", { path: abs });
+  } else {
+    session = await postJson(port, "/api/sessions", { draft: true, dir: process.cwd() });
+  }
+  process.stdout.write(`${session.url}
+`);
+  if (opts.browser) await openBrowser(session.url);
+  process.exit(0);
+});
+program.command("status").description("show daemon status").action(async () => {
+  const state = readServerState();
+  if (!state) {
+    process.stdout.write("mastermind: no daemon registered\n");
+    process.exit(0);
+  }
+  const probe = await probeHealth(state.port);
+  if (probe === "free" || probe === "foreign") {
+    process.stdout.write(
+      `mastermind: statefile names pid ${state.pid} on port ${state.port}, but no healthy daemon answered (${probe})
+`
+    );
+    process.exit(1);
+  }
+  const uptime = Math.round((Date.now() - probe.startedAt) / 1e3);
+  process.stdout.write(
+    `mastermind v${probe.version} \u2014 pid ${probe.pid}, http://127.0.0.1:${state.port}, up ${uptime}s
+log: ${serverLogPath()}
+`
+  );
+  process.exit(0);
+});
+program.command("stop").description("shut the daemon down").action(async () => {
+  const state = readServerState();
+  if (!state) {
+    process.stdout.write("mastermind: no daemon registered\n");
+    process.exit(0);
+  }
+  await requestShutdown(state.port);
+  const until = Date.now() + 4e3;
+  while (Date.now() < until) {
+    if (await probeHealth(state.port) === "free") {
+      process.stdout.write("mastermind: daemon stopped\n");
+      process.exit(0);
+    }
+    await sleep(100);
+  }
+  die(1, `daemon did not stop \u2014 check ${serverLogPath()}`);
+});
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) chunks.push(chunk);
+  return Buffer.concat(chunks).toString("utf8");
+}
+program.command("translate-blocks").argument("<file>", "markdown file to pre-translate").option("--save", "read translated [{hash,text}] JSON from stdin and write it to the on-disk cache").description("offline pre-translate: emit the blocks to translate, or (--save) cache the agent's translations").action(async (file, opts) => {
+  const abs = path5.resolve(file);
+  let source;
+  try {
+    source = fs6.readFileSync(abs, "utf8");
+  } catch {
+    die(2, `file not found: ${abs}`);
+  }
+  const { langPair } = readConfig();
+  if (opts.save) {
+    let entries;
+    try {
+      const parsed = JSON.parse(await readStdin());
+      if (!Array.isArray(parsed)) throw new Error("expected a JSON array");
+      const ok = parsed.every(
+        (e) => e !== null && typeof e === "object" && typeof e.hash === "string" && typeof e.text === "string"
+      );
+      if (!ok) throw new Error("each element must be { hash: string, text: string }");
+      entries = parsed;
+    } catch (err) {
+      die(2, `--save expects [{hash,text}] JSON on stdin: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    const res = await writePretranslations(abs, source, langPair, entries);
+    const skips = [];
+    if (res.skippedUnknownHash) skips.push(`${res.skippedUnknownHash} stale/unknown-hash`);
+    if (res.skippedMarkMismatch) skips.push(`${res.skippedMarkMismatch} mismatched-CriticMarkup`);
+    process.stdout.write(
+      `mastermind: cached ${res.written} block(s) \u2192 ${res.cachePath}${skips.length ? ` (skipped ${skips.join(", ")})` : ""}
+`
+    );
+    process.exit(0);
+  }
+  process.stdout.write(`${JSON.stringify(await planPretranslate(abs, source, langPair))}
+`);
+  process.exit(0);
+});
+async function liveDaemonPort() {
+  const state = readServerState();
+  if (!state) return null;
+  const probe = await probeHealth(state.port);
+  return typeof probe === "object" ? state.port : null;
+}
+var configCmd = program.command("config").description("read or write Mastermind preferences");
+configCmd.command("get [key]").description("print the whole config as JSON, or one dotted key (e.g. langPair.a)").action((key) => {
+  const cfg = readConfig();
+  if (key === void 0) {
+    process.stdout.write(`${JSON.stringify(cfg, null, 2)}
+`);
+  } else {
+    const v = getDotted(cfg, key);
+    if (v === void 0) die(2, `unknown config key: ${key}`);
+    process.stdout.write(`${typeof v === "string" ? v : JSON.stringify(v)}
+`);
+  }
+  process.exit(0);
+});
+configCmd.command("set <assignments...>").description('set dotted key=value pairs, e.g. langPair.a=English theme=nacht browser="Google Chrome"').action(async (raw) => {
+  let assignments;
+  try {
+    assignments = raw.map(parseAssignment);
+  } catch (err) {
+    die(2, err instanceof Error ? err.message : String(err));
+  }
+  const port = await liveDaemonPort();
+  const current = port ? await getJson(port, "/api/config") : readConfig();
+  let patch;
+  try {
+    patch = applyAssignments(current, assignments).patch;
+  } catch (err) {
+    die(2, err instanceof Error ? err.message : String(err));
+  }
+  try {
+    if (port) await putJson(port, "/api/config", patch);
+    else updateConfig(patch);
+  } catch (err) {
+    die(1, `config set failed: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  process.stdout.write(`mastermind: set ${assignments.map((a) => a.key).join(", ")}
+`);
+  process.exit(0);
+});
+var MM_DESC = "Visualize and review a Markdown file in Mastermind \u2014 /mastermind [setup|demo|<file>]. Always pre-translates the doc into both reading languages first.";
+var MASTER_DESC = "Alias of /mastermind: translate a file into both reading languages, then open it in Mastermind.";
+function readCanonical(rel) {
+  return fs6.readFileSync(path5.join(pkgRoot, rel), "utf8");
+}
+function installAgents(opts) {
+  const home = os2.homedir();
+  const mmBody = stripFrontmatter(readCanonical(".claude/skills/mastermind/SKILL.md"));
+  const masterBody = stripFrontmatter(readCanonical(".claude/skills/master/SKILL.md"));
+  const demo = readCanonical(".claude/skills/mastermind/reference/demo.md");
+  const globalBody = readCanonical("assets/agent/global.md");
+  const done = [];
+  for (const t of AGENT_TARGETS) {
+    const base = path5.join(home, t.dir);
+    if (!opts.all && !fs6.existsSync(base)) continue;
+    const mmDir = path5.join(base, "skills", "mastermind");
+    fs6.mkdirSync(path5.join(mmDir, "reference"), { recursive: true });
+    fs6.writeFileSync(path5.join(mmDir, "SKILL.md"), skillFile(t, "mastermind", MM_DESC, mmBody, package_default.version));
+    fs6.writeFileSync(path5.join(mmDir, "reference", "demo.md"), demo);
+    const masterDir = path5.join(base, "skills", "master");
+    fs6.mkdirSync(masterDir, { recursive: true });
+    fs6.writeFileSync(path5.join(masterDir, "SKILL.md"), skillFile(t, "master", MASTER_DESC, masterBody, package_default.version));
+    let note = `  ${t.id}: skills/{mastermind,master}`;
+    if (opts.global && t.globalFile) {
+      const gf = path5.join(base, t.globalFile);
+      const existing = fs6.existsSync(gf) ? fs6.readFileSync(gf, "utf8") : "";
+      fs6.writeFileSync(gf, upsertMarkedBlock(existing, globalBody));
+      note += ` + global (${t.globalFile})`;
+    } else if (opts.global && !t.globalFile) {
+      note += ` + global skipped (no known memory file for ${t.id}; see AGENT_SETUP.md)`;
+    }
+    done.push(`${note} \u2192 ${base}`);
+  }
+  if (done.length === 0) {
+    process.stdout.write(
+      "mastermind: no agent config dirs found (~/.claude, ~/.cursor, ~/.gemini, ~/.agents). Re-run with --all to create them.\n"
+    );
+    return;
+  }
+  process.stdout.write(`mastermind: installed for ${done.length} agent(s):
+${done.join("\n")}
+`);
+  if (opts.global) process.stdout.write("  (undo the global block + skills with `mastermind uninstall-agents`)\n");
+}
+function uninstallAgents() {
+  const home = os2.homedir();
+  const removed = [];
+  for (const t of AGENT_TARGETS) {
+    const base = path5.join(home, t.dir);
+    for (const name of ["mastermind", "master"]) {
+      const dir = path5.join(base, "skills", name);
+      if (fs6.existsSync(dir)) {
+        fs6.rmSync(dir, { recursive: true, force: true });
+        removed.push(`  ${t.id}: skills/${name}`);
+      }
+    }
+    if (t.globalFile) {
+      const gf = path5.join(base, t.globalFile);
+      if (fs6.existsSync(gf)) fs6.writeFileSync(gf, removeMarkedBlock(fs6.readFileSync(gf, "utf8")));
+    }
+  }
+  process.stdout.write(removed.length ? `mastermind: removed:
+${removed.join("\n")}
+` : "mastermind: nothing to remove\n");
+}
+program.command("install-agents").option("--all", "install for every supported agent, creating its config dir if absent").option("--no-global", "install the skills only \u2014 skip the always-translate-first / plan\u2192visualize global instruction block").description("install the mastermind + master skills (and a global instruction block) for your coding agents").action((opts) => {
+  installAgents({ all: !!opts.all, global: opts.global });
+  process.exit(0);
+});
+program.command("uninstall-agents").description("remove the mastermind/master skills and the global instruction block this tool installed").action(() => {
+  uninstallAgents();
+  process.exit(0);
+});
+program.parseAsync().catch((err) => {
+  if (err instanceof CliError) die(err.exitCode, err.message);
+  die(1, err instanceof Error ? err.message : String(err));
+});
+//# sourceMappingURL=index.js.map