mastermind-md 0.1.0

package/dist/server/index.js

@@ -0,0 +1,1752 @@
+// src/server/index.ts
+import { serve } from "@hono/node-server";
+import fsp from "fs/promises";
+
+// 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/shared/constants.ts
+var DEFAULT_PORT = 5173;
+var PORT_SCAN_LIMIT = 20;
+var SSE_PING_INTERVAL_MS = 15e3;
+var SESSION_CLOSE_GRACE_MS = 3e4;
+var SESSION_NEVER_OPENED_MS = 12e4;
+var DAEMON_IDLE_EXIT_MS = 30 * 6e4;
+var DEFAULT_AUTHOR_TAG = "ke";
+var ASSIST_TIMEOUT_MS = 12e4;
+
+// src/server/app.ts
+import { Hono } from "hono";
+import { streamSSE } from "hono/streaming";
+import fs11 from "fs/promises";
+import os3 from "os";
+import path8 from "path";
+
+// src/server/config.ts
+import fs2 from "fs";
+import path2 from "path";
+
+// 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 configFilePath() {
+  return path.join(configDir(), "config.json");
+}
+
+// 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 = fs2.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 = path2.join(dir, `.config.json.${process.pid}.tmp`);
+  fs2.writeFileSync(tmp, JSON.stringify(config, null, 2));
+  fs2.renameSync(tmp, configFilePath());
+}
+function updateConfig(patch) {
+  const next = { ...readConfig(), ...patch, version: 1 };
+  persist(next);
+  return next;
+}
+function redactConfig(config) {
+  return config;
+}
+
+// src/server/contain.ts
+import fs3 from "fs/promises";
+import path3 from "path";
+async function resolveWithin(rootReal, rel) {
+  if (path3.isAbsolute(rel)) return null;
+  const normalized = path3.normalize(rel);
+  if (normalized === ".." || normalized.startsWith(`..${path3.sep}`)) return null;
+  let real;
+  try {
+    real = await fs3.realpath(path3.resolve(rootReal, normalized));
+  } catch {
+    return null;
+  }
+  if (real !== rootReal && !real.startsWith(rootReal + path3.sep)) return null;
+  return real;
+}
+function relWithin(rootReal, realPath) {
+  if (realPath === rootReal) return "";
+  if (!realPath.startsWith(rootReal + path3.sep)) return null;
+  return realPath.slice(rootReal.length + 1).split(path3.sep).join("/");
+}
+
+// src/server/feedback.ts
+async function processFeedbackLanguage(content) {
+  return content;
+}
+
+// src/server/files.ts
+import crypto from "crypto";
+import fs4 from "fs/promises";
+function sha256hex(content) {
+  return crypto.createHash("sha256").update(content, "utf8").digest("hex");
+}
+async function writeSessionFile(session, content, baseMtimeMs) {
+  if (baseMtimeMs !== void 0) {
+    const st2 = await fs4.stat(session.path).catch(() => null);
+    if (st2 && Math.abs(st2.mtimeMs - baseMtimeMs) > 1e-3) {
+      return { ok: false, currentMtimeMs: st2.mtimeMs };
+    }
+  }
+  session.lastSelfWriteHash = sha256hex(content);
+  await fs4.writeFile(session.path, content);
+  const st = await fs4.stat(session.path);
+  return { ok: true, mtimeMs: st.mtimeMs };
+}
+
+// src/server/handback.ts
+import fs5 from "fs/promises";
+
+// 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;
+}
+var AUTHOR_RE = /^\s*@([^\s:@]{1,64}):\s?/;
+function stripLinePrefixes(s) {
+  return s.replace(/\n[ \t]*(?:>[ \t]?)*/g, "\n");
+}
+function parseAuthor(content) {
+  const m = AUTHOR_RE.exec(content);
+  if (!m) return { author: null, body: content };
+  return { author: m[1], body: content.slice(m[0].length) };
+}
+function toEntry(span, text) {
+  const { author, body } = parseAuthor(stripLinePrefixes(text.slice(span.innerStart, span.innerEnd)));
+  return { span, author, body };
+}
+function group(spans, text) {
+  const items = [];
+  let i = 0;
+  while (i < spans.length) {
+    const s = spans[i];
+    if (s.kind === "ins" || s.kind === "del" || s.kind === "sub") {
+      items.push({ type: "suggestion", span: s });
+      i++;
+      continue;
+    }
+    if (s.kind === "highlight") {
+      const next = spans[i + 1];
+      if (!(next && next.kind === "comment" && next.start === s.end)) {
+        items.push({ type: "highlight", span: s });
+        i++;
+        continue;
+      }
+      const comments2 = [];
+      let j2 = i + 1;
+      let expectedStart2 = s.end;
+      while (spans[j2] && spans[j2].kind === "comment" && spans[j2].start === expectedStart2) {
+        comments2.push(toEntry(spans[j2], text));
+        expectedStart2 = spans[j2].end;
+        j2++;
+      }
+      items.push({ type: "thread", anchor: s, comments: comments2, start: s.start, end: expectedStart2 });
+      i = j2;
+      continue;
+    }
+    const comments = [toEntry(s, text)];
+    let j = i + 1;
+    let expectedStart = s.end;
+    while (spans[j] && spans[j].kind === "comment" && spans[j].start === expectedStart) {
+      comments.push(toEntry(spans[j], text));
+      expectedStart = spans[j].end;
+      j++;
+    }
+    items.push({ type: "thread", anchor: null, comments, start: s.start, end: expectedStart });
+    i = j;
+  }
+  return items;
+}
+function reviewCounts(items) {
+  let comments = 0;
+  let edits = 0;
+  let highlights = 0;
+  for (const item of items) {
+    if (item.type === "suggestion") edits++;
+    else if (item.type === "highlight") highlights++;
+    else comments += item.comments.length;
+  }
+  return { comments, edits, highlights };
+}
+
+// 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/summary.ts
+var SUMMARY_OPEN = "<!-- mastermind:summary -->";
+var SUMMARY_CLOSE = "<!-- /mastermind:summary -->";
+var SUMMARY_RE = /[ \t]*<!-- mastermind:summary -->[\s\S]*?<!-- \/mastermind:summary -->[ \t]*\n?/g;
+function stripSummary(text) {
+  return text.replace(SUMMARY_RE, "");
+}
+function countsPhrase(counts) {
+  const parts = [];
+  if (counts.comments > 0) parts.push(`${counts.comments} comment${counts.comments === 1 ? "" : "s"}`);
+  if (counts.edits > 0) parts.push(`${counts.edits} suggested edit${counts.edits === 1 ? "" : "s"}`);
+  if (counts.highlights > 0) parts.push(`${counts.highlights} highlight${counts.highlights === 1 ? "" : "s"}`);
+  return parts.join(", ");
+}
+function summaryLine(counts) {
+  const phrase = countsPhrase(counts);
+  return `mastermind: review complete \u2014 ${phrase || "no marks"}`;
+}
+function formatStamp(date) {
+  const p = (n) => String(n).padStart(2, "0");
+  return `${date.getFullYear()}-${p(date.getMonth() + 1)}-${p(date.getDate())} ${p(date.getHours())}:${p(date.getMinutes())}`;
+}
+function noteLines(note) {
+  const safe = (note ?? "").replace(/<!--|-->/g, "").trim();
+  if (!safe) return "";
+  const quoted = safe.split("\n").map((l) => `> ${l}`.trimEnd()).join("\n");
+  return `>
+> **Note:** ${quoted.replace(/^> /, "")}
+`;
+}
+function buildSummaryBlock(counts, date, note) {
+  const phrase = countsPhrase(counts);
+  const detail = phrase ? `${phrase}. Open the CriticMarkup marks above for details.` : "No inline marks \u2014 see the document itself for changes.";
+  return `${SUMMARY_OPEN}
+> **Review summary** (${formatStamp(date)})
+> ${detail}
+${noteLines(note)}${SUMMARY_CLOSE}
+`;
+}
+function upsertSummary(text, counts, date, note) {
+  const block = buildSummaryBlock(counts, date, note);
+  const firstIdx = text.indexOf(SUMMARY_OPEN);
+  if (firstIdx !== -1) {
+    const before = stripSummary(text.slice(0, firstIdx));
+    const after = stripSummary(text.slice(firstIdx));
+    return before + block + after;
+  }
+  let body = text;
+  if (body.length > 0 && !body.endsWith("\n")) body += "\n";
+  if (body.length > 0 && !body.endsWith("\n\n")) body += "\n";
+  return body + block;
+}
+
+// src/server/handback.ts
+async function performHandback(session, rawContent, baseMtimeMs, note) {
+  if (baseMtimeMs !== void 0) {
+    const st2 = await fs5.stat(session.path).catch(() => null);
+    if (st2 && Math.abs(st2.mtimeMs - baseMtimeMs) > 1e-3) {
+      return { ok: false, currentMtimeMs: st2.mtimeMs };
+    }
+  }
+  const content = await processFeedbackLanguage(rawContent);
+  const body = stripSummary(content);
+  const counts = reviewCounts(group(scan(body, codeRanges(body)), body));
+  const final = upsertSummary(content, counts, /* @__PURE__ */ new Date(), note);
+  session.lastSelfWriteHash = sha256hex(final);
+  await fs5.writeFile(session.path, final);
+  const st = await fs5.stat(session.path);
+  return { ok: true, mtimeMs: st.mtimeMs, counts, summaryLine: summaryLine(counts) };
+}
+
+// src/server/browsers.ts
+import fs6 from "fs";
+import os2 from "os";
+import path4 from "path";
+var KNOWN_BROWSERS = [
+  "Safari",
+  "Google Chrome",
+  "Arc",
+  "Firefox",
+  "Brave Browser",
+  "Microsoft Edge",
+  "Vivaldi",
+  "Opera",
+  "Chromium",
+  "Zen"
+];
+function appExists(name) {
+  return [
+    `/Applications/${name}.app`,
+    `/System/Applications/${name}.app`,
+    path4.join(os2.homedir(), "Applications", `${name}.app`)
+  ].some((p) => fs6.existsSync(p));
+}
+function detectBrowsers() {
+  if (process.platform !== "darwin") return [];
+  return KNOWN_BROWSERS.filter(appExists).map((name) => ({ id: name, name }));
+}
+
+// src/server/themes.ts
+import fs7 from "fs/promises";
+import path5 from "path";
+
+// src/server/log.ts
+function log(...args) {
+  console.error(`[${(/* @__PURE__ */ new Date()).toISOString()}]`, ...args);
+}
+
+// src/server/themes.ts
+function parseSwatch(s) {
+  if (!s) return null;
+  const { bg, ink, accent } = s;
+  if (typeof bg === "string" && typeof ink === "string" && typeof accent === "string") {
+    return { bg, ink, accent };
+  }
+  return null;
+}
+function resolveFontUrl(themeId, src) {
+  if (src.startsWith("/themes/")) return src;
+  return `/themes/${themeId}${src.startsWith("/") ? "" : "/"}${src}`;
+}
+async function scanThemes() {
+  let entries;
+  try {
+    entries = await fs7.readdir(themesDir);
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const id of entries.sort()) {
+    const dir = path5.join(themesDir, id);
+    try {
+      const st = await fs7.stat(dir);
+      if (!st.isDirectory()) continue;
+      await fs7.access(path5.join(dir, "theme.json"));
+    } catch {
+      continue;
+    }
+    try {
+      const [jsonRaw] = await Promise.all([
+        fs7.readFile(path5.join(dir, "theme.json"), "utf8"),
+        fs7.access(path5.join(dir, "tokens.css"))
+        // both files required
+      ]);
+      const parsed = JSON.parse(jsonRaw);
+      const fonts = [];
+      for (const f of parsed.fonts ?? []) {
+        if (!f.family || !f.src) continue;
+        fonts.push({ family: f.family, url: resolveFontUrl(id, f.src), weight: f.weight ?? 400 });
+      }
+      out.push({
+        id,
+        name: parsed.name ?? id,
+        appearance: parsed.appearance === "dark" ? "dark" : "light",
+        grain: parsed.grain ? { enabled: parsed.grain.enabled ?? false, opacity: parsed.grain.opacity, tintOpacity: parsed.grain.tintOpacity } : null,
+        fonts,
+        swatch: parseSwatch(parsed.swatch)
+      });
+    } catch (err) {
+      log(`theme ${id} skipped:`, err instanceof Error ? err.message : err);
+    }
+  }
+  return out;
+}
+
+// src/shared/blocks.ts
+function validateTranslatedBlock(original, translated) {
+  const kinds = (t) => scan(t, codeRanges(t)).map((s) => s.kind).join(",");
+  return kinds(original) === kinds(translated);
+}
+
+// src/server/assist/index.ts
+import crypto2 from "crypto";
+var AssistError = class extends Error {
+  constructor(code, detail) {
+    super(detail ? `${code}: ${detail}` : code);
+    this.code = code;
+    this.name = "AssistError";
+  }
+  code;
+};
+var AssistRegistry = class {
+  constructor(sessions, timeoutMs = ASSIST_TIMEOUT_MS) {
+    this.sessions = sessions;
+    this.timeoutMs = timeoutMs;
+  }
+  sessions;
+  timeoutMs;
+  pending = /* @__PURE__ */ new Map();
+  hasListener(session) {
+    return this.sessions.hasAssistListener(session);
+  }
+  enqueue(session, request, opts = {}) {
+    return this.enqueueWithId(session, request, opts).result;
+  }
+  /** Like enqueue, but exposes the request id synchronously (the suggest route returns it now, settles later). */
+  enqueueWithId(session, request, opts = {}) {
+    if (!this.hasListener(session)) return { id: "", result: Promise.reject(new AssistError("no-agent")) };
+    const id = crypto2.randomUUID();
+    const timeoutMs = opts.timeoutMs ?? this.timeoutMs;
+    const result = new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        if (this.pending.delete(id)) {
+          session.pendingAssist.delete(id);
+          reject(new AssistError("timeout"));
+        }
+      }, timeoutMs);
+      this.pending.set(id, { id, sessionId: session.id, request, createdAt: Date.now(), resolve, reject, timer });
+      session.pendingAssist.add(id);
+      const event = { id, ...request };
+      this.sessions.broadcast(session.id, "assist-request", event, ["cli"]);
+      log(`assist: enqueued ${request.kind} ${id.slice(0, 8)} for session ${session.id}`);
+    });
+    return { id, result };
+  }
+  /** Agent delivered a result. Returns false if the id is unknown (expired / dup). */
+  resolve(id, payload) {
+    const p = this.pending.get(id);
+    if (!p) return false;
+    this.settle(p);
+    p.resolve(payload);
+    return true;
+  }
+  /** Agent declined/failed a request. */
+  fail(id, reason) {
+    const p = this.pending.get(id);
+    if (!p) return false;
+    this.settle(p);
+    p.reject(new AssistError("agent-error", reason));
+    return true;
+  }
+  /** Reject every pending request for a session (called on close). */
+  cancelForSession(sessionId) {
+    for (const p of [...this.pending.values()]) {
+      if (p.sessionId === sessionId) {
+        this.settle(p);
+        p.reject(new AssistError("cancelled"));
+      }
+    }
+  }
+  /** Requests still open for a session — drained by `mastermind assist` on (re)connect. */
+  pendingFor(sessionId) {
+    return [...this.pending.values()].filter((p) => p.sessionId === sessionId).map((p) => ({ id: p.id, ...p.request }));
+  }
+  settle(p) {
+    clearTimeout(p.timer);
+    this.pending.delete(p.id);
+    this.sessions.get(p.sessionId)?.pendingAssist.delete(p.id);
+  }
+};
+
+// src/server/translate/cache.ts
+import path6 from "path";
+import fs8 from "fs/promises";
+function cacheFile(realPath, targetLang) {
+  const safeLang = targetLang.replace(/[^a-zA-Z0-9_-]/g, "_") || "x";
+  return path6.join(path6.dirname(realPath), ".mastermind", "translations", `${path6.basename(realPath)}.${safeLang}.json`);
+}
+async function loadCache(realPath, targetLang) {
+  try {
+    const raw = await fs8.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 fs8.mkdir(path6.dirname(file), { recursive: true });
+    const merged = { ...await loadCache(realPath, targetLang), ...entries };
+    await fs8.writeFile(file, JSON.stringify(merged));
+  } catch {
+  }
+}
+
+// src/server/translate/index.ts
+async function translateBlocks(session, blocks, sourceLang, targetLang, assist) {
+  if (blocks.length === 0) return { results: [] };
+  const cache = await loadCache(session.path, targetLang);
+  const results = [];
+  const misses = [];
+  for (const block of blocks) {
+    const hit = cache[block.hash];
+    if (hit !== void 0 && validateTranslatedBlock(block.text, hit)) {
+      results.push({ hash: block.hash, text: hit, cached: true });
+    } else {
+      misses.push(block);
+    }
+  }
+  if (misses.length === 0) return { results };
+  const fresh = {};
+  let error;
+  try {
+    const payload = await assist.enqueue(session, { kind: "translate", sourceLang, targetLang, blocks: misses });
+    const byHash = new Map(payload.kind === "translate" ? payload.blocks.map((b) => [b.hash, b.text]) : []);
+    for (const block of misses) {
+      const text = byHash.get(block.hash);
+      if (text === void 0) results.push({ hash: block.hash, error: "provider", cached: false });
+      else if (!validateTranslatedBlock(block.text, text)) results.push({ hash: block.hash, error: "structure", cached: false });
+      else {
+        results.push({ hash: block.hash, text, cached: false });
+        fresh[block.hash] = text;
+      }
+    }
+  } catch (err) {
+    error = err instanceof AssistError ? err.code : "provider";
+    for (const block of misses) results.push({ hash: block.hash, error, cached: false });
+  }
+  await saveCache(session.path, targetLang, fresh);
+  return { results, error };
+}
+
+// src/server/watch.ts
+import { watch } from "chokidar";
+import fs9 from "fs/promises";
+function startWatcher(session, registry) {
+  const watcher = watch(session.path, {
+    ignoreInitial: true,
+    awaitWriteFinish: { stabilityThreshold: 150, pollInterval: 50 }
+  });
+  const onContent = async () => {
+    try {
+      const [content, st] = await Promise.all([fs9.readFile(session.path, "utf8"), fs9.stat(session.path)]);
+      if (sha256hex(content) === session.lastSelfWriteHash) return;
+      registry.broadcast(session.id, "file-changed", { mtimeMs: st.mtimeMs });
+    } catch {
+    }
+  };
+  watcher.on("change", () => void onContent());
+  watcher.on("add", () => void onContent());
+  watcher.on("unlink", () => {
+    setTimeout(() => {
+      void fs9.access(session.path).catch(() => {
+        log(`session ${session.id}: file deleted on disk`);
+        registry.broadcast(session.id, "file-deleted", {});
+      });
+    }, 500);
+  });
+  watcher.on("error", (err) => log(`watcher error for ${session.path}:`, err));
+  session.watcher = watcher;
+}
+async function stopWatcher(session) {
+  await session.watcher?.close().catch(() => {
+  });
+  session.watcher = null;
+}
+
+// src/shared/edits.ts
+function applyTextEdits(text, edits) {
+  const sorted = [...edits].sort((a, b) => b.from - a.from);
+  let out = text;
+  let lastFrom = Infinity;
+  for (const e of sorted) {
+    if (e.from > e.to) throw new Error(`invalid edit range ${e.from}..${e.to}`);
+    if (e.to > lastFrom) throw new Error("overlapping edits");
+    out = out.slice(0, e.from) + e.insert + out.slice(e.to);
+    lastFrom = e.from;
+  }
+  return out;
+}
+
+// src/shared/critic/resolve.ts
+function rejectEdit(text, span) {
+  switch (span.kind) {
+    case "ins":
+      return { from: span.start, to: span.end, insert: "" };
+    case "del":
+      return { from: span.start, to: span.end, insert: text.slice(span.innerStart, span.innerEnd) };
+    case "sub":
+      return { from: span.start, to: span.end, insert: text.slice(span.oldStart, span.oldEnd) };
+    case "highlight":
+      return { from: span.start, to: span.end, insert: text.slice(span.innerStart, span.innerEnd) };
+    case "comment":
+      return { from: span.start, to: span.end, insert: "" };
+  }
+}
+
+// src/shared/critic/suggest.ts
+function validateSuggestion(markup, original) {
+  const spans = scan(markup, codeRanges(markup));
+  if (spans.length === 0) return { ok: false, spans, reason: "no-marks" };
+  if (!spans.every((s) => s.kind === "ins" || s.kind === "del" || s.kind === "sub")) {
+    return { ok: false, spans, reason: "wrong-kind" };
+  }
+  const rejected = applyTextEdits(
+    markup,
+    spans.map((s) => rejectEdit(markup, s))
+  );
+  if (rejected !== original) return { ok: false, spans, reason: "rewrites-original" };
+  return { ok: true, spans };
+}
+
+// src/server/static.ts
+import fs10 from "fs/promises";
+import path7 from "path";
+var MIME = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "text/javascript; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".map": "application/json",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".ico": "image/x-icon",
+  ".woff2": "font/woff2",
+  ".woff": "font/woff",
+  ".ttf": "font/ttf",
+  ".txt": "text/plain; charset=utf-8",
+  ".md": "text/markdown; charset=utf-8"
+};
+async function serveFile(root, relPath, cache = "no-cache") {
+  const abs = path7.normalize(path7.join(root, relPath));
+  if (abs !== root && !abs.startsWith(root + path7.sep)) return null;
+  let data;
+  try {
+    data = await fs10.readFile(abs);
+  } catch {
+    return null;
+  }
+  const headers = {
+    "content-type": MIME[path7.extname(abs).toLowerCase()] ?? "application/octet-stream",
+    "cache-control": cache === "immutable" ? "public, max-age=31536000, immutable" : cache === "no-store" ? "no-store" : "no-cache"
+  };
+  return new Response(new Uint8Array(data), { status: 200, headers });
+}
+
+// src/server/app.ts
+var LOCAL_HOST_RE = /^(127\.0\.0\.1|localhost|\[::1\])(:\d+)?$/;
+var LOCAL_ORIGIN_RE = /^https?:\/\/(127\.0\.0\.1|localhost|\[::1\])(:\d+)?$/;
+var WORKSPACE_DENYLIST = /* @__PURE__ */ new Set(["node_modules", ".git", ".mastermind"]);
+function isHiddenEntry(name) {
+  return name.startsWith(".") || WORKSPACE_DENYLIST.has(name);
+}
+var fileMetaCache = /* @__PURE__ */ new Map();
+async function workspaceFileMeta(rel, real, mtimeMs) {
+  const key = `${real}\0${mtimeMs}`;
+  const hit = fileMetaCache.get(key);
+  if (hit) return hit;
+  let counts = null;
+  if (real.toLowerCase().endsWith(".md")) {
+    try {
+      const body = stripSummary(await fs11.readFile(real, "utf8"));
+      counts = reviewCounts(group(scan(body, codeRanges(body)), body));
+    } catch {
+      counts = null;
+    }
+  }
+  const meta = { rel, counts, mtimeMs };
+  fileMetaCache.set(key, meta);
+  return meta;
+}
+function createApp(deps) {
+  const { registry, workspaces, assist } = deps;
+  const app = new Hono();
+  app.use("*", async (c, next) => {
+    deps.touch();
+    const host = c.req.header("host") ?? "";
+    if (!LOCAL_HOST_RE.test(host)) return c.text("forbidden host", 403);
+    const origin = c.req.header("origin");
+    if (origin && c.req.method !== "GET" && !LOCAL_ORIGIN_RE.test(origin)) {
+      return c.text("forbidden origin", 403);
+    }
+    await next();
+  });
+  app.get("/api/health", (c) => {
+    const body = {
+      ok: true,
+      pid: process.pid,
+      version: deps.version,
+      startedAt: deps.startedAt
+    };
+    return c.json(body);
+  });
+  app.post("/api/admin/shutdown", (c) => {
+    setTimeout(() => deps.requestShutdown("admin request"), 20);
+    return c.body(null, 202);
+  });
+  app.get("/api/config", (c) => c.json(redactConfig(readConfig())));
+  app.put("/api/config", async (c) => {
+    let patch;
+    try {
+      patch = await c.req.json();
+    } catch {
+      return c.json({ error: "invalid JSON body" }, 400);
+    }
+    const next = updateConfig(patch);
+    for (const session of registry.all()) {
+      registry.broadcast(session.id, "config-changed", {});
+    }
+    return c.json(redactConfig(next));
+  });
+  app.get("/api/themes", async (c) => c.json(await scanThemes()));
+  app.get("/api/browsers", (c) => c.json(detectBrowsers()));
+  app.post("/api/translate", async (c) => {
+    let body;
+    try {
+      body = await c.req.json();
+    } catch {
+      return c.json({ error: "invalid JSON body" }, 400);
+    }
+    if (!body.sessionId || !body.targetLang || !Array.isArray(body.blocks)) {
+      return c.json({ error: "sessionId, targetLang, blocks required" }, 400);
+    }
+    const session = registry.get(body.sessionId);
+    if (!session) return c.json({ error: "session not found" }, 404);
+    try {
+      const { results, error } = await translateBlocks(
+        session,
+        body.blocks.slice(0, 50),
+        body.sourceLang ?? "auto-detected source language",
+        body.targetLang,
+        assist
+      );
+      return c.json({ results, error });
+    } catch (err) {
+      const code = err instanceof AssistError ? err.code : "provider";
+      return c.json({ error: code }, 502);
+    }
+  });
+  app.post("/api/sessions", async (c) => {
+    let body;
+    try {
+      body = await c.req.json();
+    } catch {
+      return c.json({ error: "invalid JSON body" }, 400);
+    }
+    let real;
+    let isDraft = false;
+    if (body.draft) {
+      const dir = body.dir ? path8.resolve(body.dir) : os3.homedir();
+      const dirStat = await fs11.stat(dir).catch(() => null);
+      if (!dirStat?.isDirectory()) return c.json({ error: `not a directory: ${dir}` }, 400);
+      let name = "untitled.md";
+      for (let n = 2; ; n++) {
+        try {
+          await fs11.writeFile(path8.join(dir, name), "", { flag: "wx" });
+          break;
+        } catch {
+          name = `untitled-${n}.md`;
+        }
+      }
+      real = await fs11.realpath(path8.join(dir, name));
+      isDraft = true;
+    } else {
+      if (!body.path) return c.json({ error: "path is required" }, 400);
+      try {
+        real = await fs11.realpath(path8.resolve(body.path));
+      } catch {
+        return c.json({ error: `file not found: ${body.path}` }, 404);
+      }
+      const st = await fs11.stat(real);
+      if (!st.isFile()) return c.json({ error: `not a file: ${real}` }, 400);
+    }
+    const { session, created } = registry.open(real, { isDraft });
+    const resp = {
+      sessionId: session.id,
+      url: `http://${c.req.header("host")}/d/${session.id}`,
+      created,
+      isDraft: session.isDraft
+    };
+    return c.json(resp);
+  });
+  app.get("/api/sessions/:id", async (c) => {
+    const session = registry.get(c.req.param("id"));
+    if (!session) return c.json({ error: "session not found" }, 404);
+    let mtimeMs = 0;
+    try {
+      mtimeMs = (await fs11.stat(session.path)).mtimeMs;
+    } catch {
+    }
+    const meta = {
+      sessionId: session.id,
+      path: session.path,
+      displayName: session.displayName,
+      isDraft: session.isDraft,
+      mtimeMs,
+      agentWaiting: session.cliConns.size > 0,
+      assistAvailable: registry.hasAssistListener(session)
+    };
+    return c.json(meta);
+  });
+  app.get("/api/sessions/:id/file", async (c) => {
+    const session = registry.get(c.req.param("id"));
+    if (!session) return c.json({ error: "session not found" }, 404);
+    try {
+      const [content, st] = await Promise.all([fs11.readFile(session.path, "utf8"), fs11.stat(session.path)]);
+      const body = { content, mtimeMs: st.mtimeMs };
+      return c.json(body);
+    } catch {
+      return c.json({ error: "file unreadable (deleted?)" }, 410);
+    }
+  });
+  app.put("/api/sessions/:id/file", async (c) => {
+    const session = registry.get(c.req.param("id"));
+    if (!session) return c.json({ error: "session not found" }, 404);
+    let body;
+    try {
+      body = await c.req.json();
+    } catch {
+      return c.json({ error: "invalid JSON body" }, 400);
+    }
+    if (typeof body.content !== "string") return c.json({ error: "content is required" }, 400);
+    const processed = await processFeedbackLanguage(body.content);
+    const result = await writeSessionFile(session, processed, body.baseMtimeMs);
+    if (!result.ok) {
+      return c.json({ error: "file changed on disk", currentMtimeMs: result.currentMtimeMs }, 409);
+    }
+    workspaces.notifyForPath(session.path, "file-badge-changed");
+    return c.json({ mtimeMs: result.mtimeMs, content: processed !== body.content ? processed : void 0 });
+  });
+  app.post("/api/sessions/:id/rename", async (c) => {
+    const session = registry.get(c.req.param("id"));
+    if (!session) return c.json({ error: "session not found" }, 404);
+    let body;
+    try {
+      body = await c.req.json();
+    } catch {
+      return c.json({ error: "invalid JSON body" }, 400);
+    }
+    let name = path8.basename((body.filename ?? "").trim());
+    if (!name || name === ".md" || name.startsWith(".")) return c.json({ error: "invalid filename" }, 400);
+    if (!name.endsWith(".md")) name += ".md";
+    const target = path8.join(path8.dirname(session.path), name);
+    const exists = await fs11.stat(target).then(
+      () => true,
+      () => false
+    );
+    if (exists) return c.json({ error: `${name} already exists`, code: "exists" }, 409);
+    await stopWatcher(session);
+    await fs11.rename(session.path, target);
+    const real = await fs11.realpath(target);
+    registry.rekey(session, real);
+    session.isDraft = false;
+    startWatcher(session, registry);
+    log(`session ${session.id}: renamed to ${real}`);
+    return c.json({ path: real, displayName: session.displayName });
+  });
+  app.post("/api/sessions/:id/handback", async (c) => {
+    const session = registry.get(c.req.param("id"));
+    if (!session) return c.json({ error: "session not found" }, 404);
+    let body;
+    try {
+      body = await c.req.json();
+    } catch {
+      return c.json({ error: "invalid JSON body" }, 400);
+    }
+    if (typeof body.content !== "string") return c.json({ error: "content is required" }, 400);
+    const note = typeof body.note === "string" ? body.note : void 0;
+    const result = await performHandback(session, body.content, body.baseMtimeMs, note);
+    if (!result.ok) {
+      return c.json({ error: "file changed on disk", currentMtimeMs: result.currentMtimeMs }, 409);
+    }
+    log(`session ${session.id}: hand back \u2014 ${result.summaryLine}`);
+    registry.broadcast(session.id, "handback", {
+      summaryLine: result.summaryLine,
+      counts: result.counts,
+      mtimeMs: result.mtimeMs
+    });
+    workspaces.notifyForPath(session.path, "file-badge-changed");
+    return c.json({
+      mtimeMs: result.mtimeMs,
+      counts: result.counts,
+      summaryLine: result.summaryLine
+    });
+  });
+  app.post("/api/workspaces", async (c) => {
+    let body;
+    try {
+      body = await c.req.json();
+    } catch {
+      return c.json({ error: "invalid JSON body" }, 400);
+    }
+    if (!body.root) return c.json({ error: "root is required" }, 400);
+    let root;
+    try {
+      root = await fs11.realpath(path8.resolve(body.root));
+    } catch {
+      return c.json({ error: `directory not found: ${body.root}` }, 404);
+    }
+    if (!(await fs11.stat(root)).isDirectory()) return c.json({ error: `not a directory: ${root}` }, 400);
+    const ws = workspaces.open(root);
+    const resp = {
+      workspaceId: ws.id,
+      url: `http://${c.req.header("host")}/w/${ws.id}`,
+      root: ws.root,
+      displayName: ws.displayName
+    };
+    return c.json(resp);
+  });
+  app.get("/api/workspaces/:wid", (c) => {
+    const ws = workspaces.get(c.req.param("wid"));
+    if (!ws) return c.json({ error: "workspace not found" }, 404);
+    const meta = { workspaceId: ws.id, root: ws.root, displayName: ws.displayName };
+    return c.json(meta);
+  });
+  app.get("/api/workspaces/:wid/tree", async (c) => {
+    const ws = workspaces.get(c.req.param("wid"));
+    if (!ws) return c.json({ error: "workspace not found" }, 404);
+    const dir = c.req.query("dir") ?? "";
+    const real = await resolveWithin(ws.root, dir);
+    if (!real) return c.json({ error: "forbidden path" }, 403);
+    let dirents;
+    try {
+      dirents = await fs11.readdir(real, { withFileTypes: true });
+    } catch {
+      return c.json({ error: "not a directory" }, 404);
+    }
+    const entries = [];
+    for (const d of dirents) {
+      if (isHiddenEntry(d.name)) continue;
+      const rel = dir ? `${dir}/${d.name}` : d.name;
+      let isDir = d.isDirectory();
+      if (d.isSymbolicLink()) {
+        const target = await resolveWithin(ws.root, rel);
+        if (!target) continue;
+        try {
+          isDir = (await fs11.stat(target)).isDirectory();
+        } catch {
+          continue;
+        }
+      }
+      entries.push({ name: d.name, rel, isDir, isMarkdown: !isDir && d.name.toLowerCase().endsWith(".md") });
+    }
+    entries.sort((a, b) => a.isDir === b.isDir ? a.name.localeCompare(b.name) : a.isDir ? -1 : 1);
+    const resp = { dir, entries };
+    return c.json(resp);
+  });
+  app.get("/api/workspaces/:wid/file-meta", async (c) => {
+    const ws = workspaces.get(c.req.param("wid"));
+    if (!ws) return c.json({ error: "workspace not found" }, 404);
+    const rel = c.req.query("path") ?? "";
+    const real = await resolveWithin(ws.root, rel);
+    if (!real) return c.json({ error: "forbidden path" }, 403);
+    let st;
+    try {
+      st = await fs11.stat(real);
+    } catch {
+      return c.json({ error: "unreadable" }, 410);
+    }
+    if (!st.isFile()) return c.json({ error: "not a file" }, 400);
+    return c.json(await workspaceFileMeta(rel, real, st.mtimeMs));
+  });
+  app.get("/api/workspaces/:wid/sessions", (c) => {
+    const ws = workspaces.get(c.req.param("wid"));
+    if (!ws) return c.json({ error: "workspace not found" }, 404);
+    const out = [];
+    for (const s of registry.all()) {
+      const rel = relWithin(ws.root, s.path);
+      if (rel === null) continue;
+      out.push({
+        rel,
+        sessionId: s.id,
+        agentWaiting: s.cliConns.size > 0,
+        assistAvailable: registry.hasAssistListener(s),
+        isDraft: s.isDraft
+      });
+    }
+    return c.json(out);
+  });
+  app.get("/api/workspaces/:wid/events", (c) => {
+    const wid = c.req.param("wid");
+    if (!workspaces.get(wid)) return c.json({ error: "workspace not found" }, 404);
+    return streamSSE(c, async (stream) => {
+      let open = true;
+      const conn = {
+        role: "ui",
+        send: async (event, data) => {
+          await stream.writeSSE({ event, data: JSON.stringify(data) });
+        },
+        close: () => {
+          open = false;
+          void stream.close();
+        }
+      };
+      stream.onAbort(() => {
+        open = false;
+        workspaces.detach(wid, conn);
+      });
+      if (!workspaces.attach(wid, conn)) {
+        open = false;
+        return;
+      }
+      log(`sse ui connected to workspace ${wid}`);
+      while (open) {
+        await stream.sleep(SSE_PING_INTERVAL_MS);
+        if (!open) break;
+        try {
+          await stream.writeSSE({ event: "ping", data: "{}" });
+        } catch {
+          open = false;
+        }
+      }
+      workspaces.detach(wid, conn);
+    });
+  });
+  const suggestions = /* @__PURE__ */ new Map();
+  app.post("/api/assist", async (c) => {
+    let body;
+    try {
+      body = await c.req.json();
+    } catch {
+      return c.json({ error: "invalid JSON body" }, 400);
+    }
+    if (!body.sessionId || body.kind !== "suggest" || typeof body.selection !== "string") {
+      return c.json({ error: "sessionId, kind:suggest, selection required" }, 400);
+    }
+    const session = registry.get(body.sessionId);
+    if (!session) return c.json({ error: "session not found" }, 404);
+    if (!assist.hasListener(session)) return c.json({ error: "no-agent" }, 409);
+    const scope = body.scope === "section" || body.scope === "document" ? body.scope : "selection";
+    const selection = body.selection;
+    const { id, result } = assist.enqueueWithId(session, { kind: "suggest", scope, selection, context: body.context });
+    result.then((payload) => {
+      const ok = payload.kind === "suggest" && validateSuggestion(payload.markup, selection).ok;
+      if (ok && payload.kind === "suggest") suggestions.set(id, { markup: payload.markup });
+      registry.broadcast(session.id, "assist-result", { id, kind: "suggest", ok }, ["ui"]);
+    }).catch((err) => {
+      log(`assist suggest ${id.slice(0, 8)} failed: ${err instanceof AssistError ? err.code : "error"}`);
+      registry.broadcast(session.id, "assist-result", { id, kind: "suggest", ok: false }, ["ui"]);
+    });
+    return c.json({ requestId: id });
+  });
+  app.get("/api/assist/:id/suggestion", (c) => {
+    const s = suggestions.get(c.req.param("id"));
+    if (!s) return c.json({ error: "not found" }, 404);
+    suggestions.delete(c.req.param("id"));
+    return c.json({ markup: s.markup });
+  });
+  app.get("/api/assist/pending", (c) => {
+    const sessionId = c.req.query("sessionId");
+    const session = sessionId ? registry.get(sessionId) : void 0;
+    if (!session) return c.json({ error: "session not found" }, 404);
+    return c.json({ requests: assist.pendingFor(session.id) });
+  });
+  app.post("/api/assist/:id/result", async (c) => {
+    let payload;
+    try {
+      payload = await c.req.json();
+    } catch {
+      return c.json({ error: "invalid JSON body" }, 400);
+    }
+    return assist.resolve(c.req.param("id"), payload) ? c.body(null, 204) : c.json({ error: "unknown or expired" }, 404);
+  });
+  app.post("/api/assist/:id/error", async (c) => {
+    let body;
+    try {
+      body = await c.req.json();
+    } catch {
+      body = {};
+    }
+    return assist.fail(c.req.param("id"), body.reason ?? "declined") ? c.body(null, 204) : c.json({ error: "unknown or expired" }, 404);
+  });
+  app.get("/api/sessions/:id/events", (c) => {
+    const sessionId = c.req.param("id");
+    const role = c.req.query("role") === "cli" ? "cli" : "ui";
+    const assistCapable = role === "cli" && c.req.query("assist") === "1";
+    if (!registry.get(sessionId)) return c.json({ error: "session not found" }, 404);
+    return streamSSE(c, async (stream) => {
+      let open = true;
+      const conn = {
+        role,
+        assistCapable,
+        send: async (event, data) => {
+          await stream.writeSSE({ event, data: JSON.stringify(data) });
+        },
+        close: () => {
+          open = false;
+          void stream.close();
+        }
+      };
+      stream.onAbort(() => {
+        open = false;
+        registry.detach(sessionId, conn);
+      });
+      if (!registry.attach(sessionId, conn)) {
+        open = false;
+        return;
+      }
+      log(`sse ${role} connected to session ${sessionId}`);
+      while (open) {
+        await stream.sleep(SSE_PING_INTERVAL_MS);
+        if (!open) break;
+        try {
+          await stream.writeSSE({ event: "ping", data: "{}" });
+        } catch {
+          open = false;
+        }
+      }
+      registry.detach(sessionId, conn);
+    });
+  });
+  app.get("/themes/*", async (c) => {
+    const rel = c.req.path.replace(/^\/themes\//, "");
+    const res = await serveFile(themesDir, rel, "no-cache");
+    return res ?? c.notFound();
+  });
+  app.get("/assets/*", async (c) => {
+    const rel = c.req.path.replace(/^\//, "");
+    const res = await serveFile(uiDir, rel, "immutable");
+    return res ?? c.notFound();
+  });
+  app.get("*", async (c) => {
+    if (c.req.path.startsWith("/api/")) return c.notFound();
+    const rel = c.req.path.replace(/^\//, "");
+    if (rel && !rel.includes("..") && path8.extname(rel)) {
+      const res = await serveFile(uiDir, rel, "no-cache");
+      if (res) return res;
+      return c.notFound();
+    }
+    const index = await serveFile(uiDir, "index.html", "no-store");
+    return index ?? c.text("mastermind: UI not built \u2014 run npm run build", 500);
+  });
+  return app;
+}
+
+// src/server/sessions.ts
+import path9 from "path";
+import fs12 from "fs/promises";
+import crypto3 from "crypto";
+async function pruneStaleHistory(realPath) {
+  const dir = path9.dirname(realPath);
+  const mastermind = path9.join(dir, ".mastermind");
+  try {
+    await fs12.rm(path9.join(mastermind, "history", path9.basename(realPath)), { recursive: true, force: true });
+    await fs12.rmdir(path9.join(mastermind, "history")).catch(() => {
+    });
+    await fs12.rmdir(mastermind).catch(() => {
+    });
+  } catch {
+  }
+}
+var SessionRegistry = class {
+  byPath = /* @__PURE__ */ new Map();
+  byId = /* @__PURE__ */ new Map();
+  graceMs;
+  neverOpenedMs;
+  constructor(timers) {
+    this.graceMs = timers?.graceMs ?? SESSION_CLOSE_GRACE_MS;
+    this.neverOpenedMs = timers?.neverOpenedMs ?? SESSION_NEVER_OPENED_MS;
+  }
+  /** Called whenever a session is created or destroyed (idle-exit tracking). */
+  onChange = null;
+  /** Hook for setup when a session opens (start file watcher). */
+  onSessionOpened = null;
+  /** Hook for cleanup when a session closes (stop file watcher). */
+  onSessionClosed = null;
+  /** Hook when a session's tree-visible state changes (agent attach/detach) — lets workspaces refresh badges. */
+  onSessionActivity = null;
+  open(realPath, opts = {}) {
+    const existing = this.byPath.get(realPath);
+    if (existing) return { session: existing, created: false };
+    const session = {
+      id: crypto3.randomUUID(),
+      path: realPath,
+      displayName: path9.basename(realPath),
+      isDraft: opts.isDraft ?? false,
+      createdAt: Date.now(),
+      lastSelfWriteHash: null,
+      watcher: null,
+      pendingAssist: /* @__PURE__ */ new Set(),
+      uiConns: /* @__PURE__ */ new Set(),
+      cliConns: /* @__PURE__ */ new Set(),
+      everConnected: false,
+      graceTimer: null,
+      graceArmedAt: 0,
+      graceRearmed: false,
+      neverOpenedTimer: null,
+      closed: false
+    };
+    session.neverOpenedTimer = setTimeout(() => {
+      if (!session.everConnected && !session.closed) {
+        log(`session ${session.id} (${session.displayName}): no browser connected within timeout`);
+        this.close(session.id, "never-opened");
+      }
+    }, this.neverOpenedMs);
+    this.byPath.set(realPath, session);
+    this.byId.set(session.id, session);
+    if (!session.isDraft) void pruneStaleHistory(realPath);
+    log(`session ${session.id} opened for ${realPath}`);
+    this.onSessionOpened?.(session);
+    this.onChange?.();
+    return { session, created: true };
+  }
+  get(id) {
+    return this.byId.get(id);
+  }
+  getByPath(realPath) {
+    return this.byPath.get(realPath);
+  }
+  count() {
+    return this.byId.size;
+  }
+  all() {
+    return [...this.byId.values()];
+  }
+  /** Re-key a session after rename-on-first-save. */
+  rekey(session, newRealPath) {
+    this.byPath.delete(session.path);
+    const mutable = session;
+    mutable.path = newRealPath;
+    mutable.displayName = path9.basename(newRealPath);
+    this.byPath.set(newRealPath, session);
+  }
+  attach(sessionId, conn) {
+    const session = this.byId.get(sessionId);
+    if (!session || session.closed) return false;
+    if (conn.role === "ui") {
+      session.uiConns.add(conn);
+      session.everConnected = true;
+      if (session.neverOpenedTimer) {
+        clearTimeout(session.neverOpenedTimer);
+        session.neverOpenedTimer = null;
+      }
+      this.disarmGrace(session);
+    } else {
+      session.cliConns.add(conn);
+      this.broadcast(sessionId, "waiters-changed", { count: session.cliConns.size }, ["ui"]);
+      if (conn.assistCapable) {
+        this.broadcast(sessionId, "assist-availability", { available: true }, ["ui"]);
+      }
+      this.onSessionActivity?.(session);
+    }
+    return true;
+  }
+  /** Any assist-capable cli conn currently listening on this session. */
+  hasAssistListener(session) {
+    for (const c of session.cliConns) if (c.assistCapable) return true;
+    return false;
+  }
+  detach(sessionId, conn) {
+    const session = this.byId.get(sessionId);
+    if (!session) return;
+    const hadCli = session.cliConns.has(conn);
+    session.uiConns.delete(conn);
+    session.cliConns.delete(conn);
+    if (hadCli && !session.closed) {
+      this.broadcast(sessionId, "waiters-changed", { count: session.cliConns.size }, ["ui"]);
+      if (conn.assistCapable) {
+        this.broadcast(sessionId, "assist-availability", { available: this.hasAssistListener(session) }, ["ui"]);
+      }
+      this.onSessionActivity?.(session);
+    }
+    if (conn.role === "ui" && session.uiConns.size === 0 && session.everConnected && !session.closed) {
+      this.armGrace(session);
+    }
+  }
+  broadcast(sessionId, event, data, roles = ["ui", "cli"]) {
+    const session = this.byId.get(sessionId);
+    if (!session) return;
+    const targets = [];
+    if (roles.includes("ui")) targets.push(...session.uiConns);
+    if (roles.includes("cli")) targets.push(...session.cliConns);
+    for (const conn of targets) {
+      conn.send(event, data).catch(() => {
+        this.detach(sessionId, conn);
+      });
+    }
+  }
+  close(sessionId, reason) {
+    const session = this.byId.get(sessionId);
+    if (!session || session.closed) return;
+    session.closed = true;
+    if (session.graceTimer) clearTimeout(session.graceTimer);
+    if (session.neverOpenedTimer) clearTimeout(session.neverOpenedTimer);
+    this.broadcast(sessionId, "session-closed", { reason });
+    for (const conn of [...session.uiConns, ...session.cliConns]) {
+      setTimeout(() => conn.close(), 50);
+    }
+    session.uiConns.clear();
+    session.cliConns.clear();
+    this.byPath.delete(session.path);
+    this.byId.delete(sessionId);
+    log(`session ${sessionId} closed (${reason})`);
+    this.onSessionClosed?.(session, reason);
+    this.onChange?.();
+  }
+  closeAll(reason) {
+    for (const id of [...this.byId.keys()]) this.close(id, reason);
+  }
+  armGrace(session) {
+    this.disarmGrace(session);
+    session.graceArmedAt = Date.now();
+    session.graceRearmed = false;
+    session.graceTimer = setTimeout(() => this.graceFired(session), this.graceMs);
+  }
+  disarmGrace(session) {
+    if (session.graceTimer) {
+      clearTimeout(session.graceTimer);
+      session.graceTimer = null;
+    }
+  }
+  graceFired(session) {
+    session.graceTimer = null;
+    if (session.closed || session.uiConns.size > 0) return;
+    const elapsed = Date.now() - session.graceArmedAt;
+    if (elapsed > this.graceMs * 1.5 && !session.graceRearmed) {
+      session.graceRearmed = true;
+      session.graceArmedAt = Date.now();
+      session.graceTimer = setTimeout(() => this.graceFired(session), this.graceMs);
+      return;
+    }
+    this.close(session.id, "tabs-closed");
+  }
+};
+
+// src/server/workspaces.ts
+import crypto4 from "crypto";
+import path10 from "path";
+var WorkspaceRegistry = class {
+  byRoot = /* @__PURE__ */ new Map();
+  byId = /* @__PURE__ */ new Map();
+  /** Open (or reuse by realpath) a workspace for an already-realpath'd root. */
+  open(rootReal) {
+    const existing = this.byRoot.get(rootReal);
+    if (existing) return existing;
+    const ws = {
+      id: crypto4.randomUUID(),
+      root: rootReal,
+      displayName: path10.basename(rootReal) || rootReal,
+      createdAt: Date.now(),
+      uiConns: /* @__PURE__ */ new Set()
+    };
+    this.byRoot.set(rootReal, ws);
+    this.byId.set(ws.id, ws);
+    log(`workspace ${ws.id} opened for ${rootReal}`);
+    return ws;
+  }
+  get(id) {
+    return this.byId.get(id);
+  }
+  /** Total live tree connections across all workspaces — gates daemon idle-exit. */
+  activeUiConnCount() {
+    let n = 0;
+    for (const ws of this.byId.values()) n += ws.uiConns.size;
+    return n;
+  }
+  attach(workspaceId, conn) {
+    const ws = this.byId.get(workspaceId);
+    if (!ws) return false;
+    ws.uiConns.add(conn);
+    return true;
+  }
+  detach(workspaceId, conn) {
+    this.byId.get(workspaceId)?.uiConns.delete(conn);
+  }
+  broadcast(workspaceId, event, data) {
+    const ws = this.byId.get(workspaceId);
+    if (!ws) return;
+    for (const conn of ws.uiConns) {
+      conn.send(event, data).catch(() => this.detach(workspaceId, conn));
+    }
+  }
+  /**
+   * Tell every workspace that contains `realPath` that something about that file
+   * changed (mark counts, open/agent state). The relative path is injected into
+   * the event data so the tree can target the right row. Skips workspaces with
+   * no live tree connection.
+   */
+  notifyForPath(realPath, event, dataBase = {}) {
+    for (const ws of this.byId.values()) {
+      if (ws.uiConns.size === 0) continue;
+      const rel = relWithin(ws.root, realPath);
+      if (rel === null) continue;
+      this.broadcast(ws.id, event, { ...dataBase, rel });
+    }
+  }
+};
+
+// src/server/statefile.ts
+import fs13 from "fs";
+import path11 from "path";
+function readServerState() {
+  try {
+    const raw = fs13.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 writeServerState(state) {
+  const dir = ensureConfigDir();
+  const tmp = path11.join(dir, `.server.json.${process.pid}.tmp`);
+  fs13.writeFileSync(tmp, JSON.stringify(state, null, 2));
+  fs13.renameSync(tmp, stateFilePath());
+}
+function clearServerState(onlyIfPid) {
+  if (onlyIfPid !== void 0) {
+    const current = readServerState();
+    if (current && current.pid !== onlyIfPid) return;
+  }
+  try {
+    fs13.unlinkSync(stateFilePath());
+  } catch {
+  }
+}
+
+// src/server/index.ts
+function listenOnce(app, port) {
+  return new Promise((resolve, reject) => {
+    const server = serve({ fetch: app.fetch, port, hostname: "127.0.0.1" }, () => resolve(server));
+    server.on("error", reject);
+  });
+}
+async function listenWithScan(app, base, attempts) {
+  let lastErr;
+  for (let port = base; port < base + attempts; port++) {
+    try {
+      const server = await listenOnce(app, port);
+      return { server, port };
+    } catch (err) {
+      lastErr = err;
+      if (err.code === "EADDRINUSE") continue;
+      throw err;
+    }
+  }
+  throw lastErr instanceof Error ? lastErr : new Error("no free port found");
+}
+async function isHealthyMastermind(port) {
+  try {
+    const res = await fetch(`http://127.0.0.1:${port}/api/health`, { signal: AbortSignal.timeout(1e3) });
+    if (!res.ok) return false;
+    const j = await res.json();
+    return j.ok === true && typeof j.pid === "number";
+  } catch {
+    return false;
+  }
+}
+async function main() {
+  const pinned = process.env.MASTERMIND_PINNED === "1";
+  const base = Number(process.env.MASTERMIND_PORT || "") || DEFAULT_PORT;
+  const startedAt = Date.now();
+  let lastActivity = Date.now();
+  const registry = new SessionRegistry({
+    graceMs: Number(process.env.MASTERMIND_GRACE_MS || "") || void 0,
+    neverOpenedMs: Number(process.env.MASTERMIND_NEVER_OPENED_MS || "") || void 0
+  });
+  const assist = new AssistRegistry(registry);
+  const workspaces = new WorkspaceRegistry();
+  registry.onChange = () => {
+    lastActivity = Date.now();
+  };
+  registry.onSessionActivity = (session) => workspaces.notifyForPath(session.path, "file-badge-changed");
+  registry.onSessionOpened = (session) => {
+    startWatcher(session, registry);
+    workspaces.notifyForPath(session.path, "file-badge-changed");
+  };
+  registry.onSessionClosed = (session) => {
+    assist.cancelForSession(session.id);
+    void stopWatcher(session);
+    workspaces.notifyForPath(session.path, "file-badge-changed");
+    if (session.isDraft) {
+      void fsp.stat(session.path).then((st) => st.size === 0 ? fsp.unlink(session.path) : void 0).catch(() => {
+      });
+    }
+  };
+  let shuttingDown = false;
+  let server = null;
+  const shutdown = (reason) => {
+    if (shuttingDown) return;
+    shuttingDown = true;
+    log(`shutting down (${reason})`);
+    registry.closeAll("shutdown");
+    clearServerState(process.pid);
+    server?.close();
+    setTimeout(() => process.exit(0), 500).unref();
+  };
+  const app = createApp({
+    registry,
+    workspaces,
+    assist,
+    version: package_default.version,
+    startedAt,
+    requestShutdown: shutdown,
+    touch: () => {
+      lastActivity = Date.now();
+    }
+  });
+  const bound = await listenWithScan(app, base, pinned ? 1 : PORT_SCAN_LIMIT);
+  server = bound.server;
+  const existing = readServerState();
+  if (existing && existing.pid !== process.pid && await isHealthyMastermind(existing.port)) {
+    log(`another daemon is already healthy on port ${existing.port} \u2014 exiting`);
+    server.close();
+    process.exit(0);
+  }
+  writeServerState({ port: bound.port, pid: process.pid, version: package_default.version, startedAt });
+  log(`mastermind v${package_default.version} listening on http://127.0.0.1:${bound.port} (pid ${process.pid})`);
+  process.on("SIGTERM", () => shutdown("SIGTERM"));
+  process.on("SIGINT", () => shutdown("SIGINT"));
+  setInterval(() => {
+    const idleFor = Date.now() - lastActivity;
+    if (registry.count() === 0 && workspaces.activeUiConnCount() === 0 && idleFor > DAEMON_IDLE_EXIT_MS) {
+      shutdown(`idle for ${Math.round(idleFor / 6e4)} min with no sessions`);
+    }
+  }, 6e4).unref();
+}
+main().catch((err) => {
+  log("fatal:", err);
+  process.exit(1);
+});
+//# sourceMappingURL=index.js.map