tandem-editor 0.1.0

package/dist/server/index.js

@@ -0,0 +1,4681 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/shared/constants.ts
+var DEFAULT_WS_PORT, DEFAULT_MCP_PORT, SUPPORTED_EXTENSIONS, MAX_FILE_SIZE, MAX_WS_PAYLOAD, IDLE_TIMEOUT, SESSION_MAX_AGE, INTERRUPTION_MODE_DEFAULT, CHARS_PER_PAGE, LARGE_FILE_PAGE_THRESHOLD, VERY_LARGE_FILE_PAGE_THRESHOLD, CTRL_ROOM, Y_MAP_ANNOTATIONS, Y_MAP_AWARENESS, Y_MAP_USER_AWARENESS, Y_MAP_CHAT, Y_MAP_DOCUMENT_META, Y_MAP_SAVED_AT_VERSION, NOTIFICATION_BUFFER_SIZE, TUTORIAL_ANNOTATION_PREFIX, CHANNEL_EVENT_BUFFER_SIZE, CHANNEL_EVENT_BUFFER_AGE_MS, CHANNEL_SSE_KEEPALIVE_MS;
+var init_constants = __esm({
+  "src/shared/constants.ts"() {
+    "use strict";
+    DEFAULT_WS_PORT = 3478;
+    DEFAULT_MCP_PORT = 3479;
+    SUPPORTED_EXTENSIONS = /* @__PURE__ */ new Set([".md", ".txt", ".html", ".htm", ".docx"]);
+    MAX_FILE_SIZE = 50 * 1024 * 1024;
+    MAX_WS_PAYLOAD = 10 * 1024 * 1024;
+    IDLE_TIMEOUT = 30 * 60 * 1e3;
+    SESSION_MAX_AGE = 30 * 24 * 60 * 60 * 1e3;
+    INTERRUPTION_MODE_DEFAULT = "all";
+    CHARS_PER_PAGE = 3e3;
+    LARGE_FILE_PAGE_THRESHOLD = 50;
+    VERY_LARGE_FILE_PAGE_THRESHOLD = 100;
+    CTRL_ROOM = "__tandem_ctrl__";
+    Y_MAP_ANNOTATIONS = "annotations";
+    Y_MAP_AWARENESS = "awareness";
+    Y_MAP_USER_AWARENESS = "userAwareness";
+    Y_MAP_CHAT = "chat";
+    Y_MAP_DOCUMENT_META = "documentMeta";
+    Y_MAP_SAVED_AT_VERSION = "savedAtVersion";
+    NOTIFICATION_BUFFER_SIZE = 50;
+    TUTORIAL_ANNOTATION_PREFIX = "tutorial-";
+    CHANNEL_EVENT_BUFFER_SIZE = 200;
+    CHANNEL_EVENT_BUFFER_AGE_MS = 6e4;
+    CHANNEL_SSE_KEEPALIVE_MS = 15e3;
+  }
+});
+
+// src/server/yjs/provider.ts
+import { Hocuspocus } from "@hocuspocus/server";
+import * as Y from "yjs";
+function setDocLifecycleCallbacks(swapped, unloaded) {
+  onDocSwapped = swapped;
+  onDocUnloaded = unloaded;
+}
+function setShouldKeepDocument(fn) {
+  shouldKeepDocument = fn;
+}
+function getDocument(name) {
+  return documents.get(name);
+}
+function getOrCreateDocument(name) {
+  let doc = documents.get(name);
+  if (!doc) {
+    doc = new Y.Doc();
+    documents.set(name, doc);
+  }
+  return doc;
+}
+function removeDocument(name) {
+  return documents.delete(name);
+}
+async function startHocuspocus(port) {
+  hocuspocusInstance = new Hocuspocus({
+    port,
+    address: "127.0.0.1",
+    quiet: true,
+    // stdout is the MCP wire — suppress the startup banner
+    async onConnect({ request, documentName }) {
+      const origin = request?.headers?.origin;
+      if (origin) {
+        const url = new URL(origin);
+        if (url.hostname !== "localhost" && url.hostname !== "127.0.0.1") {
+          console.error(`[Hocuspocus] Rejected connection from origin: ${origin}`);
+          throw new Error("Connection rejected: invalid origin");
+        }
+      }
+      console.error(`[Hocuspocus] Client connected to: ${documentName}`);
+    },
+    async onDisconnect({ documentName }) {
+      console.error(`[Hocuspocus] Client disconnected from: ${documentName}`);
+    },
+    async onLoadDocument({ document, documentName }) {
+      console.error(`[Hocuspocus] Loading document: ${documentName}`);
+      const existing = documents.get(documentName);
+      if (existing && existing !== document) {
+        const update = Y.encodeStateAsUpdate(existing);
+        Y.applyUpdate(document, update);
+        existing.destroy();
+        console.error(`[Hocuspocus] Merged pre-existing content into document: ${documentName}`);
+      }
+      documents.set(documentName, document);
+      onDocSwapped?.(documentName, document);
+      return document;
+    },
+    async afterUnloadDocument({ documentName }) {
+      if (shouldKeepDocument?.(documentName)) {
+        console.error(`[Hocuspocus] Kept document in map (MCP still tracking): ${documentName}`);
+        return;
+      }
+      if (documents.has(documentName)) {
+        onDocUnloaded?.(documentName);
+        documents.delete(documentName);
+        console.error(`[Hocuspocus] Unloaded document from map: ${documentName}`);
+      }
+    }
+  });
+  const internal = hocuspocusInstance.server?.httpServer;
+  if (internal) {
+    let onError;
+    await Promise.race([
+      hocuspocusInstance.listen().then((result) => {
+        internal.removeListener("error", onError);
+        return result;
+      }),
+      new Promise((_, reject) => {
+        onError = (err) => reject(err);
+        internal.once("error", onError);
+      })
+    ]);
+  } else {
+    console.error(
+      "[Tandem] Warning: could not access Hocuspocus internal httpServer \u2014 bind failures may not be caught. Hocuspocus internals may have changed."
+    );
+    await hocuspocusInstance.listen();
+  }
+  return hocuspocusInstance;
+}
+function getHocuspocus() {
+  return hocuspocusInstance;
+}
+var hocuspocusInstance, documents, shouldKeepDocument, onDocSwapped, onDocUnloaded;
+var init_provider = __esm({
+  "src/server/yjs/provider.ts"() {
+    "use strict";
+    hocuspocusInstance = null;
+    documents = /* @__PURE__ */ new Map();
+    shouldKeepDocument = null;
+    onDocSwapped = null;
+    onDocUnloaded = null;
+  }
+});
+
+// src/server/platform.ts
+import { execSync } from "child_process";
+import net from "net";
+import path from "path";
+import envPaths from "env-paths";
+function freePort(port) {
+  try {
+    if (process.platform === "win32") {
+      freePortWindows(port);
+    } else {
+      freePortUnix(port);
+    }
+  } catch {
+  }
+}
+async function waitForPort(port, timeoutMs = 5e3) {
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    if (await tryBind(port)) return;
+    await new Promise((r) => setTimeout(r, 200));
+  }
+  console.error(
+    `[Tandem] Warning: port ${port} still not available after ${timeoutMs}ms, proceeding anyway`
+  );
+}
+function tryBind(port) {
+  return new Promise((resolve, reject) => {
+    const srv = net.createServer();
+    srv.once("error", (err) => {
+      srv.close(() => {
+        if (err.code === "EADDRINUSE") {
+          resolve(false);
+        } else {
+          reject(err);
+        }
+      });
+    });
+    srv.listen(port, "127.0.0.1", () => {
+      srv.close(() => resolve(true));
+    });
+  });
+}
+function parseLsofPids(output) {
+  return output.trim().split("\n").map((line) => parseInt(line.trim(), 10)).filter((pid) => Number.isFinite(pid) && pid > 0);
+}
+function parseSsPid(output) {
+  const match = output.match(/pid=(\d+)/);
+  return match ? parseInt(match[1], 10) : null;
+}
+function freePortWindows(port) {
+  const out = execSync(`netstat -ano | findstr ":${port}.*LISTENING"`, {
+    encoding: "utf-8",
+    stdio: ["pipe", "pipe", "ignore"]
+  });
+  const pid = out.trim().split(/\s+/).at(-1);
+  if (pid && /^\d+$/.test(pid)) {
+    execSync(`taskkill /PID ${pid} /F`, { stdio: "ignore" });
+    console.error(`[Tandem] Killed stale PID ${pid} holding port ${port}`);
+  }
+}
+function freePortUnix(port) {
+  let pids = [];
+  try {
+    const out = execSync(`lsof -ti TCP:${port} -sTCP:LISTEN`, {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "ignore"]
+    });
+    pids = parseLsofPids(out);
+  } catch {
+    try {
+      const out = execSync(`ss -tlnp sport = :${port}`, {
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "ignore"]
+      });
+      const pid = parseSsPid(out);
+      if (pid) pids = [pid];
+    } catch {
+    }
+  }
+  for (const pid of pids) {
+    try {
+      process.kill(pid, "SIGKILL");
+      console.error(`[Tandem] Killed stale PID ${pid} holding port ${port}`);
+    } catch {
+    }
+  }
+}
+var paths, SESSION_DIR;
+var init_platform = __esm({
+  "src/server/platform.ts"() {
+    "use strict";
+    paths = envPaths("tandem", { suffix: "" });
+    SESSION_DIR = path.join(paths.data, "sessions");
+  }
+});
+
+// src/server/session/manager.ts
+import fs from "fs/promises";
+import path2 from "path";
+import * as Y2 from "yjs";
+function sessionKey(filePath) {
+  return encodeURIComponent(filePath.replace(/\\/g, "/"));
+}
+async function saveSession(filePath, format, doc) {
+  const key = sessionKey(filePath);
+  let sourceFileMtime = 0;
+  if (!filePath.startsWith("upload://")) {
+    try {
+      const stat = await fs.stat(filePath);
+      sourceFileMtime = stat.mtimeMs;
+    } catch {
+    }
+  }
+  const state = Y2.encodeStateAsUpdate(doc);
+  const ydocState = Buffer.from(state).toString("base64");
+  const data = {
+    filePath,
+    format,
+    ydocState,
+    sourceFileMtime,
+    lastAccessed: Date.now()
+  };
+  if (!sessionDirReady) {
+    await fs.mkdir(SESSION_DIR, { recursive: true });
+    sessionDirReady = true;
+  }
+  const sessionPath = path2.join(SESSION_DIR, `${key}.json`);
+  const tmpPath = `${sessionPath}.tmp`;
+  await fs.writeFile(tmpPath, JSON.stringify(data), "utf-8");
+  try {
+    await fs.rename(tmpPath, sessionPath);
+  } catch (err) {
+    await fs.unlink(tmpPath).catch(() => {
+    });
+    throw err;
+  }
+}
+async function loadSession(filePath) {
+  const key = sessionKey(filePath);
+  const sessionPath = path2.join(SESSION_DIR, `${key}.json`);
+  try {
+    const content = await fs.readFile(sessionPath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function restoreYDoc(doc, session) {
+  const state = Buffer.from(session.ydocState, "base64");
+  Y2.applyUpdate(doc, new Uint8Array(state));
+}
+async function sourceFileChanged(session) {
+  if (session.filePath.startsWith("upload://")) return false;
+  try {
+    const stat = await fs.stat(session.filePath);
+    return stat.mtimeMs !== session.sourceFileMtime;
+  } catch {
+    return true;
+  }
+}
+async function deleteSession(filePath) {
+  const key = sessionKey(filePath);
+  const sessionPath = path2.join(SESSION_DIR, `${key}.json`);
+  try {
+    await fs.unlink(sessionPath);
+  } catch (err) {
+    const code = err.code;
+    if (code !== "ENOENT") {
+      console.error(`[Tandem] deleteSession: failed to delete ${sessionPath}:`, err);
+    }
+  }
+}
+async function saveCtrlSession(doc) {
+  if (!sessionDirReady) {
+    await fs.mkdir(SESSION_DIR, { recursive: true });
+    sessionDirReady = true;
+  }
+  const chatMap = doc.getMap(Y_MAP_CHAT);
+  const entries = [];
+  chatMap.forEach((value, key) => {
+    const msg = value;
+    entries.push({ id: key, timestamp: msg.timestamp });
+  });
+  if (entries.length > 200) {
+    entries.sort((a, b) => a.timestamp - b.timestamp);
+    const toDelete = entries.slice(0, entries.length - 200);
+    doc.transact(() => {
+      for (const entry of toDelete) {
+        chatMap.delete(entry.id);
+      }
+    }, MCP_ORIGIN);
+  }
+  const state = Y2.encodeStateAsUpdate(doc);
+  const ydocState = Buffer.from(state).toString("base64");
+  const data = { ydocState, lastAccessed: Date.now() };
+  const sessionPath = path2.join(SESSION_DIR, `${CTRL_SESSION_KEY}.json`);
+  const tmpPath = `${sessionPath}.tmp`;
+  await fs.writeFile(tmpPath, JSON.stringify(data), "utf-8");
+  try {
+    await fs.rename(tmpPath, sessionPath);
+  } catch (err) {
+    await fs.unlink(tmpPath).catch(() => {
+    });
+    throw err;
+  }
+}
+async function loadCtrlSession() {
+  const sessionPath = path2.join(SESSION_DIR, `${CTRL_SESSION_KEY}.json`);
+  try {
+    const content = await fs.readFile(sessionPath, "utf-8");
+    const data = JSON.parse(content);
+    return data.ydocState ?? null;
+  } catch {
+    return null;
+  }
+}
+function restoreCtrlDoc(doc, base64State) {
+  const state = Buffer.from(base64State, "base64");
+  Y2.applyUpdate(doc, new Uint8Array(state));
+}
+async function listSessionFilePaths() {
+  try {
+    await fs.mkdir(SESSION_DIR, { recursive: true });
+    const files = await fs.readdir(SESSION_DIR);
+    const results = [];
+    for (const file of files) {
+      if (!file.endsWith(".json")) continue;
+      if (file === `${encodeURIComponent(CTRL_ROOM)}.json`) continue;
+      try {
+        const raw = await fs.readFile(path2.join(SESSION_DIR, file), "utf-8");
+        const data = JSON.parse(raw);
+        if (!data.filePath || data.filePath.startsWith("upload://")) continue;
+        results.push({ filePath: data.filePath, lastAccessed: data.lastAccessed ?? 0 });
+      } catch (err) {
+        console.error(`[Tandem] Skipping unreadable session file ${file}:`, err);
+      }
+    }
+    results.sort((a, b) => b.lastAccessed - a.lastAccessed);
+    return results;
+  } catch (err) {
+    console.error("[Tandem] Failed to read session directory:", err);
+    return [];
+  }
+}
+async function cleanupSessions() {
+  let cleaned = 0;
+  try {
+    const files = await fs.readdir(SESSION_DIR);
+    const now = Date.now();
+    for (const file of files) {
+      const filePath = path2.join(SESSION_DIR, file);
+      const stat = await fs.stat(filePath);
+      if (now - stat.mtimeMs > SESSION_MAX_AGE) {
+        await fs.unlink(filePath);
+        cleaned++;
+      }
+    }
+  } catch {
+  }
+  return cleaned;
+}
+function isAutoSaveRunning() {
+  return autoSaveTimer !== null;
+}
+function startAutoSave(callback) {
+  stopAutoSave();
+  autoSaveCallback = callback;
+  autoSaveTimer = setInterval(async () => {
+    try {
+      await autoSaveCallback?.();
+    } catch (err) {
+      console.error("[Tandem] Auto-save failed:", err);
+    }
+  }, AUTO_SAVE_INTERVAL);
+}
+function stopAutoSave() {
+  if (autoSaveTimer) {
+    clearInterval(autoSaveTimer);
+    autoSaveTimer = null;
+  }
+  autoSaveCallback = null;
+}
+var AUTO_SAVE_INTERVAL, sessionDirReady, CTRL_SESSION_KEY, autoSaveTimer, autoSaveCallback;
+var init_manager = __esm({
+  "src/server/session/manager.ts"() {
+    "use strict";
+    init_platform();
+    init_constants();
+    init_queue();
+    AUTO_SAVE_INTERVAL = 60 * 1e3;
+    sessionDirReady = false;
+    CTRL_SESSION_KEY = CTRL_ROOM;
+    autoSaveTimer = null;
+    autoSaveCallback = null;
+  }
+});
+
+// src/server/file-io/mdast-ydoc.ts
+import * as Y3 from "yjs";
+function mdastToYDoc(doc, tree) {
+  const fragment = doc.getXmlFragment("default");
+  if (fragment.length > 0) {
+    fragment.delete(0, fragment.length);
+  }
+  const deferred = [];
+  const allElements = [];
+  for (const node of tree.children) {
+    allElements.push(...blockToYxml(node, deferred));
+  }
+  if (allElements.length > 0) {
+    fragment.insert(0, allElements);
+  }
+  for (const { xmlText, nodes, plainText } of deferred) {
+    if (nodes) {
+      processInline(xmlText, nodes, {});
+    } else if (plainText != null) {
+      xmlText.insert(0, plainText);
+    }
+  }
+}
+function blockToYxml(node, deferred) {
+  switch (node.type) {
+    case "heading": {
+      const el = new Y3.XmlElement("heading");
+      el.setAttribute("level", node.depth);
+      const text = new Y3.XmlText();
+      el.insert(0, [text]);
+      deferred.push({ xmlText: text, nodes: node.children });
+      return [el];
+    }
+    case "paragraph": {
+      const el = new Y3.XmlElement("paragraph");
+      const text = new Y3.XmlText();
+      el.insert(0, [text]);
+      deferred.push({ xmlText: text, nodes: node.children });
+      return [el];
+    }
+    case "blockquote": {
+      const el = new Y3.XmlElement("blockquote");
+      for (const child of node.children) {
+        const childEls = blockToYxml(child, deferred);
+        for (const c of childEls) {
+          el.insert(el.length, [c]);
+        }
+      }
+      return [el];
+    }
+    case "list": {
+      const nodeName = node.ordered ? "orderedList" : "bulletList";
+      const el = new Y3.XmlElement(nodeName);
+      if (node.ordered && node.start != null && node.start !== 1) {
+        el.setAttribute("start", node.start);
+      }
+      for (const item of node.children) {
+        const listItem = new Y3.XmlElement("listItem");
+        for (const child of item.children) {
+          const childEls = blockToYxml(child, deferred);
+          for (const c of childEls) {
+            listItem.insert(listItem.length, [c]);
+          }
+        }
+        el.insert(el.length, [listItem]);
+      }
+      return [el];
+    }
+    case "code": {
+      const el = new Y3.XmlElement("codeBlock");
+      if (node.lang) {
+        el.setAttribute("language", node.lang);
+      }
+      const text = new Y3.XmlText();
+      el.insert(0, [text]);
+      deferred.push({ xmlText: text, plainText: node.value });
+      return [el];
+    }
+    case "thematicBreak": {
+      return [new Y3.XmlElement("horizontalRule")];
+    }
+    case "image": {
+      const el = new Y3.XmlElement("image");
+      el.setAttribute("src", node.url);
+      if (node.alt) el.setAttribute("alt", node.alt);
+      if (node.title) el.setAttribute("title", node.title);
+      return [el];
+    }
+    // html blocks, definitions, etc. — wrap as paragraphs to avoid data loss
+    default: {
+      if ("value" in node && typeof node.value === "string") {
+        const el = new Y3.XmlElement("paragraph");
+        const text = new Y3.XmlText();
+        el.insert(0, [text]);
+        deferred.push({ xmlText: text, plainText: node.value });
+        return [el];
+      }
+      return [];
+    }
+  }
+}
+function buildAttrs(marks) {
+  const attrs = {};
+  for (const name of ALL_MARKS) {
+    attrs[name] = name in marks ? marks[name] : null;
+  }
+  return attrs;
+}
+function processInline(xmlText, nodes, marks) {
+  for (const node of nodes) {
+    switch (node.type) {
+      case "text": {
+        xmlText.insert(xmlText.length, node.value, buildAttrs(marks));
+        break;
+      }
+      case "strong":
+        processInline(xmlText, node.children, { ...marks, bold: {} });
+        break;
+      case "emphasis":
+        processInline(xmlText, node.children, { ...marks, italic: {} });
+        break;
+      case "delete":
+        processInline(xmlText, node.children, { ...marks, strike: {} });
+        break;
+      case "inlineCode": {
+        xmlText.insert(xmlText.length, node.value, buildAttrs({ ...marks, code: {} }));
+        break;
+      }
+      case "link":
+        processInline(xmlText, node.children, {
+          ...marks,
+          link: { href: node.url, ...node.title ? { title: node.title } : {} }
+        });
+        break;
+      case "break": {
+        const embed = new Y3.XmlElement("hardBreak");
+        xmlText.insertEmbed(xmlText.length, embed);
+        break;
+      }
+      case "image": {
+        xmlText.insert(xmlText.length, node.alt || node.url, buildAttrs(marks));
+        break;
+      }
+      // html inline, footnoteReference, etc. — insert raw value if available
+      default:
+        if ("value" in node && typeof node.value === "string") {
+          xmlText.insert(xmlText.length, node.value, buildAttrs(marks));
+        }
+        break;
+    }
+  }
+}
+function yDocToMdast(doc) {
+  const fragment = doc.getXmlFragment("default");
+  const children = [];
+  for (let i = 0; i < fragment.length; i++) {
+    const node = fragment.get(i);
+    if (node instanceof Y3.XmlElement) {
+      const mdastNode = yxmlToMdast(node);
+      if (mdastNode) children.push(mdastNode);
+    }
+  }
+  return { type: "root", children };
+}
+function yxmlToMdast(el) {
+  switch (el.nodeName) {
+    case "heading": {
+      const depth = Number(el.getAttribute("level") ?? 1);
+      return { type: "heading", depth, children: deltaToPhrasingContent(el) };
+    }
+    case "paragraph":
+      return { type: "paragraph", children: deltaToPhrasingContent(el) };
+    case "blockquote": {
+      const children = [];
+      for (let i = 0; i < el.length; i++) {
+        const child = el.get(i);
+        if (child instanceof Y3.XmlElement) {
+          const m = yxmlToMdast(child);
+          if (m) children.push(m);
+        }
+      }
+      return { type: "blockquote", children };
+    }
+    case "bulletList":
+    case "orderedList": {
+      const ordered = el.nodeName === "orderedList";
+      const start = ordered ? Number(el.getAttribute("start")) || 1 : void 0;
+      const listItems = [];
+      for (let i = 0; i < el.length; i++) {
+        const child = el.get(i);
+        if (child instanceof Y3.XmlElement && child.nodeName === "listItem") {
+          const itemChildren = [];
+          for (let j = 0; j < child.length; j++) {
+            const grandchild = child.get(j);
+            if (grandchild instanceof Y3.XmlElement) {
+              const m = yxmlToMdast(grandchild);
+              if (m) itemChildren.push(m);
+            }
+          }
+          listItems.push({ type: "listItem", spread: false, children: itemChildren });
+        }
+      }
+      return {
+        type: "list",
+        ordered,
+        spread: false,
+        ...ordered && start !== 1 ? { start } : {},
+        children: listItems
+      };
+    }
+    case "codeBlock": {
+      const lang = el.getAttribute("language");
+      let value = "";
+      for (let i = 0; i < el.length; i++) {
+        const child = el.get(i);
+        if (child instanceof Y3.XmlText) {
+          value += child.toString();
+        }
+      }
+      return { type: "code", lang: lang || null, value };
+    }
+    case "horizontalRule":
+      return { type: "thematicBreak" };
+    case "image": {
+      return {
+        type: "image",
+        url: el.getAttribute("src") || "",
+        alt: el.getAttribute("alt") || void 0,
+        title: el.getAttribute("title") || null
+      };
+    }
+    // Unknown node types — try to extract text content as a paragraph
+    default: {
+      const phrasing = deltaToPhrasingContent(el);
+      if (phrasing.length > 0) {
+        return { type: "paragraph", children: phrasing };
+      }
+      return null;
+    }
+  }
+}
+function stripHashSuffix(key) {
+  const dashIdx = key.indexOf("--");
+  return dashIdx >= 0 ? key.slice(0, dashIdx) : key;
+}
+function deltaToPhrasingContent(el) {
+  const result = [];
+  for (let i = 0; i < el.length; i++) {
+    const child = el.get(i);
+    if (child instanceof Y3.XmlText) {
+      const delta = child.toDelta();
+      for (const op of delta) {
+        if (typeof op.insert !== "string") {
+          if (op.insert instanceof Y3.XmlElement && op.insert.nodeName === "hardBreak") {
+            result.push({ type: "break" });
+          }
+          continue;
+        }
+        const text = op.insert;
+        if (text.length === 0) continue;
+        const attrs = op.attributes || {};
+        const marks = /* @__PURE__ */ new Map();
+        for (const [key, value] of Object.entries(attrs)) {
+          marks.set(stripHashSuffix(key), value);
+        }
+        let node = { type: "text", value: text };
+        if (marks.has("link")) {
+          const linkAttrs = marks.get("link") || {};
+          node = {
+            type: "link",
+            url: linkAttrs.href || "",
+            ...linkAttrs.title ? { title: linkAttrs.title } : {},
+            children: [node]
+          };
+        }
+        if (marks.has("code")) {
+          node = { type: "inlineCode", value: text };
+        }
+        if (marks.has("strike")) {
+          if (node.type === "inlineCode") {
+            node = { type: "delete", children: [{ type: "text", value: text }] };
+          } else {
+            node = { type: "delete", children: [node] };
+          }
+        }
+        if (marks.has("italic")) {
+          if (node.type === "inlineCode") {
+            node = { type: "emphasis", children: [{ type: "text", value: text }] };
+          } else {
+            node = { type: "emphasis", children: [node] };
+          }
+        }
+        if (marks.has("bold")) {
+          if (node.type === "inlineCode") {
+            node = { type: "strong", children: [{ type: "text", value: text }] };
+          } else {
+            node = { type: "strong", children: [node] };
+          }
+        }
+        result.push(node);
+      }
+    } else if (child instanceof Y3.XmlElement) {
+      if (child.nodeName === "hardBreak") {
+        result.push({ type: "break" });
+      }
+    }
+  }
+  return result;
+}
+var ALL_MARKS;
+var init_mdast_ydoc = __esm({
+  "src/server/file-io/mdast-ydoc.ts"() {
+    "use strict";
+    ALL_MARKS = ["bold", "italic", "strike", "code", "link"];
+  }
+});
+
+// src/server/file-io/markdown.ts
+import { unified } from "unified";
+import remarkParse from "remark-parse";
+import remarkGfm from "remark-gfm";
+import remarkStringify from "remark-stringify";
+function loadMarkdown(doc, markdown) {
+  const tree = parser.parse(markdown);
+  mdastToYDoc(doc, tree);
+}
+function saveMarkdown(doc) {
+  const tree = yDocToMdast(doc);
+  return serializer.stringify(tree);
+}
+var parser, serializer;
+var init_markdown = __esm({
+  "src/server/file-io/markdown.ts"() {
+    "use strict";
+    init_mdast_ydoc();
+    parser = unified().use(remarkParse).use(remarkGfm).freeze();
+    serializer = unified().use(remarkGfm).use(remarkStringify, {
+      bullet: "-",
+      emphasis: "*",
+      strong: "*",
+      listItemIndent: "one",
+      rule: "-"
+    }).freeze();
+  }
+});
+
+// src/shared/offsets.ts
+function headingPrefixLength(level) {
+  if (!level) return 0;
+  return level + 1;
+}
+function headingPrefix(level) {
+  return "#".repeat(level) + " ";
+}
+var FLAT_SEPARATOR;
+var init_offsets = __esm({
+  "src/shared/offsets.ts"() {
+    "use strict";
+    FLAT_SEPARATOR = "\n";
+  }
+});
+
+// src/server/mcp/document-model.ts
+import path3 from "path";
+import * as Y4 from "yjs";
+function detectFormat(filePath) {
+  const ext = path3.extname(filePath).toLowerCase();
+  switch (ext) {
+    case ".md":
+      return "md";
+    case ".txt":
+      return "txt";
+    case ".html":
+    case ".htm":
+      return "html";
+    case ".docx":
+      return "docx";
+    default:
+      return "txt";
+  }
+}
+function docIdFromPath(filePath) {
+  const normalized = filePath.replace(/\\/g, "/").toLowerCase();
+  let hash = 0;
+  for (let i = 0; i < normalized.length; i++) {
+    hash = (hash << 5) - hash + normalized.charCodeAt(i) | 0;
+  }
+  const name = path3.basename(normalized, path3.extname(normalized)).replace(/[^a-zA-Z0-9]/g, "-").replace(/-+/g, "-").slice(0, 16);
+  return `${name}-${Math.abs(hash).toString(36).slice(0, 6)}`;
+}
+function populateYDoc(doc, text) {
+  const fragment = doc.getXmlFragment("default");
+  if (fragment.length > 0) {
+    fragment.delete(0, fragment.length);
+  }
+  if (text === "") return;
+  const lines = text.split("\n");
+  for (const line of lines) {
+    if (line === "") {
+      const empty = new Y4.XmlElement("paragraph");
+      empty.insert(0, [new Y4.XmlText("")]);
+      fragment.insert(fragment.length, [empty]);
+      continue;
+    }
+    let element;
+    if (line.startsWith("### ")) {
+      element = new Y4.XmlElement("heading");
+      element.setAttribute("level", 3);
+      element.insert(0, [new Y4.XmlText(line.slice(4))]);
+    } else if (line.startsWith("## ")) {
+      element = new Y4.XmlElement("heading");
+      element.setAttribute("level", 2);
+      element.insert(0, [new Y4.XmlText(line.slice(3))]);
+    } else if (line.startsWith("# ")) {
+      element = new Y4.XmlElement("heading");
+      element.setAttribute("level", 1);
+      element.insert(0, [new Y4.XmlText(line.slice(2))]);
+    } else {
+      element = new Y4.XmlElement("paragraph");
+      element.insert(0, [new Y4.XmlText(line)]);
+    }
+    fragment.insert(fragment.length, [element]);
+  }
+}
+function getElementText(element) {
+  const parts = [];
+  for (let i = 0; i < element.length; i++) {
+    const child = element.get(i);
+    if (child instanceof Y4.XmlText) {
+      parts.push(child.toString());
+    } else if (child instanceof Y4.XmlElement) {
+      parts.push(getElementText(child));
+    }
+  }
+  return parts.join("");
+}
+function extractText(doc) {
+  const fragment = doc.getXmlFragment("default");
+  const lines = [];
+  for (let i = 0; i < fragment.length; i++) {
+    const node = fragment.get(i);
+    if (node instanceof Y4.XmlElement) {
+      const text = getElementText(node);
+      if (node.nodeName === "heading") {
+        const level = Number(node.getAttribute("level") ?? 1);
+        lines.push(headingPrefix(level) + text);
+      } else {
+        lines.push(text);
+      }
+    }
+  }
+  return lines.join(FLAT_SEPARATOR);
+}
+function extractMarkdown(doc) {
+  return saveMarkdown(doc).trimEnd();
+}
+function getHeadingPrefixLength(node) {
+  if (node.nodeName === "heading") {
+    const level = Number(node.getAttribute("level") ?? 1);
+    return headingPrefixLength(level);
+  }
+  return 0;
+}
+function findXmlText(element) {
+  for (let i = 0; i < element.length; i++) {
+    const child = element.get(i);
+    if (child instanceof Y4.XmlText) {
+      return child;
+    }
+  }
+  return null;
+}
+function getOrCreateXmlText(element) {
+  return findXmlText(element) ?? (() => {
+    const textNode = new Y4.XmlText("");
+    element.insert(0, [textNode]);
+    return textNode;
+  })();
+}
+var init_document_model = __esm({
+  "src/server/mcp/document-model.ts"() {
+    "use strict";
+    init_offsets();
+    init_markdown();
+  }
+});
+
+// src/server/file-io/docx-html.ts
+import * as htmlparser2 from "htmlparser2";
+import * as Y5 from "yjs";
+function buildAttrs2(marks) {
+  const attrs = {};
+  for (const name of ALL_MARKS2) {
+    attrs[name] = name in marks ? marks[name] : null;
+  }
+  return attrs;
+}
+function isElement(node) {
+  return node.type === "tag";
+}
+function isText(node) {
+  return node.type === "text";
+}
+function htmlToYDoc(doc, html) {
+  const fragment = doc.getXmlFragment("default");
+  if (fragment.length > 0) {
+    fragment.delete(0, fragment.length);
+  }
+  if (!html.trim()) return;
+  const parsed = htmlparser2.parseDocument(html);
+  const deferred = [];
+  const allElements = [];
+  for (const child of parsed.children) {
+    allElements.push(...domNodeToYxml(child, deferred));
+  }
+  if (allElements.length > 0) {
+    fragment.insert(0, allElements);
+  }
+  for (const { xmlText, children, marks } of deferred) {
+    processInlineNodes(xmlText, children, marks);
+  }
+}
+function domNodeToYxml(node, deferred) {
+  if (isText(node)) {
+    const text = node.data;
+    if (!text.trim()) return [];
+    const el = new Y5.XmlElement("paragraph");
+    const xmlText = new Y5.XmlText();
+    el.insert(0, [xmlText]);
+    deferred.push({ xmlText, children: [node], marks: {} });
+    return [el];
+  }
+  if (!isElement(node)) return [];
+  const tag = node.tagName.toLowerCase();
+  const headingMatch = tag.match(/^h([1-6])$/);
+  if (headingMatch) {
+    const el = new Y5.XmlElement("heading");
+    el.setAttribute("level", parseInt(headingMatch[1]));
+    const xmlText = new Y5.XmlText();
+    el.insert(0, [xmlText]);
+    deferred.push({ xmlText, children: node.children, marks: {} });
+    return [el];
+  }
+  switch (tag) {
+    case "p": {
+      const el = new Y5.XmlElement("paragraph");
+      const xmlText = new Y5.XmlText();
+      el.insert(0, [xmlText]);
+      deferred.push({ xmlText, children: node.children, marks: {} });
+      return [el];
+    }
+    case "blockquote": {
+      const el = new Y5.XmlElement("blockquote");
+      const blockChildren = collectBlockChildren(node.children, deferred);
+      for (const child of blockChildren) {
+        el.insert(el.length, [child]);
+      }
+      return [el];
+    }
+    case "ul": {
+      const el = new Y5.XmlElement("bulletList");
+      for (const child of node.children) {
+        if (isElement(child) && child.tagName.toLowerCase() === "li") {
+          el.insert(el.length, [buildListItem(child, deferred)]);
+        }
+      }
+      return [el];
+    }
+    case "ol": {
+      const el = new Y5.XmlElement("orderedList");
+      const start = parseInt(node.attribs.start || "1");
+      if (start !== 1) {
+        el.setAttribute("start", start);
+      }
+      for (const child of node.children) {
+        if (isElement(child) && child.tagName.toLowerCase() === "li") {
+          el.insert(el.length, [buildListItem(child, deferred)]);
+        }
+      }
+      return [el];
+    }
+    case "table": {
+      const el = new Y5.XmlElement("table");
+      const rows = collectTableRows(node);
+      for (const row of rows) {
+        el.insert(el.length, [buildTableRow(row, deferred)]);
+      }
+      return [el];
+    }
+    case "pre": {
+      const el = new Y5.XmlElement("codeBlock");
+      const xmlText = new Y5.XmlText();
+      el.insert(0, [xmlText]);
+      deferred.push({ xmlText, children: node.children, marks: {} });
+      return [el];
+    }
+    case "img": {
+      const el = new Y5.XmlElement("image");
+      el.setAttribute("src", node.attribs.src || "");
+      if (node.attribs.alt) el.setAttribute("alt", node.attribs.alt);
+      if (node.attribs.title) el.setAttribute("title", node.attribs.title);
+      return [el];
+    }
+    case "hr": {
+      return [new Y5.XmlElement("horizontalRule")];
+    }
+    case "br": {
+      const el = new Y5.XmlElement("paragraph");
+      el.insert(0, [new Y5.XmlText("")]);
+      return [el];
+    }
+    case "div": {
+      const results = [];
+      for (const child of node.children) {
+        results.push(...domNodeToYxml(child, deferred));
+      }
+      return results;
+    }
+    default: {
+      if (hasBlockChildren(node)) {
+        const results = [];
+        for (const child of node.children) {
+          results.push(...domNodeToYxml(child, deferred));
+        }
+        return results;
+      }
+      const el = new Y5.XmlElement("paragraph");
+      const xmlText = new Y5.XmlText();
+      el.insert(0, [xmlText]);
+      deferred.push({ xmlText, children: node.children, marks: {} });
+      return [el];
+    }
+  }
+}
+function hasBlockChildren(node) {
+  return node.children.some(
+    (child) => isElement(child) && BLOCK_TAGS.has(child.tagName.toLowerCase())
+  );
+}
+function collectBlockChildren(children, deferred) {
+  const result = [];
+  let inlineBuffer = [];
+  const flushInline = () => {
+    if (inlineBuffer.length === 0) return;
+    const hasContent = inlineBuffer.some((n) => isText(n) ? n.data.trim().length > 0 : true);
+    if (hasContent) {
+      const el = new Y5.XmlElement("paragraph");
+      const xmlText = new Y5.XmlText();
+      el.insert(0, [xmlText]);
+      deferred.push({ xmlText, children: inlineBuffer, marks: {} });
+      result.push(el);
+    }
+    inlineBuffer = [];
+  };
+  for (const child of children) {
+    if (isElement(child) && BLOCK_TAGS.has(child.tagName.toLowerCase())) {
+      flushInline();
+      result.push(...domNodeToYxml(child, deferred));
+    } else {
+      inlineBuffer.push(child);
+    }
+  }
+  flushInline();
+  if (result.length === 0) {
+    const el = new Y5.XmlElement("paragraph");
+    el.insert(0, [new Y5.XmlText("")]);
+    result.push(el);
+  }
+  return result;
+}
+function buildListItem(li, deferred) {
+  const listItem = new Y5.XmlElement("listItem");
+  const blockChildren = collectBlockChildren(li.children, deferred);
+  for (const child of blockChildren) {
+    listItem.insert(listItem.length, [child]);
+  }
+  return listItem;
+}
+function collectTableRows(table) {
+  const rows = [];
+  for (const child of table.children) {
+    if (!isElement(child)) continue;
+    const tag = child.tagName.toLowerCase();
+    if (tag === "tr") {
+      rows.push(child);
+    } else if (tag === "thead" || tag === "tbody" || tag === "tfoot") {
+      for (const grandchild of child.children) {
+        if (isElement(grandchild) && grandchild.tagName.toLowerCase() === "tr") {
+          rows.push(grandchild);
+        }
+      }
+    }
+  }
+  return rows;
+}
+function buildTableRow(tr, deferred) {
+  const row = new Y5.XmlElement("tableRow");
+  for (const child of tr.children) {
+    if (!isElement(child)) continue;
+    const tag = child.tagName.toLowerCase();
+    if (tag === "td" || tag === "th") {
+      const nodeName = tag === "th" ? "tableHeader" : "tableCell";
+      const cell = new Y5.XmlElement(nodeName);
+      if (child.attribs.colspan && child.attribs.colspan !== "1") {
+        cell.setAttribute("colspan", parseInt(child.attribs.colspan));
+      }
+      if (child.attribs.rowspan && child.attribs.rowspan !== "1") {
+        cell.setAttribute("rowspan", parseInt(child.attribs.rowspan));
+      }
+      const cellBlocks = collectBlockChildren(child.children, deferred);
+      for (const block of cellBlocks) {
+        cell.insert(cell.length, [block]);
+      }
+      row.insert(row.length, [cell]);
+    }
+  }
+  return row;
+}
+function processInlineNodes(xmlText, nodes, marks) {
+  for (const node of nodes) {
+    if (isText(node)) {
+      const text = node.data;
+      if (text.length > 0) {
+        xmlText.insert(xmlText.length, text, buildAttrs2(marks));
+      }
+      continue;
+    }
+    if (!isElement(node)) continue;
+    const tag = node.tagName.toLowerCase();
+    if (tag === "br") {
+      const embed = new Y5.XmlElement("hardBreak");
+      xmlText.insertEmbed(xmlText.length, embed);
+      continue;
+    }
+    const markFactory = INLINE_MARK_TAGS[tag];
+    if (markFactory) {
+      const newMarks = { ...marks, ...markFactory(node) };
+      processInlineNodes(xmlText, node.children, newMarks);
+      continue;
+    }
+    if (tag === "code") {
+      processInlineNodes(xmlText, node.children, marks);
+      continue;
+    }
+    processInlineNodes(xmlText, node.children, marks);
+  }
+}
+var ALL_MARKS2, INLINE_MARK_TAGS, BLOCK_TAGS;
+var init_docx_html = __esm({
+  "src/server/file-io/docx-html.ts"() {
+    "use strict";
+    ALL_MARKS2 = [
+      "bold",
+      "italic",
+      "strike",
+      "code",
+      "link",
+      "underline",
+      "superscript",
+      "subscript"
+    ];
+    INLINE_MARK_TAGS = {
+      strong: () => ({ bold: {} }),
+      b: () => ({ bold: {} }),
+      em: () => ({ italic: {} }),
+      i: () => ({ italic: {} }),
+      u: () => ({ underline: {} }),
+      s: () => ({ strike: {} }),
+      del: () => ({ strike: {} }),
+      sup: () => ({ superscript: {} }),
+      sub: () => ({ subscript: {} }),
+      a: (el) => ({
+        link: { href: el.attribs.href || "" }
+      })
+    };
+    BLOCK_TAGS = /* @__PURE__ */ new Set([
+      "h1",
+      "h2",
+      "h3",
+      "h4",
+      "h5",
+      "h6",
+      "p",
+      "ul",
+      "ol",
+      "li",
+      "blockquote",
+      "table",
+      "tr",
+      "td",
+      "th",
+      "pre",
+      "img",
+      "hr",
+      "br",
+      "div"
+    ]);
+  }
+});
+
+// src/server/file-io/docx.ts
+import mammoth from "mammoth";
+import * as Y6 from "yjs";
+async function loadDocx(content) {
+  const result = await mammoth.convertToHtml({ buffer: content });
+  for (const msg of result.messages) {
+    console.error(`[mammoth] ${msg.type}: ${msg.message}`);
+  }
+  return result.value;
+}
+function exportAnnotations(doc, annotations) {
+  if (annotations.length === 0) {
+    return "# Document Review\n\nNo annotations found.";
+  }
+  const fragment = doc.getXmlFragment("default");
+  const fullText = extractFullText(fragment);
+  const groups = {};
+  for (const ann of annotations) {
+    const key = ann.type;
+    if (!groups[key]) groups[key] = [];
+    groups[key].push(ann);
+  }
+  const lines = ["# Document Review", ""];
+  const typeLabels = {
+    highlight: "Highlights",
+    comment: "Comments",
+    suggestion: "Suggestions",
+    overlay: "Overlays",
+    question: "Questions",
+    flag: "Flags"
+  };
+  for (const [type, anns] of Object.entries(groups)) {
+    lines.push(`## ${typeLabels[type] || type}`, "");
+    for (const ann of anns) {
+      const snippet = safeSlice(fullText, ann.range.from, ann.range.to);
+      const truncated = snippet.length > 80 ? snippet.slice(0, 77) + "..." : snippet;
+      lines.push(`- **"${truncated}"** (${ann.author})`);
+      if (ann.type === "suggestion") {
+        try {
+          const { newText, reason } = JSON.parse(ann.content);
+          lines.push(`  - Replace with: "${newText}"`);
+          if (reason) lines.push(`  - Reason: ${reason}`);
+        } catch {
+          lines.push(`  - ${ann.content}`);
+        }
+      } else if (ann.content) {
+        lines.push(`  - ${ann.content}`);
+      }
+      if (ann.color) {
+        lines.push(`  - Color: ${ann.color}`);
+      }
+      lines.push("");
+    }
+  }
+  return lines.join("\n").trimEnd();
+}
+function extractFullText(fragment) {
+  const parts = [];
+  for (let i = 0; i < fragment.length; i++) {
+    const node = fragment.get(i);
+    if (node instanceof Y6.XmlElement) {
+      parts.push(getElementText(node));
+    }
+  }
+  return parts.join("\n");
+}
+function safeSlice(text, from, to) {
+  const start = Math.max(0, Math.min(from, text.length));
+  const end = Math.max(start, Math.min(to, text.length));
+  return text.slice(start, end);
+}
+var init_docx = __esm({
+  "src/server/file-io/docx.ts"() {
+    "use strict";
+    init_document_model();
+    init_docx_html();
+  }
+});
+
+// src/shared/positions/types.ts
+var toFlatOffset, toSerializedRelPos;
+var init_types = __esm({
+  "src/shared/positions/types.ts"() {
+    "use strict";
+    toFlatOffset = (n) => n;
+    toSerializedRelPos = (json) => json;
+  }
+});
+
+// src/shared/positions/index.ts
+var init_positions = __esm({
+  "src/shared/positions/index.ts"() {
+    "use strict";
+    init_types();
+  }
+});
+
+// src/server/positions.ts
+import * as Y7 from "yjs";
+function resolveToElement(fragment, charOffset) {
+  let accumulated = 0;
+  for (let i = 0; i < fragment.length; i++) {
+    const node = fragment.get(i);
+    if (!(node instanceof Y7.XmlElement)) continue;
+    const prefixLen = getHeadingPrefixLength(node);
+    const text = getElementText(node);
+    const fullLen = prefixLen + text.length;
+    if (accumulated + fullLen > charOffset) {
+      const offsetInFull = charOffset - accumulated;
+      const clampedFromPrefix = offsetInFull < prefixLen && prefixLen > 0;
+      const textOffset = Math.max(0, offsetInFull - prefixLen);
+      return { elementIndex: i, textOffset, clampedFromPrefix };
+    }
+    accumulated += fullLen;
+    if (i < fragment.length - 1) {
+      accumulated += 1;
+      if (accumulated > charOffset) {
+        return { elementIndex: i, textOffset: text.length, clampedFromPrefix: false };
+      }
+    }
+  }
+  if (fragment.length > 0) {
+    const lastNode = fragment.get(fragment.length - 1);
+    if (lastNode instanceof Y7.XmlElement) {
+      return {
+        elementIndex: fragment.length - 1,
+        textOffset: getElementText(lastNode).length,
+        clampedFromPrefix: false
+      };
+    }
+  }
+  return null;
+}
+function flatOffsetToRelPos(doc, offset, assoc) {
+  const fragment = doc.getXmlFragment("default");
+  const resolved = resolveToElement(fragment, offset);
+  if (!resolved || resolved.clampedFromPrefix) return null;
+  const node = fragment.get(resolved.elementIndex);
+  if (!(node instanceof Y7.XmlElement)) return null;
+  const xmlText = findXmlText(node);
+  if (!xmlText) return null;
+  const rpos = Y7.createRelativePositionFromTypeIndex(xmlText, resolved.textOffset, assoc);
+  return toSerializedRelPos(Y7.relativePositionToJSON(rpos));
+}
+function relPosToFlatOffset(doc, relPosJson) {
+  let absPos;
+  try {
+    const rpos = Y7.createRelativePositionFromJSON(relPosJson);
+    absPos = Y7.createAbsolutePositionFromRelativePosition(rpos, doc);
+  } catch (err) {
+    if (!(err instanceof TypeError) && !(err instanceof SyntaxError)) {
+      console.error("[positions] relPosToFlatOffset: unexpected error resolving relRange:", err);
+    }
+    return null;
+  }
+  if (!absPos) return null;
+  const fragment = doc.getXmlFragment("default");
+  let accumulated = 0;
+  for (let i = 0; i < fragment.length; i++) {
+    const node = fragment.get(i);
+    if (!(node instanceof Y7.XmlElement)) continue;
+    const prefixLen = getHeadingPrefixLength(node);
+    const text = getElementText(node);
+    const xmlText = findXmlText(node);
+    if (xmlText && xmlText === absPos.type) {
+      return toFlatOffset(accumulated + prefixLen + absPos.index);
+    }
+    accumulated += prefixLen + text.length;
+    if (i < fragment.length - 1) {
+      accumulated += 1;
+    }
+  }
+  return null;
+}
+function validateRange(ydoc, from, to, opts) {
+  const rejectHeadingOverlap = opts?.rejectHeadingOverlap ?? false;
+  if (from > to) {
+    return {
+      ok: false,
+      code: "INVALID_RANGE",
+      message: `Invalid range: from (${from}) must be <= to (${to}).`
+    };
+  }
+  if (opts?.textSnapshot) {
+    const fullText = extractText(ydoc);
+    if (fullText.slice(from, to) !== opts.textSnapshot) {
+      const candidates = [];
+      let searchFrom = 0;
+      while (true) {
+        const idx = fullText.indexOf(opts.textSnapshot, searchFrom);
+        if (idx === -1) break;
+        candidates.push(idx);
+        searchFrom = idx + 1;
+      }
+      if (candidates.length === 0) {
+        return { ok: false, code: "RANGE_GONE" };
+      }
+      const best = candidates.reduce((a, b) => Math.abs(a - from) <= Math.abs(b - from) ? a : b);
+      return {
+        ok: false,
+        code: "RANGE_MOVED",
+        resolvedFrom: toFlatOffset(best),
+        resolvedTo: toFlatOffset(best + opts.textSnapshot.length)
+      };
+    }
+  }
+  if (rejectHeadingOverlap) {
+    const fragment = ydoc.getXmlFragment("default");
+    const startPos = resolveToElement(fragment, from);
+    const endPos = resolveToElement(fragment, to);
+    if (!startPos || !endPos) {
+      return {
+        ok: false,
+        code: "INVALID_RANGE",
+        message: `Cannot resolve offset range [${from}, ${to}] in document.`
+      };
+    }
+    if (startPos.clampedFromPrefix || endPos.clampedFromPrefix) {
+      return { ok: false, code: "HEADING_OVERLAP" };
+    }
+  }
+  return { ok: true, range: { from, to } };
+}
+function anchoredRange(ydoc, from, to, textSnapshot) {
+  const validation = validateRange(ydoc, from, to, { textSnapshot });
+  if (!validation.ok) return validation;
+  const range = { from, to };
+  const fromRel = flatOffsetToRelPos(ydoc, from, 0);
+  const toRel = flatOffsetToRelPos(ydoc, to, -1);
+  const relRange = fromRel && toRel ? { fromRel, toRel } : void 0;
+  if (!relRange) {
+    const fragment = ydoc.getXmlFragment("default");
+    const fromEl = resolveToElement(fragment, from);
+    const toEl = resolveToElement(fragment, to);
+    if (fromEl && !fromEl.clampedFromPrefix && toEl && !toEl.clampedFromPrefix) {
+      console.error(`[positions] anchoredRange: relRange creation failed for [${from}, ${to}]`);
+    }
+  }
+  if (relRange) {
+    return { ok: true, fullyAnchored: true, range, relRange };
+  }
+  return { ok: true, fullyAnchored: false, range };
+}
+function refreshRange(ann, ydoc, map) {
+  if (!ann.relRange) {
+    const fromRel = flatOffsetToRelPos(ydoc, ann.range.from, 0);
+    const toRel = flatOffsetToRelPos(ydoc, ann.range.to, -1);
+    if (!fromRel || !toRel) return ann;
+    const updated2 = { ...ann, relRange: { fromRel, toRel } };
+    if (map) map.set(ann.id, updated2);
+    return updated2;
+  }
+  const newFrom = relPosToFlatOffset(ydoc, ann.relRange.fromRel);
+  const newTo = relPosToFlatOffset(ydoc, ann.relRange.toRel);
+  if (newFrom === null || newTo === null) return ann;
+  if (newFrom > newTo) {
+    console.error(
+      `[positions] refreshRange: inverted CRDT range for annotation ${ann.id}: resolved [${newFrom}, ${newTo}] from flat [${ann.range.from}, ${ann.range.to}]`
+    );
+    return ann;
+  }
+  if (newFrom === ann.range.from && newTo === ann.range.to) return ann;
+  const updated = { ...ann, range: { from: newFrom, to: newTo } };
+  if (map) map.set(ann.id, updated);
+  return updated;
+}
+function refreshAllRanges(annotations, ydoc, map) {
+  const results = [];
+  ydoc.transact(() => {
+    for (const ann of annotations) {
+      results.push(refreshRange(ann, ydoc, map));
+    }
+  }, MCP_ORIGIN);
+  return results;
+}
+var init_positions2 = __esm({
+  "src/server/positions.ts"() {
+    "use strict";
+    init_queue();
+    init_positions();
+    init_document_model();
+  }
+});
+
+// src/shared/types.ts
+import { z } from "zod";
+var AnnotationTypeSchema, AnnotationStatusSchema, AnnotationPrioritySchema, InterruptionModeSchema, HighlightColorSchema, SeveritySchema, AuthorSchema, AnnotationActionSchema, ExportFormatSchema, DocumentFormatSchema, ToolErrorCodeSchema;
+var init_types2 = __esm({
+  "src/shared/types.ts"() {
+    "use strict";
+    init_types();
+    AnnotationTypeSchema = z.enum([
+      "highlight",
+      "comment",
+      "suggestion",
+      "overlay",
+      "question",
+      "flag"
+    ]);
+    AnnotationStatusSchema = z.enum(["pending", "accepted", "dismissed"]);
+    AnnotationPrioritySchema = z.enum(["normal", "urgent"]);
+    InterruptionModeSchema = z.enum(["all", "urgent-only", "paused"]);
+    HighlightColorSchema = z.enum(["yellow", "red", "green", "blue", "purple"]);
+    SeveritySchema = z.enum(["info", "warning", "error", "success"]);
+    AuthorSchema = z.enum(["user", "claude", "import"]);
+    AnnotationActionSchema = z.enum(["accept", "dismiss"]);
+    ExportFormatSchema = z.enum(["markdown", "json"]);
+    DocumentFormatSchema = z.enum(["md", "txt", "html", "docx"]);
+    ToolErrorCodeSchema = z.enum([
+      "RANGE_GONE",
+      "RANGE_MOVED",
+      "FILE_LOCKED",
+      "FILE_NOT_FOUND",
+      "NO_DOCUMENT",
+      "INVALID_RANGE",
+      "FORMAT_ERROR",
+      "PERMISSION_DENIED"
+    ]);
+  }
+});
+
+// src/server/file-io/docx-comments.ts
+import JSZip from "jszip";
+import { parseDocument as parseDocument2 } from "htmlparser2";
+async function extractDocxComments(buffer3) {
+  const zip = await JSZip.loadAsync(buffer3);
+  const commentsXml = await zip.file("word/comments.xml")?.async("text");
+  if (!commentsXml) return [];
+  const documentXml = await zip.file("word/document.xml")?.async("text");
+  if (!documentXml) return [];
+  const commentMap = parseCommentMetadata(commentsXml);
+  if (commentMap.size === 0) return [];
+  const ranges = calculateCommentRanges(documentXml);
+  const result = [];
+  for (const [id, meta] of commentMap) {
+    const range = ranges.get(id);
+    if (!range) {
+      console.error(
+        `[docx-comments] Comment ${id} has no range markers in document.xml \u2014 skipping`
+      );
+      continue;
+    }
+    result.push({
+      commentId: id,
+      authorName: meta.authorName,
+      bodyText: meta.bodyText,
+      from: range.from,
+      to: range.to,
+      date: meta.date
+    });
+  }
+  return result;
+}
+function parseCommentMetadata(xml) {
+  const doc = parseDocument2(xml, { xmlMode: true });
+  const map = /* @__PURE__ */ new Map();
+  for (const comment of findAllByName("w:comment", doc.children)) {
+    const id = getAttr(comment, "w:id");
+    if (!id) continue;
+    const author = getAttr(comment, "w:author") || "Unknown";
+    const date = getAttr(comment, "w:date");
+    const textNodes = findAllByName("w:t", comment.children);
+    const bodyText = textNodes.map((t) => getTextContent(t)).join("");
+    map.set(id, { authorName: author, bodyText, date });
+  }
+  return map;
+}
+function calculateCommentRanges(xml) {
+  const doc = parseDocument2(xml, { xmlMode: true });
+  const ranges = /* @__PURE__ */ new Map();
+  const openRanges = /* @__PURE__ */ new Map();
+  let offset = 0;
+  let firstParagraph = true;
+  function walk(nodes) {
+    for (const node of nodes) {
+      if (!isElement2(node)) continue;
+      if (node.name === "w:p") {
+        if (!firstParagraph) offset += 1;
+        firstParagraph = false;
+        const headingLevel = detectHeadingLevel(node);
+        if (headingLevel > 0) {
+          offset += headingPrefixLength(headingLevel);
+        }
+        walk(node.children);
+      } else if (node.name === "w:commentRangeStart") {
+        const id = getAttr(node, "w:id");
+        if (id) openRanges.set(id, offset);
+      } else if (node.name === "w:commentRangeEnd") {
+        const id = getAttr(node, "w:id");
+        if (id && openRanges.has(id)) {
+          ranges.set(id, { from: toFlatOffset(openRanges.get(id)), to: toFlatOffset(offset) });
+          openRanges.delete(id);
+        }
+      } else if (node.name === "w:t") {
+        const text = getTextContent(node);
+        offset += text.length;
+      } else if (node.name === "w:tab" || node.name === "w:br") {
+        offset += 1;
+      } else {
+        walk(node.children);
+      }
+    }
+  }
+  const bodyElements = findAllByName("w:body", doc.children);
+  if (bodyElements.length === 0) {
+    console.error(
+      "[docx-comments] No <w:body> found in document.xml \u2014 cannot calculate comment ranges"
+    );
+    return ranges;
+  }
+  walk(bodyElements[0].children);
+  if (openRanges.size > 0) {
+    console.error(
+      `[docx-comments] ${openRanges.size} comment range(s) had start markers but no end markers: ${[...openRanges.keys()].join(", ")}`
+    );
+  }
+  return ranges;
+}
+function detectHeadingLevel(paragraph) {
+  for (const child of paragraph.children) {
+    if (!isElement2(child) || child.name !== "w:pPr") continue;
+    for (const prop of child.children) {
+      if (!isElement2(prop) || prop.name !== "w:pStyle") continue;
+      const val = getAttr(prop, "w:val") || "";
+      const match = val.match(/^heading\s*(\d)$/i);
+      if (match) {
+        const level = parseInt(match[1], 10);
+        if (level >= 1 && level <= 6) return level;
+      }
+    }
+  }
+  return 0;
+}
+function injectCommentsAsAnnotations(doc, comments) {
+  if (comments.length === 0) return 0;
+  const map = doc.getMap(Y_MAP_ANNOTATIONS);
+  let injected = 0;
+  doc.transact(() => {
+    for (const comment of comments) {
+      const result = anchoredRange(doc, toFlatOffset(comment.from), toFlatOffset(comment.to));
+      if (!result.ok) {
+        console.error(
+          `[docx-comments] Skipping imported comment ${comment.commentId}: range [${comment.from}, ${comment.to}] \u2014 ${result.code}`
+        );
+        continue;
+      }
+      const id = `import-${comment.commentId}-${Date.now()}`;
+      const content = comment.authorName !== "Unknown" ? `[${comment.authorName}] ${comment.bodyText}` : comment.bodyText;
+      const annotation = {
+        id,
+        author: "import",
+        type: "comment",
+        range: { from: result.range.from, to: result.range.to },
+        content,
+        status: "pending",
+        timestamp: comment.date ? new Date(comment.date).getTime() : Date.now()
+      };
+      if (result.fullyAnchored) {
+        annotation.relRange = result.relRange;
+      }
+      map.set(id, annotation);
+      injected++;
+    }
+  }, MCP_ORIGIN);
+  if (injected > 0 || comments.length > 0) {
+    console.error(`[docx-comments] Imported ${injected}/${comments.length} Word comments`);
+  }
+  return injected;
+}
+function isElement2(node) {
+  return node.type === "tag";
+}
+function getAttr(el, name) {
+  return el.attribs?.[name];
+}
+function getTextContent(node) {
+  if (node.type === "text") return node.data;
+  if (!isElement2(node)) return "";
+  return node.children.map(getTextContent).join("");
+}
+function findAllByName(name, nodes) {
+  const results = [];
+  for (const node of nodes) {
+    if (isElement2(node)) {
+      if (node.name === name) results.push(node);
+      results.push(...findAllByName(name, node.children));
+    }
+  }
+  return results;
+}
+var init_docx_comments = __esm({
+  "src/server/file-io/docx-comments.ts"() {
+    "use strict";
+    init_constants();
+    init_offsets();
+    init_positions2();
+    init_types2();
+    init_queue();
+  }
+});
+
+// src/server/file-io/index.ts
+import fs2 from "fs/promises";
+import path4 from "path";
+function getAdapter(format) {
+  return adapters[format] ?? plaintextAdapter;
+}
+async function atomicWrite(filePath, content) {
+  const tempPath = path4.join(path4.dirname(filePath), `.tandem-tmp-${Date.now()}`);
+  await fs2.writeFile(tempPath, content, "utf-8");
+  await fs2.rename(tempPath, filePath);
+}
+var markdownAdapter, plaintextAdapter, docxAdapter, adapters;
+var init_file_io = __esm({
+  "src/server/file-io/index.ts"() {
+    "use strict";
+    init_markdown();
+    init_docx();
+    init_docx_comments();
+    init_document_model();
+    markdownAdapter = {
+      canSave: true,
+      load(doc, content) {
+        loadMarkdown(doc, content);
+      },
+      save(doc) {
+        return saveMarkdown(doc);
+      }
+    };
+    plaintextAdapter = {
+      canSave: true,
+      load(doc, content) {
+        populateYDoc(doc, content);
+      },
+      save(doc) {
+        return extractText(doc);
+      }
+    };
+    docxAdapter = {
+      canSave: false,
+      async load(doc, content) {
+        const buffer3 = content;
+        const [html, comments] = await Promise.all([
+          loadDocx(buffer3),
+          extractDocxComments(buffer3).catch((err) => {
+            console.error(
+              "[docx-comments] Comment extraction failed; document will load without imported comments:",
+              err
+            );
+            return [];
+          })
+        ]);
+        htmlToYDoc(doc, html);
+        if (comments.length > 0) {
+          injectCommentsAsAnnotations(doc, comments);
+        }
+      },
+      save() {
+        return null;
+      }
+    };
+    adapters = {
+      md: markdownAdapter,
+      txt: plaintextAdapter,
+      docx: docxAdapter
+    };
+  }
+});
+
+// src/server/mcp/file-opener.ts
+var file_opener_exports = {};
+__export(file_opener_exports, {
+  SUPPORTED_EXTENSIONS: () => SUPPORTED_EXTENSIONS,
+  openFileByPath: () => openFileByPath,
+  openFileFromContent: () => openFileFromContent
+});
+import fs3 from "fs/promises";
+import fsSync from "fs";
+import path5 from "path";
+import { randomUUID } from "crypto";
+async function openFileByPath(filePath, options) {
+  let resolved = path5.resolve(filePath);
+  try {
+    resolved = fsSync.realpathSync(resolved);
+  } catch {
+    resolved = path5.resolve(filePath);
+  }
+  if (process.platform === "win32" && (resolved.startsWith("\\\\") || resolved.startsWith("//"))) {
+    throw Object.assign(new Error("UNC paths are not supported for security reasons."), {
+      code: "INVALID_PATH"
+    });
+  }
+  const ext = path5.extname(resolved).toLowerCase();
+  if (!SUPPORTED_EXTENSIONS.has(ext)) {
+    throw Object.assign(
+      new Error(
+        `Unsupported file format: ${ext}. Supported: ${[...SUPPORTED_EXTENSIONS].join(", ")}`
+      ),
+      { code: "UNSUPPORTED_FORMAT" }
+    );
+  }
+  const stat = await fs3.stat(resolved);
+  if (stat.size > MAX_FILE_SIZE) {
+    throw Object.assign(new Error("File exceeds 50MB limit."), { code: "FILE_TOO_LARGE" });
+  }
+  const format = detectFormat(resolved);
+  const isDocx = format === "docx";
+  const readOnly = isDocx;
+  const id = docIdFromPath(resolved);
+  const openDocs2 = getOpenDocs();
+  const existing = openDocs2.get(id);
+  const forceReload = existing && options?.force === true;
+  if (existing && !forceReload) {
+    setActiveDocId(id);
+    broadcastOpenDocs();
+    const doc2 = getOrCreateDocument(id);
+    return {
+      ...buildResult(doc2, {
+        documentId: id,
+        filePath: resolved,
+        fileName: path5.basename(resolved),
+        format,
+        readOnly,
+        source: "file",
+        restoredFromSession: false
+      }),
+      alreadyOpen: true
+    };
+  }
+  if (forceReload) {
+    await forceCloseDocument(id, existing);
+  }
+  const doc = getOrCreateDocument(id);
+  const fileName = path5.basename(resolved);
+  let restoredFromSession = false;
+  const session = await loadSession(resolved);
+  if (session) {
+    const changed = await sourceFileChanged(session);
+    if (!changed) {
+      restoreYDoc(doc, session);
+      const fragment = doc.getXmlFragment("default");
+      if (fragment.length > 0) {
+        restoredFromSession = true;
+      } else {
+        console.error(
+          `[Tandem] Session restore yielded empty doc for ${fileName}, falling back to source file`
+        );
+      }
+    }
+  }
+  if (!restoredFromSession) {
+    const adapter = getAdapter(format);
+    const fileContent = isDocx ? await fs3.readFile(resolved) : await fs3.readFile(resolved, "utf-8");
+    await adapter.load(doc, fileContent);
+  }
+  addDoc(id, { id, filePath: resolved, format, readOnly, source: "file" });
+  setActiveDocId(id);
+  writeDocMeta(doc, id, fileName, format, readOnly);
+  initSavedBaseline(doc);
+  broadcastOpenDocs();
+  ensureAutoSave();
+  return {
+    ...buildResult(doc, {
+      documentId: id,
+      filePath: resolved,
+      fileName,
+      format,
+      readOnly,
+      source: "file",
+      restoredFromSession
+    }),
+    forceReloaded: forceReload === true
+  };
+}
+async function openFileFromContent(fileName, content) {
+  const ext = path5.extname(fileName).toLowerCase();
+  if (!SUPPORTED_EXTENSIONS.has(ext)) {
+    throw Object.assign(
+      new Error(
+        `Unsupported file format: ${ext}. Supported: ${[...SUPPORTED_EXTENSIONS].join(", ")}`
+      ),
+      { code: "UNSUPPORTED_FORMAT" }
+    );
+  }
+  const contentSize = content instanceof Buffer ? content.length : Buffer.byteLength(content);
+  if (contentSize > MAX_FILE_SIZE) {
+    throw Object.assign(new Error("File exceeds 50MB limit."), { code: "FILE_TOO_LARGE" });
+  }
+  const format = detectFormat(fileName);
+  const readOnly = true;
+  const syntheticPath = `upload://${randomUUID()}/${fileName}`;
+  const id = docIdFromPath(syntheticPath);
+  const doc = getOrCreateDocument(id);
+  const adapter = getAdapter(format);
+  await adapter.load(doc, content);
+  addDoc(id, { id, filePath: syntheticPath, format, readOnly, source: "upload" });
+  setActiveDocId(id);
+  writeDocMeta(doc, id, fileName, format, readOnly);
+  initSavedBaseline(doc);
+  broadcastOpenDocs();
+  ensureAutoSave();
+  return buildResult(doc, {
+    documentId: id,
+    filePath: syntheticPath,
+    fileName,
+    format,
+    readOnly,
+    source: "upload",
+    restoredFromSession: false
+  });
+}
+async function forceCloseDocument(id, existing) {
+  console.error(`[Tandem] forceCloseDocument: tearing down ${id}`);
+  let errors = 0;
+  try {
+    detachObservers(id);
+  } catch (err) {
+    errors++;
+    console.error(`[Tandem] forceCloseDocument: detachObservers failed for ${id}:`, err);
+  }
+  try {
+    removeDoc(id);
+    broadcastOpenDocs();
+  } catch (err) {
+    errors++;
+    console.error(`[Tandem] forceCloseDocument: removeDoc/broadcast failed for ${id}:`, err);
+  }
+  try {
+    const hp = getHocuspocus();
+    if (hp) {
+      hp.closeConnections(id);
+      const hpDoc = hp.documents.get(id);
+      if (hpDoc) {
+        hp.documents.delete(id);
+        hpDoc.destroy();
+      }
+      hp.loadingDocuments.delete(id);
+    }
+  } catch (err) {
+    errors++;
+    console.error(`[Tandem] forceCloseDocument: Hocuspocus cleanup failed for ${id}:`, err);
+  }
+  try {
+    const oldDoc = getDocument(id);
+    if (oldDoc) {
+      oldDoc.destroy();
+      removeDocument(id);
+    }
+  } catch (err) {
+    errors++;
+    console.error(`[Tandem] forceCloseDocument: Y.Doc removal failed for ${id}:`, err);
+  }
+  try {
+    await deleteSession(existing.filePath);
+  } catch (err) {
+    errors++;
+    console.error(`[Tandem] forceCloseDocument: deleteSession failed for ${id}:`, err);
+  }
+  await new Promise((resolve) => setTimeout(resolve, 100));
+  console.error(
+    `[Tandem] forceCloseDocument: teardown complete for ${id}${errors > 0 ? ` with ${errors} error(s)` : ""}`
+  );
+}
+function initSavedBaseline(doc) {
+  const meta = doc.getMap(Y_MAP_DOCUMENT_META);
+  doc.transact(() => meta.set(Y_MAP_SAVED_AT_VERSION, Date.now()), MCP_ORIGIN);
+}
+function writeDocMeta(doc, id, fileName, format, readOnly) {
+  const meta = doc.getMap(Y_MAP_DOCUMENT_META);
+  doc.transact(() => {
+    meta.set("readOnly", readOnly);
+    meta.set("format", format);
+    meta.set("documentId", id);
+    meta.set("fileName", fileName);
+  }, MCP_ORIGIN);
+}
+function buildResult(doc, base) {
+  const textContent = extractText(doc);
+  const textLen = textContent.length;
+  const pageEstimate = Math.ceil(textLen / CHARS_PER_PAGE);
+  const warnings = [];
+  if (pageEstimate >= VERY_LARGE_FILE_PAGE_THRESHOLD) {
+    warnings.push(
+      `Very large document (~${pageEstimate} pages). Consider splitting into smaller files.`
+    );
+  } else if (pageEstimate >= LARGE_FILE_PAGE_THRESHOLD) {
+    warnings.push(`Large document (~${pageEstimate} pages). Operations may be slower than usual.`);
+  }
+  return {
+    ...base,
+    tokenEstimate: Math.ceil(textLen / 4),
+    pageEstimate,
+    alreadyOpen: false,
+    forceReloaded: false,
+    ...warnings.length > 0 ? { warnings } : {}
+  };
+}
+function ensureAutoSave() {
+  if (isAutoSaveRunning()) return;
+  startAutoSave(async () => {
+    for (const [docId, state] of getOpenDocs()) {
+      const d = getOrCreateDocument(docId);
+      await saveSession(state.filePath, state.format, d);
+    }
+  });
+}
+var init_file_opener = __esm({
+  "src/server/mcp/file-opener.ts"() {
+    "use strict";
+    init_provider();
+    init_constants();
+    init_queue();
+    init_file_io();
+    init_manager();
+    init_document_model();
+    init_document_service();
+  }
+});
+
+// src/server/mcp/document-service.ts
+import path6 from "path";
+import { randomUUID as randomUUID2 } from "crypto";
+function getOpenDocs() {
+  return openDocs;
+}
+function addDoc(id, entry) {
+  openDocs.set(id, entry);
+}
+function removeDoc(id) {
+  return openDocs.delete(id);
+}
+function hasDoc(id) {
+  return openDocs.has(id);
+}
+function docCount() {
+  return openDocs.size;
+}
+function getActiveDocId() {
+  return activeDocId;
+}
+function setActiveDocId(id) {
+  activeDocId = id;
+}
+function getCurrentDoc(documentId) {
+  const id = documentId ?? activeDocId;
+  if (!id) return null;
+  const doc = openDocs.get(id);
+  if (!doc) return null;
+  return { ...doc, docName: id };
+}
+function requireDocument(documentId) {
+  const current = getCurrentDoc(documentId);
+  if (!current) return null;
+  return {
+    doc: getOrCreateDocument(current.docName),
+    filePath: current.filePath,
+    docId: current.id
+  };
+}
+function toDocListEntry(d) {
+  return {
+    id: d.id,
+    filePath: d.filePath,
+    fileName: path6.basename(d.filePath),
+    format: d.format,
+    readOnly: d.readOnly
+  };
+}
+function broadcastOpenDocs() {
+  try {
+    const docList = Array.from(openDocs.values()).map(toDocListEntry);
+    const id = activeDocId;
+    const ctrl = getOrCreateDocument(CTRL_ROOM);
+    const ctrlMeta = ctrl.getMap(Y_MAP_DOCUMENT_META);
+    ctrl.transact(() => {
+      ctrlMeta.set("openDocuments", docList);
+      ctrlMeta.set("activeDocumentId", id);
+    }, MCP_ORIGIN);
+    for (const [docId] of openDocs) {
+      const ydoc = getOrCreateDocument(docId);
+      const meta = ydoc.getMap(Y_MAP_DOCUMENT_META);
+      ydoc.transact(() => {
+        meta.set("openDocuments", docList);
+        meta.set("activeDocumentId", id);
+      }, MCP_ORIGIN);
+    }
+  } catch (err) {
+    console.error("[Tandem] broadcastOpenDocs error:", err);
+  }
+}
+async function closeDocumentById(id) {
+  const docState = openDocs.get(id);
+  if (!docState) {
+    return { success: false, error: `Document ${id} not found.` };
+  }
+  const closedPath = docState.filePath;
+  try {
+    const doc = getOrCreateDocument(id);
+    await saveSession(docState.filePath, docState.format, doc);
+  } catch (err) {
+    console.error(`[Tandem] Failed to save session before closing ${id}:`, err);
+  }
+  removeDoc(id);
+  if (getActiveDocId() === id) {
+    const remaining = Array.from(openDocs.keys());
+    setActiveDocId(remaining.length > 0 ? remaining[0] : null);
+  }
+  if (docCount() === 0) {
+    stopAutoSave();
+  }
+  broadcastOpenDocs();
+  return { success: true, closedPath, activeDocumentId: getActiveDocId() };
+}
+async function saveCurrentSession() {
+  for (const [id, state] of openDocs) {
+    const doc = getOrCreateDocument(id);
+    await saveSession(state.filePath, state.format, doc);
+  }
+  const ctrlDoc = getOrCreateDocument(CTRL_ROOM);
+  await saveCtrlSession(ctrlDoc);
+}
+async function restoreCtrlSession() {
+  const saved = await loadCtrlSession();
+  if (!saved) return null;
+  const ctrlDoc = getOrCreateDocument(CTRL_ROOM);
+  restoreCtrlDoc(ctrlDoc, saved);
+  const meta = ctrlDoc.getMap(Y_MAP_DOCUMENT_META);
+  const previousActiveDocId = meta.get("activeDocumentId") ?? null;
+  ctrlDoc.transact(() => {
+    meta.delete("openDocuments");
+    meta.delete("activeDocumentId");
+  }, MCP_ORIGIN);
+  console.error("[Tandem] Restored chat history from session (cleared stale doc list)");
+  return previousActiveDocId;
+}
+function writeGenerationId() {
+  const ctrlDoc = getOrCreateDocument(CTRL_ROOM);
+  const meta = ctrlDoc.getMap(Y_MAP_DOCUMENT_META);
+  const generationId = randomUUID2();
+  ctrlDoc.transact(() => meta.set("generationId", generationId), MCP_ORIGIN);
+  console.error(`[Tandem] Server generationId: ${generationId}`);
+}
+async function restoreOpenDocuments(previousActiveDocId) {
+  const { openFileByPath: openFileByPath2 } = await Promise.resolve().then(() => (init_file_opener(), file_opener_exports));
+  const sessions = await listSessionFilePaths();
+  if (sessions.length === 0) return 0;
+  let restoredCount = 0;
+  for (const { filePath } of sessions) {
+    try {
+      await openFileByPath2(filePath);
+      restoredCount++;
+    } catch (err) {
+      const code = err.code;
+      if (code === "ENOENT") {
+        console.error(`[Tandem] Skipping deleted file (removing stale session): ${filePath}`);
+        deleteSession(filePath).catch(() => {
+        });
+      } else {
+        console.error(`[Tandem] Failed to restore ${filePath}:`, err);
+      }
+    }
+  }
+  if (previousActiveDocId && openDocs.has(previousActiveDocId)) {
+    setActiveDocId(previousActiveDocId);
+    broadcastOpenDocs();
+  }
+  if (restoredCount > 0) {
+    console.error(`[Tandem] Restored ${restoredCount} document(s) from session`);
+  }
+  return restoredCount;
+}
+var openDocs, activeDocId;
+var init_document_service = __esm({
+  "src/server/mcp/document-service.ts"() {
+    "use strict";
+    init_provider();
+    init_manager();
+    init_constants();
+    init_queue();
+    openDocs = /* @__PURE__ */ new Map();
+    setShouldKeepDocument((name) => openDocs.has(name) || name === CTRL_ROOM);
+    activeDocId = null;
+  }
+});
+
+// src/shared/utils.ts
+function generateId(prefix) {
+  return `${prefix}_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+}
+function generateAnnotationId() {
+  return generateId("ann");
+}
+function generateMessageId() {
+  return generateId("msg");
+}
+function generateEventId() {
+  return generateId("evt");
+}
+function generateNotificationId() {
+  return generateId("ntf");
+}
+var init_utils = __esm({
+  "src/shared/utils.ts"() {
+    "use strict";
+  }
+});
+
+// src/server/events/types.ts
+var init_types3 = __esm({
+  "src/server/events/types.ts"() {
+    "use strict";
+    init_utils();
+  }
+});
+
+// src/server/events/queue.ts
+function getTrackableId(event) {
+  switch (event.type) {
+    case "annotation:created":
+    case "annotation:accepted":
+    case "annotation:dismissed":
+      return event.payload.annotationId;
+    case "chat:message":
+      return event.payload.messageId;
+    default:
+      return void 0;
+  }
+}
+function trackPayloadId(event) {
+  const id = getTrackableId(event);
+  if (id) emittedPayloadIds.set(id, (emittedPayloadIds.get(id) ?? 0) + 1);
+}
+function untrackPayloadId(event) {
+  const id = getTrackableId(event);
+  if (!id) return;
+  const count = emittedPayloadIds.get(id) ?? 0;
+  if (count <= 1) emittedPayloadIds.delete(id);
+  else emittedPayloadIds.set(id, count - 1);
+}
+function pushEvent(event) {
+  buffer.push(event);
+  trackPayloadId(event);
+  while (buffer.length > CHANNEL_EVENT_BUFFER_SIZE) {
+    const evicted = buffer.shift();
+    if (evicted) untrackPayloadId(evicted);
+  }
+  const now = Date.now();
+  while (buffer.length > 0 && now - buffer[0].timestamp > CHANNEL_EVENT_BUFFER_AGE_MS) {
+    const evicted = buffer.shift();
+    if (evicted) untrackPayloadId(evicted);
+  }
+  for (const cb of subscribers) {
+    try {
+      cb(event);
+    } catch (err) {
+      console.error("[EventQueue] Subscriber threw during event dispatch:", err);
+    }
+  }
+}
+function subscribe(cb) {
+  subscribers.add(cb);
+}
+function unsubscribe(cb) {
+  subscribers.delete(cb);
+}
+function replaySince(lastEventId) {
+  const idx = buffer.findIndex((e) => e.id === lastEventId);
+  if (idx === -1) return [...buffer];
+  return buffer.slice(idx + 1);
+}
+function attachObservers(docName, doc) {
+  detachObservers(docName);
+  const cleanups = [];
+  const annotationsMap = doc.getMap(Y_MAP_ANNOTATIONS);
+  const annotationsObs = (event, txn) => {
+    if (txn.origin === MCP_ORIGIN) return;
+    for (const [key, change] of event.changes.keys) {
+      const ann = annotationsMap.get(key);
+      if (!ann) continue;
+      if (change.action === "add" && ann.author === "user") {
+        pushEvent({
+          id: generateEventId(),
+          type: "annotation:created",
+          timestamp: Date.now(),
+          documentId: docName,
+          payload: {
+            annotationId: ann.id,
+            annotationType: ann.type,
+            content: ann.content,
+            textSnippet: ann.textSnapshot ?? ""
+          }
+        });
+      } else if (change.action === "update" && ann.author === "claude") {
+        if (ann.status === "accepted") {
+          pushEvent({
+            id: generateEventId(),
+            type: "annotation:accepted",
+            timestamp: Date.now(),
+            documentId: docName,
+            payload: {
+              annotationId: ann.id,
+              textSnippet: ann.textSnapshot ?? ""
+            }
+          });
+        } else if (ann.status === "dismissed") {
+          pushEvent({
+            id: generateEventId(),
+            type: "annotation:dismissed",
+            timestamp: Date.now(),
+            documentId: docName,
+            payload: {
+              annotationId: ann.id,
+              textSnippet: ann.textSnapshot ?? ""
+            }
+          });
+        }
+      }
+    }
+  };
+  annotationsMap.observe(annotationsObs);
+  cleanups.push(() => annotationsMap.unobserve(annotationsObs));
+  const userAwareness = doc.getMap(Y_MAP_USER_AWARENESS);
+  const awarenessObs = (event, txn) => {
+    if (txn.origin === MCP_ORIGIN) return;
+    if (event.keysChanged.has("selection")) {
+      const selection = userAwareness.get("selection");
+      pushEvent({
+        id: generateEventId(),
+        type: "selection:changed",
+        timestamp: Date.now(),
+        documentId: docName,
+        payload: {
+          from: selection?.from ?? 0,
+          to: selection?.to ?? 0,
+          selectedText: selection?.from !== selection?.to ? selection?.selectedText ?? "" : ""
+        }
+      });
+    }
+  };
+  userAwareness.observe(awarenessObs);
+  cleanups.push(() => userAwareness.unobserve(awarenessObs));
+  docObservers.set(docName, cleanups);
+  console.error(`[EventQueue] Attached observers for document: ${docName}`);
+}
+function detachObservers(docName) {
+  const cleanups = docObservers.get(docName);
+  if (cleanups) {
+    for (const cleanup of cleanups) cleanup();
+    docObservers.delete(docName);
+    console.error(`[EventQueue] Detached observers for document: ${docName}`);
+  }
+}
+function reattachObservers(docName, newDoc) {
+  attachObservers(docName, newDoc);
+}
+function attachCtrlObservers() {
+  for (const cleanup of ctrlCleanups) cleanup();
+  ctrlCleanups = [];
+  const ctrlDoc = getOrCreateDocument(CTRL_ROOM);
+  const chatMap = ctrlDoc.getMap(Y_MAP_CHAT);
+  const chatObs = (event, txn) => {
+    if (txn.origin === MCP_ORIGIN) return;
+    for (const [key, change] of event.changes.keys) {
+      if (change.action !== "add") continue;
+      const msg = chatMap.get(key);
+      if (!msg || msg.author !== "user") continue;
+      pushEvent({
+        id: generateEventId(),
+        type: "chat:message",
+        timestamp: Date.now(),
+        documentId: msg.documentId,
+        payload: {
+          messageId: msg.id,
+          text: msg.text,
+          replyTo: msg.replyTo ?? null,
+          anchor: msg.anchor ?? null
+        }
+      });
+    }
+  };
+  chatMap.observe(chatObs);
+  ctrlCleanups.push(() => chatMap.unobserve(chatObs));
+  const metaMap = ctrlDoc.getMap(Y_MAP_DOCUMENT_META);
+  let lastActiveDocId = null;
+  let lastOpenDocIds = /* @__PURE__ */ new Set();
+  const metaObs = (event, txn) => {
+    if (txn.origin === MCP_ORIGIN) return;
+    if (event.keysChanged.has("activeDocumentId")) {
+      const activeId = metaMap.get("activeDocumentId");
+      if (activeId && activeId !== lastActiveDocId) {
+        const openDoc = getOpenDocs().get(activeId);
+        pushEvent({
+          id: generateEventId(),
+          type: "document:switched",
+          timestamp: Date.now(),
+          documentId: activeId,
+          payload: {
+            fileName: openDoc?.filePath?.split(/[/\\]/).pop() ?? activeId
+          }
+        });
+        lastActiveDocId = activeId;
+      }
+    }
+    if (event.keysChanged.has("openDocuments")) {
+      const docList = metaMap.get("openDocuments") ?? [];
+      const currentIds = new Set(docList.map((d) => d.id));
+      for (const doc of docList) {
+        if (!lastOpenDocIds.has(doc.id)) {
+          const openDoc = getOpenDocs().get(doc.id);
+          pushEvent({
+            id: generateEventId(),
+            type: "document:opened",
+            timestamp: Date.now(),
+            documentId: doc.id,
+            payload: {
+              fileName: doc.fileName ?? openDoc?.filePath?.split(/[/\\]/).pop() ?? doc.id,
+              format: openDoc?.format ?? "unknown"
+            }
+          });
+        }
+      }
+      for (const oldId of lastOpenDocIds) {
+        if (!currentIds.has(oldId)) {
+          pushEvent({
+            id: generateEventId(),
+            type: "document:closed",
+            timestamp: Date.now(),
+            documentId: oldId,
+            payload: {
+              fileName: oldId
+            }
+          });
+        }
+      }
+      lastOpenDocIds = currentIds;
+    }
+  };
+  metaMap.observe(metaObs);
+  ctrlCleanups.push(() => metaMap.unobserve(metaObs));
+  console.error("[EventQueue] Attached CTRL_ROOM observers (chat + documentMeta)");
+}
+function reattachCtrlObservers() {
+  attachCtrlObservers();
+}
+var MCP_ORIGIN, docObservers, emittedPayloadIds, buffer, subscribers, ctrlCleanups;
+var init_queue = __esm({
+  "src/server/events/queue.ts"() {
+    "use strict";
+    init_constants();
+    init_document_service();
+    init_provider();
+    init_types3();
+    MCP_ORIGIN = "mcp";
+    docObservers = /* @__PURE__ */ new Map();
+    emittedPayloadIds = /* @__PURE__ */ new Map();
+    buffer = [];
+    subscribers = /* @__PURE__ */ new Set();
+    ctrlCleanups = [];
+  }
+});
+
+// src/server/mcp/launcher.ts
+var launcher_exports = {};
+__export(launcher_exports, {
+  killClaude: () => killClaude,
+  launchClaude: () => launchClaude
+});
+import { spawn } from "child_process";
+function launchClaude() {
+  if (claudeProcess && !claudeProcess.killed) {
+    return { status: "already_running", pid: claudeProcess.pid };
+  }
+  const claudeCmd = process.env.TANDEM_CLAUDE_CMD || "claude";
+  const tandemUrl = `http://localhost:${process.env.TANDEM_MCP_PORT || DEFAULT_MCP_PORT}`;
+  const args = [
+    "--dangerously-load-development-channels",
+    "server:tandem-channel",
+    "--append-system-prompt",
+    TANDEM_SYSTEM_PROMPT,
+    "--name",
+    "tandem-reviewer"
+  ];
+  claudeProcess = spawn(claudeCmd, args, {
+    env: { ...process.env, TANDEM_URL: tandemUrl },
+    stdio: "pipe",
+    detached: true
+  });
+  if (claudeProcess.stdin?.writable) {
+    claudeProcess.stdin.write(
+      "A document has been opened in Tandem for review. Call tandem_checkInbox to see what needs attention, then begin reviewing.\n",
+      (err) => {
+        if (err) console.error("[Launcher] Failed to send initial prompt:", err.message);
+      }
+    );
+  } else {
+    console.error("[Launcher] Claude process has no writable stdin \u2014 initial prompt not delivered");
+  }
+  const pid = claudeProcess.pid;
+  claudeProcess.on("error", (err) => {
+    if (err.code === "ENOENT") {
+      console.error(
+        "[Launcher] Claude Code not found. Install with: npm i -g @anthropic-ai/claude-code"
+      );
+    } else {
+      console.error("[Launcher] spawn error:", err);
+    }
+    claudeProcess = null;
+  });
+  claudeProcess.on("exit", (code) => {
+    console.error(`[Launcher] Claude Code exited with code ${code}`);
+    claudeProcess = null;
+  });
+  claudeProcess.stderr?.on("data", (chunk) => {
+    console.error(`[Claude] ${chunk.toString().trimEnd()}`);
+  });
+  claudeProcess.unref();
+  console.error(`[Launcher] Claude Code launched (pid: ${pid})`);
+  return { status: "launched", pid };
+}
+function killClaude() {
+  if (claudeProcess && !claudeProcess.killed) {
+    console.error(`[Launcher] Killing Claude Code (pid: ${claudeProcess.pid})`);
+    try {
+      claudeProcess.kill("SIGTERM");
+    } catch (err) {
+      const code = err.code;
+      if (code !== "ESRCH") {
+        console.error("[Launcher] Failed to kill Claude process:", err);
+      }
+    }
+    claudeProcess = null;
+  }
+}
+var claudeProcess, TANDEM_SYSTEM_PROMPT;
+var init_launcher = __esm({
+  "src/server/mcp/launcher.ts"() {
+    "use strict";
+    init_constants();
+    claudeProcess = null;
+    TANDEM_SYSTEM_PROMPT = [
+      "You are Claude, connected to Tandem \u2014 a collaborative document editor.",
+      "You will receive real-time push notifications via the tandem-channel when users",
+      "create annotations, send chat messages, accept/dismiss your suggestions, or switch documents.",
+      "Use your tandem MCP tools (tandem_getTextContent, tandem_comment, tandem_highlight,",
+      "tandem_suggest, tandem_edit, etc.) to review and annotate documents.",
+      "Start by calling tandem_checkInbox to see what needs attention."
+    ].join(" ");
+  }
+});
+
+// src/server/index.ts
+import path8 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+
+// src/server/mcp/server.ts
+import { createMcpExpressApp } from "@modelcontextprotocol/sdk/server/express.js";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { isInitializeRequest } from "@modelcontextprotocol/sdk/types.js";
+import { randomUUID as randomUUID3 } from "crypto";
+import { existsSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+import { createRequire } from "module";
+
+// src/server/open-browser.ts
+import { execFile } from "child_process";
+function openBrowser(url) {
+  let command;
+  let args;
+  if (process.platform === "win32") {
+    command = "cmd";
+    args = ["/c", "start", "", url];
+  } else if (process.platform === "darwin") {
+    command = "open";
+    args = [url];
+  } else {
+    command = "xdg-open";
+    args = [url];
+  }
+  execFile(command, args, (err) => {
+    if (err) {
+      console.error("[Tandem] Could not open browser automatically.");
+      console.error(`[Tandem] Open this URL manually: ${url}`);
+    }
+  });
+}
+
+// src/server/mcp/annotations.ts
+init_constants();
+init_queue();
+init_provider();
+import { z as z3 } from "zod";
+
+// src/server/mcp/document.ts
+init_provider();
+import { z as z2 } from "zod";
+import * as Y8 from "yjs";
+
+// src/server/mcp/response.ts
+function mcpSuccess(data) {
+  return {
+    content: [{ type: "text", text: JSON.stringify({ error: false, data }) }]
+  };
+}
+function mcpError(code, message, details) {
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify({ error: true, code, message, ...details && { details } })
+      }
+    ]
+  };
+}
+function noDocumentError() {
+  return mcpError("NO_DOCUMENT", "No document is open. Call tandem_open first.");
+}
+function getErrorMessage(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function withErrorBoundary(toolName, handler) {
+  return async (args) => {
+    try {
+      return await handler(args);
+    } catch (err) {
+      console.error(`[Tandem] Tool ${toolName} threw:`, err);
+      return mcpError("INTERNAL_ERROR", `${toolName} failed: ${getErrorMessage(err)}`);
+    }
+  };
+}
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// src/server/notifications.ts
+init_constants();
+var buffer2 = [];
+var subscribers2 = /* @__PURE__ */ new Set();
+function pushNotification(notification) {
+  buffer2.push(notification);
+  while (buffer2.length > NOTIFICATION_BUFFER_SIZE) {
+    buffer2.shift();
+  }
+  for (const cb of subscribers2) {
+    try {
+      cb(notification);
+    } catch (err) {
+      console.error("[Notifications] Subscriber threw during dispatch:", err);
+    }
+  }
+}
+function subscribe2(cb) {
+  subscribers2.add(cb);
+  return () => {
+    subscribers2.delete(cb);
+  };
+}
+
+// src/server/mcp/document.ts
+init_utils();
+init_offsets();
+init_file_io();
+
+// src/server/mcp/convert.ts
+init_provider();
+init_document_model();
+init_file_io();
+init_file_opener();
+init_document_service();
+import fs4 from "fs/promises";
+import path7 from "path";
+async function findAvailablePath(basePath) {
+  const dir = path7.dirname(basePath);
+  const ext = path7.extname(basePath);
+  const name = path7.basename(basePath, ext);
+  const MAX_ATTEMPTS = 1e3;
+  let candidate = basePath;
+  let counter = 0;
+  while (counter <= MAX_ATTEMPTS) {
+    try {
+      await fs4.access(candidate);
+      counter++;
+      candidate = path7.join(dir, `${name}-${counter}${ext}`);
+    } catch (err) {
+      const code = err.code;
+      if (code === "ENOENT") return candidate;
+      throw err;
+    }
+  }
+  throw Object.assign(new Error("Could not find an available filename after 1000 attempts."), {
+    code: "CONFLICT"
+  });
+}
+async function convertToMarkdown(documentId, outputPath) {
+  const docState = getCurrentDoc(documentId);
+  if (!docState) {
+    throw Object.assign(new Error("Document not found."), { code: "FILE_NOT_FOUND" });
+  }
+  if (docState.format !== "docx") {
+    throw Object.assign(new Error("Only .docx documents can be converted to Markdown."), {
+      code: "UNSUPPORTED_FORMAT"
+    });
+  }
+  if (docState.source === "upload") {
+    throw Object.assign(
+      new Error(
+        "Uploaded .docx files cannot be converted \u2014 no disk location to write the .md file."
+      ),
+      { code: "INVALID_PATH" }
+    );
+  }
+  const doc = getOrCreateDocument(docState.id);
+  const markdown = extractMarkdown(doc);
+  if (!markdown.trim()) {
+    throw Object.assign(
+      new Error("Conversion produced empty output \u2014 the .docx may not contain extractable text."),
+      { code: "EMPTY_CONVERSION" }
+    );
+  }
+  const sourceDir = path7.dirname(docState.filePath);
+  let resolvedOutput;
+  if (outputPath) {
+    resolvedOutput = path7.resolve(outputPath);
+    if (resolvedOutput.startsWith("\\\\") || resolvedOutput.startsWith("//")) {
+      throw Object.assign(new Error("UNC paths are not supported for security reasons."), {
+        code: "INVALID_PATH"
+      });
+    }
+    try {
+      const stat = await fs4.stat(resolvedOutput);
+      if (stat.isDirectory()) {
+        const baseName = path7.basename(docState.filePath, path7.extname(docState.filePath));
+        resolvedOutput = path7.join(resolvedOutput, `${baseName}.md`);
+      }
+    } catch (err) {
+      const code = err.code;
+      if (code !== "ENOENT") throw err;
+    }
+  } else {
+    const baseName = path7.basename(docState.filePath, path7.extname(docState.filePath));
+    resolvedOutput = path7.join(sourceDir, `${baseName}.md`);
+  }
+  resolvedOutput = await findAvailablePath(resolvedOutput);
+  await atomicWrite(resolvedOutput, markdown);
+  try {
+    const openResult = await openFileByPath(resolvedOutput);
+    return {
+      outputPath: resolvedOutput,
+      documentId: openResult.documentId,
+      fileName: openResult.fileName
+    };
+  } catch (err) {
+    throw Object.assign(
+      new Error(
+        `Markdown written to ${resolvedOutput} but failed to open: ${err.message}`
+      ),
+      { code: "OPEN_FAILED" }
+    );
+  }
+}
+
+// src/server/mcp/document.ts
+init_manager();
+init_file_opener();
+init_constants();
+init_types2();
+init_queue();
+init_document_model();
+init_positions2();
+init_document_service();
+init_document_model();
+init_positions2();
+init_document_service();
+init_file_opener();
+function getOutline(fragment) {
+  const outline = [];
+  for (let i = 0; i < fragment.length; i++) {
+    const node = fragment.get(i);
+    if (node instanceof Y8.XmlElement && node.nodeName === "heading") {
+      const level = Number(node.getAttribute("level") ?? 1);
+      outline.push({ level, text: getElementText(node), index: i });
+    }
+  }
+  return outline;
+}
+function getSection(fragment, sectionName) {
+  const lines = [];
+  let inSection = false;
+  let sectionLevel = 0;
+  for (let i = 0; i < fragment.length; i++) {
+    const node = fragment.get(i);
+    if (!(node instanceof Y8.XmlElement)) continue;
+    const text = getElementText(node);
+    if (node.nodeName === "heading") {
+      const level = Number(node.getAttribute("level") ?? 1);
+      if (inSection && level <= sectionLevel) break;
+      if (text.trim().toLowerCase() === sectionName.trim().toLowerCase()) {
+        inSection = true;
+        sectionLevel = level;
+        lines.push(headingPrefix(level) + text);
+        continue;
+      }
+    }
+    if (inSection) {
+      if (node.nodeName === "heading") {
+        const level = Number(node.getAttribute("level") ?? 1);
+        lines.push(headingPrefix(level) + text);
+      } else {
+        lines.push(text);
+      }
+    }
+  }
+  if (!inSection) return { found: false };
+  return { found: true, text: lines.join("\n") };
+}
+function registerDocumentTools(server) {
+  const openDocs2 = getOpenDocs();
+  server.tool(
+    "tandem_open",
+    "Open a file in the Tandem editor. Returns a documentId for multi-document workflows. Auto-opens browser. Pass force=true to reload from disk if the file changed externally.",
+    {
+      filePath: z2.string().describe("Absolute path to the file to open"),
+      force: z2.boolean().optional().describe("Force reload from disk even if already open. Clears annotations and session.")
+    },
+    withErrorBoundary("tandem_open", async ({ filePath, force }) => {
+      try {
+        const result = await openFileByPath(filePath, { force });
+        return mcpSuccess({
+          ...result,
+          message: result.forceReloaded ? `Force-reloaded from disk: ${result.fileName}` : result.alreadyOpen ? `Switched to already-open document: ${result.fileName}` : result.restoredFromSession ? `Session restored: ${result.fileName} (annotations preserved)` : result.readOnly ? `Document opened (review only): ${result.fileName}` : `Document opened: ${result.fileName}`
+        });
+      } catch (err) {
+        const e = err;
+        if (e.code === "ENOENT" || e.code === "FILE_NOT_FOUND") {
+          return mcpError("FILE_NOT_FOUND", e.message);
+        }
+        if (e.code === "INVALID_PATH") {
+          return mcpError("FILE_NOT_FOUND", e.message);
+        }
+        if (e.code === "UNSUPPORTED_FORMAT" || e.code === "FILE_TOO_LARGE") {
+          return mcpError("FORMAT_ERROR", e.message);
+        }
+        if (e.code === "EBUSY" || e.code === "EPERM") {
+          return mcpError(
+            "FILE_LOCKED",
+            `File is locked \u2014 another program (likely Microsoft Word) has it open. Close it and try again.`
+          );
+        }
+        if (e.code === "EACCES") {
+          return mcpError("PERMISSION_DENIED", e.message);
+        }
+        return mcpError("FORMAT_ERROR", getErrorMessage(err));
+      }
+    })
+  );
+  server.tool(
+    "tandem_getContent",
+    "Read full document content. Warning: token-heavy for large docs. Use getOutline() or getTextContent() instead.",
+    {
+      documentId: z2.string().optional().describe("Target document ID (defaults to active document)")
+    },
+    withErrorBoundary("tandem_getContent", async ({ documentId }) => {
+      const r = requireDocument(documentId);
+      if (!r) return noDocumentError();
+      const fragment = r.doc.getXmlFragment("default");
+      return mcpSuccess({ content: fragment.toJSON(), filePath: r.filePath, documentId: r.docId });
+    })
+  );
+  server.tool(
+    "tandem_getTextContent",
+    "Read document as plain text. ~60% fewer tokens than getContent().",
+    {
+      section: z2.string().optional().describe("Optional heading text to read only that section"),
+      documentId: z2.string().optional().describe("Target document ID (defaults to active document)")
+    },
+    withErrorBoundary("tandem_getTextContent", async ({ section, documentId }) => {
+      const r = requireDocument(documentId);
+      if (!r) return noDocumentError();
+      if (section) {
+        const fragment = r.doc.getXmlFragment("default");
+        const result = getSection(fragment, section);
+        if (!result.found) {
+          return mcpError("INVALID_RANGE", `Section "${section}" not found in document.`);
+        }
+        return mcpSuccess({ text: result.text, filePath: r.filePath, section });
+      }
+      const text = extractText(r.doc);
+      return mcpSuccess({ text, filePath: r.filePath, documentId: r.docId });
+    })
+  );
+  server.tool(
+    "tandem_getOutline",
+    "Get document structure (headings, sections) without full content. Low token cost.",
+    {
+      documentId: z2.string().optional().describe("Target document ID (defaults to active document)")
+    },
+    withErrorBoundary("tandem_getOutline", async ({ documentId }) => {
+      const r = requireDocument(documentId);
+      if (!r) return noDocumentError();
+      const fragment = r.doc.getXmlFragment("default");
+      const outline = getOutline(fragment);
+      return mcpSuccess({ outline, totalNodes: fragment.length });
+    })
+  );
+  server.tool(
+    "tandem_edit",
+    "Edit text in the document at a specific range. For single-paragraph replacements only \u2014 newlines in newText are inserted as literal text.",
+    {
+      from: z2.number().describe("Start position (character offset)"),
+      to: z2.number().describe("End position (character offset)"),
+      newText: z2.string().describe("Replacement text (single paragraph \u2014 no newlines)"),
+      documentId: z2.string().optional().describe("Target document ID (defaults to active document)"),
+      textSnapshot: z2.string().optional().describe(
+        "Expected text at [from, to] \u2014 returns RANGE_MOVED with relocated range on mismatch, or RANGE_GONE if text was deleted"
+      )
+    },
+    withErrorBoundary(
+      "tandem_edit",
+      async ({ from: rawFrom, to: rawTo, newText, documentId, textSnapshot }) => {
+        const r = requireDocument(documentId);
+        if (!r) return noDocumentError();
+        const docState = getCurrentDoc(documentId);
+        if (docState?.readOnly) {
+          return mcpError(
+            "FORMAT_ERROR",
+            "Document is read-only (.docx). Use annotations instead."
+          );
+        }
+        const from = toFlatOffset(rawFrom);
+        const to = toFlatOffset(rawTo);
+        const v = validateRange(r.doc, from, to, {
+          textSnapshot,
+          rejectHeadingOverlap: true
+        });
+        if (!v.ok) {
+          if (v.code === "RANGE_GONE") {
+            return mcpError("RANGE_GONE", "Target text no longer exists in the document.");
+          }
+          if (v.code === "RANGE_MOVED") {
+            return mcpError(
+              "RANGE_MOVED",
+              "Target text has moved. Use resolvedFrom/resolvedTo to retry.",
+              { resolvedFrom: v.resolvedFrom, resolvedTo: v.resolvedTo }
+            );
+          }
+          if (v.code === "HEADING_OVERLAP") {
+            return mcpError(
+              "INVALID_RANGE",
+              'Edit range overlaps with heading markup (e.g., "## "). Target the text content only. Use tandem_resolveRange to find the text position.'
+            );
+          }
+          return mcpError("INVALID_RANGE", v.message);
+        }
+        const fragment = r.doc.getXmlFragment("default");
+        const startPos = resolveToElement(fragment, from);
+        const endPos = resolveToElement(fragment, to);
+        if (!startPos || !endPos) {
+          return mcpError(
+            "INVALID_RANGE",
+            `Cannot resolve offset range [${from}, ${to}] in document.`
+          );
+        }
+        if (startPos.elementIndex !== endPos.elementIndex) {
+          r.doc.transact(() => {
+            const startNode = fragment.get(startPos.elementIndex);
+            const startText = getOrCreateXmlText(startNode);
+            const startLen = startText.toString().length;
+            if (startPos.textOffset < startLen) {
+              startText.delete(startPos.textOffset, startLen - startPos.textOffset);
+            }
+            const deleteCount = endPos.elementIndex - startPos.elementIndex - 1;
+            for (let i = 0; i < deleteCount; i++) {
+              fragment.delete(startPos.elementIndex + 1, 1);
+            }
+            const endNode = fragment.get(startPos.elementIndex + 1);
+            const endText = getOrCreateXmlText(endNode);
+            if (endPos.textOffset > 0) {
+              endText.delete(0, endPos.textOffset);
+            }
+            const remainingText = endText.toString();
+            if (remainingText.length > 0) {
+              startText.insert(startPos.textOffset, remainingText);
+            }
+            fragment.delete(startPos.elementIndex + 1, 1);
+            startText.insert(startPos.textOffset, newText);
+          }, MCP_ORIGIN);
+        } else {
+          r.doc.transact(() => {
+            const node = fragment.get(startPos.elementIndex);
+            const textNode = getOrCreateXmlText(node);
+            const deleteLen = endPos.textOffset - startPos.textOffset;
+            if (deleteLen > 0) {
+              textNode.delete(startPos.textOffset, deleteLen);
+            }
+            if (newText.length > 0) {
+              textNode.insert(startPos.textOffset, newText);
+            }
+          }, MCP_ORIGIN);
+        }
+        return mcpSuccess({ edited: true, from, to, newTextLength: newText.length });
+      }
+    )
+  );
+  server.tool(
+    "tandem_save",
+    "Save the current document back to disk",
+    {
+      documentId: z2.string().optional().describe("Target document ID (defaults to active document)")
+    },
+    withErrorBoundary("tandem_save", async ({ documentId }) => {
+      const r = requireDocument(documentId);
+      if (!r) return noDocumentError();
+      try {
+        const docState = getCurrentDoc(documentId);
+        const format = docState?.format ?? "txt";
+        const readOnly = docState?.readOnly ?? false;
+        if (docState?.source === "upload") {
+          await saveSession(r.filePath, format, r.doc);
+          return mcpSuccess({
+            saved: true,
+            sessionOnly: true,
+            filePath: r.filePath,
+            message: "Session saved (annotations preserved). This file was uploaded \u2014 no disk path to save to."
+          });
+        }
+        const adapter = getAdapter(format);
+        if (readOnly || !adapter.canSave) {
+          await saveSession(r.filePath, format, r.doc);
+          return mcpSuccess({
+            saved: true,
+            sessionOnly: true,
+            filePath: r.filePath,
+            message: "Session saved (annotations preserved). Source file unchanged \u2014 document is read-only."
+          });
+        }
+        const output = adapter.save(r.doc);
+        await atomicWrite(r.filePath, output);
+        await saveSession(r.filePath, format, r.doc);
+        const meta = r.doc.getMap(Y_MAP_DOCUMENT_META);
+        r.doc.transact(() => meta.set(Y_MAP_SAVED_AT_VERSION, Date.now()), MCP_ORIGIN);
+        return mcpSuccess({ saved: true, filePath: r.filePath });
+      } catch (err) {
+        const errCode = err.code;
+        const msg = getErrorMessage(err);
+        pushNotification({
+          id: generateNotificationId(),
+          type: "save-error",
+          severity: "error",
+          message: `Save failed: ${msg}`,
+          toolName: "tandem_save",
+          errorCode: errCode ?? "UNKNOWN",
+          documentId: r.docId,
+          dedupKey: `save:${r.docId}`,
+          timestamp: Date.now()
+        });
+        if (errCode === "EACCES" || errCode === "EPERM") {
+          return mcpError("FILE_LOCKED", msg);
+        }
+        return mcpError("FORMAT_ERROR", `Save failed: ${msg}`);
+      }
+    })
+  );
+  server.tool(
+    "tandem_status",
+    "Check editor status: running, open documents, active document",
+    {},
+    withErrorBoundary("tandem_status", async () => {
+      const activeId = getActiveDocId();
+      const active = activeId ? openDocs2.get(activeId) : null;
+      let interruptionMode = INTERRUPTION_MODE_DEFAULT;
+      if (activeId) {
+        const doc = getOrCreateDocument(activeId);
+        const awareness = doc.getMap(Y_MAP_USER_AWARENESS);
+        interruptionMode = awareness.get("interruptionMode") ?? INTERRUPTION_MODE_DEFAULT;
+      }
+      return mcpSuccess({
+        running: true,
+        interruptionMode,
+        activeDocument: active ? { documentId: active.id, filePath: active.filePath, format: active.format } : null,
+        openDocuments: Array.from(openDocs2.values()).map((d) => ({
+          documentId: d.id,
+          filePath: d.filePath,
+          format: d.format,
+          readOnly: d.readOnly
+        })),
+        documentCount: docCount()
+      });
+    })
+  );
+  server.tool(
+    "tandem_close",
+    "Close a document. Closes the active document if no documentId specified.",
+    {
+      documentId: z2.string().optional().describe("Document ID to close (defaults to active document)")
+    },
+    withErrorBoundary("tandem_close", async ({ documentId }) => {
+      const id = documentId ?? getActiveDocId();
+      if (!id) return mcpError("NO_DOCUMENT", "No document to close.");
+      const result = await closeDocumentById(id);
+      if (!result.success) return mcpError("NO_DOCUMENT", result.error);
+      return mcpSuccess({
+        closed: true,
+        was: result.closedPath,
+        activeDocumentId: result.activeDocumentId
+      });
+    })
+  );
+  server.tool(
+    "tandem_listDocuments",
+    "List all open documents with their IDs, file paths, and formats.",
+    {},
+    withErrorBoundary("tandem_listDocuments", async () => {
+      return mcpSuccess({
+        documents: Array.from(openDocs2.values()).map((d) => ({
+          ...toDocListEntry(d),
+          isActive: d.id === getActiveDocId()
+        })),
+        activeDocumentId: getActiveDocId(),
+        count: docCount()
+      });
+    })
+  );
+  server.tool(
+    "tandem_switchDocument",
+    "Switch the active document. Tools will operate on this document by default.",
+    {
+      documentId: z2.string().describe("Document ID to switch to")
+    },
+    withErrorBoundary("tandem_switchDocument", async ({ documentId }) => {
+      if (!hasDoc(documentId)) {
+        return mcpError("NO_DOCUMENT", `Document ${documentId} is not open.`);
+      }
+      setActiveDocId(documentId);
+      broadcastOpenDocs();
+      return mcpSuccess({
+        activeDocumentId: documentId,
+        ...toDocListEntry(openDocs2.get(documentId))
+      });
+    })
+  );
+  server.tool(
+    "tandem_convertToMarkdown",
+    "Convert a .docx document to an editable Markdown file. Writes the .md file to disk and opens it as a new tab.",
+    {
+      documentId: z2.string().optional().describe("Document ID of the .docx to convert (defaults to active document)"),
+      outputPath: z2.string().optional().describe("Custom output path for the .md file (defaults to same directory as the .docx)")
+    },
+    withErrorBoundary("tandem_convertToMarkdown", async ({ documentId, outputPath }) => {
+      try {
+        const result = await convertToMarkdown(documentId, outputPath);
+        return mcpSuccess({
+          converted: true,
+          outputPath: result.outputPath,
+          documentId: result.documentId,
+          fileName: result.fileName,
+          message: `Converted to Markdown: ${result.fileName}`
+        });
+      } catch (err) {
+        const e = err;
+        if (e.code === "FILE_NOT_FOUND") return noDocumentError();
+        if (e.code === "UNSUPPORTED_FORMAT" || e.code === "INVALID_PATH" || e.code === "EMPTY_CONVERSION" || e.code === "OPEN_FAILED") {
+          return mcpError("FORMAT_ERROR", e.message);
+        }
+        throw err;
+      }
+    })
+  );
+}
+
+// src/server/mcp/annotations.ts
+init_docx();
+init_types2();
+init_positions2();
+init_utils();
+init_positions2();
+function getDocAndAnnotations(documentId) {
+  const doc = getCurrentDoc(documentId);
+  if (!doc) return null;
+  const ydoc = getOrCreateDocument(doc.docName);
+  return { ydoc, map: ydoc.getMap(Y_MAP_ANNOTATIONS) };
+}
+function rangeFailureMessage(result) {
+  if (result.code === "RANGE_GONE") return "Target text no longer exists in the document.";
+  if (result.code === "RANGE_MOVED") return "Target text has moved.";
+  if (result.code === "INVALID_RANGE") return result.message;
+  return 'Range overlaps with heading markup (e.g., "## "). Target the text content only.';
+}
+function rangeFailureToError(result) {
+  if (result.code === "RANGE_GONE") {
+    return mcpError("RANGE_GONE", "Target text no longer exists in the document.");
+  }
+  if (result.code === "RANGE_MOVED") {
+    return mcpError("RANGE_MOVED", "Target text has moved. Use resolvedFrom/resolvedTo to retry.", {
+      resolvedFrom: result.resolvedFrom,
+      resolvedTo: result.resolvedTo
+    });
+  }
+  if (result.code === "INVALID_RANGE") {
+    return mcpError("INVALID_RANGE", result.message);
+  }
+  return mcpError(
+    "INVALID_RANGE",
+    'Range overlaps with heading markup (e.g., "## "). Target the text content only.'
+  );
+}
+function notifyRangeFailure(result, toolName, documentId) {
+  pushNotification({
+    id: generateNotificationId(),
+    type: "annotation-error",
+    severity: "error",
+    message: `Annotation failed: ${rangeFailureMessage(result)}`,
+    toolName,
+    errorCode: result.code,
+    documentId,
+    dedupKey: `${toolName}:${result.code}`,
+    timestamp: Date.now()
+  });
+}
+var SNAPSHOT_CAP = 200;
+function captureSnapshot(ydoc, from, to) {
+  const text = extractText(ydoc).slice(from, to);
+  return text.length > SNAPSHOT_CAP ? text.slice(0, SNAPSHOT_CAP - 3) + "..." : text;
+}
+function createAnnotation(map, ydoc, type, anchored, content, extras) {
+  const id = generateAnnotationId();
+  const annotation = {
+    id,
+    author: "claude",
+    type,
+    range: anchored.range,
+    ...anchored.relRange ? { relRange: anchored.relRange } : {},
+    content,
+    status: "pending",
+    timestamp: Date.now(),
+    ...extras
+  };
+  ydoc.transact(() => map.set(id, annotation), MCP_ORIGIN);
+  return id;
+}
+function collectAnnotations(map) {
+  const result = [];
+  map.forEach((value) => result.push(value));
+  return result;
+}
+function registerAnnotationTools(server) {
+  server.tool(
+    "tandem_highlight",
+    "Highlight text with a color and optional note",
+    {
+      from: z3.number().describe("Start position"),
+      to: z3.number().describe("End position"),
+      color: HighlightColorSchema.describe("Highlight color"),
+      note: z3.string().optional().describe("Optional note for the highlight"),
+      documentId: z3.string().optional().describe("Target document ID (defaults to active document)"),
+      priority: AnnotationPrioritySchema.optional().describe(
+        "Annotation priority. Set to 'urgent' for critical issues that should be visible even when the user has interruption mode set to urgent-only. Flags and questions are implicitly urgent."
+      ),
+      textSnapshot: z3.string().optional().describe(
+        "Expected text at [from, to] \u2014 returns RANGE_MOVED with relocated range on mismatch, or RANGE_GONE if text was deleted"
+      )
+    },
+    withErrorBoundary(
+      "tandem_highlight",
+      async ({ from: rawFrom, to: rawTo, color, note, documentId, priority, textSnapshot }) => {
+        const da = getDocAndAnnotations(documentId);
+        if (!da) return noDocumentError();
+        const from = toFlatOffset(rawFrom);
+        const to = toFlatOffset(rawTo);
+        const result = anchoredRange(da.ydoc, from, to, textSnapshot);
+        if (!result.ok) {
+          notifyRangeFailure(result, "tandem_highlight", documentId);
+          return rangeFailureToError(result);
+        }
+        const snap = captureSnapshot(da.ydoc, result.range.from, result.range.to);
+        const id = createAnnotation(da.map, da.ydoc, "highlight", result, note || "", {
+          color,
+          ...priority ? { priority } : {},
+          textSnapshot: snap
+        });
+        return mcpSuccess({ annotationId: id });
+      }
+    )
+  );
+  server.tool(
+    "tandem_comment",
+    "Add a comment to a text range",
+    {
+      from: z3.number().describe("Start position"),
+      to: z3.number().describe("End position"),
+      text: z3.string().describe("Comment text"),
+      documentId: z3.string().optional().describe("Target document ID (defaults to active document)"),
+      priority: AnnotationPrioritySchema.optional().describe(
+        "Annotation priority. Set to 'urgent' for critical issues that should be visible even when the user has interruption mode set to urgent-only. Flags and questions are implicitly urgent."
+      ),
+      textSnapshot: z3.string().optional().describe(
+        "Expected text at [from, to] \u2014 returns RANGE_MOVED with relocated range on mismatch, or RANGE_GONE if text was deleted"
+      )
+    },
+    withErrorBoundary(
+      "tandem_comment",
+      async ({ from: rawFrom, to: rawTo, text, documentId, priority, textSnapshot }) => {
+        const da = getDocAndAnnotations(documentId);
+        if (!da) return noDocumentError();
+        const from = toFlatOffset(rawFrom);
+        const to = toFlatOffset(rawTo);
+        const result = anchoredRange(da.ydoc, from, to, textSnapshot);
+        if (!result.ok) {
+          notifyRangeFailure(result, "tandem_comment", documentId);
+          return rangeFailureToError(result);
+        }
+        const snap = captureSnapshot(da.ydoc, result.range.from, result.range.to);
+        const id = createAnnotation(da.map, da.ydoc, "comment", result, text, {
+          ...priority ? { priority } : {},
+          textSnapshot: snap
+        });
+        return mcpSuccess({ annotationId: id });
+      }
+    )
+  );
+  server.tool(
+    "tandem_suggest",
+    "Propose a text replacement (tracked change style)",
+    {
+      from: z3.number().describe("Start position"),
+      to: z3.number().describe("End position"),
+      newText: z3.string().describe("Suggested replacement text"),
+      reason: z3.string().optional().describe("Reason for the suggestion"),
+      documentId: z3.string().optional().describe("Target document ID (defaults to active document)"),
+      priority: AnnotationPrioritySchema.optional().describe(
+        "Annotation priority. Set to 'urgent' for critical issues that should be visible even when the user has interruption mode set to urgent-only. Flags and questions are implicitly urgent."
+      ),
+      textSnapshot: z3.string().optional().describe(
+        "Expected text at [from, to] \u2014 returns RANGE_MOVED with relocated range on mismatch, or RANGE_GONE if text was deleted"
+      )
+    },
+    withErrorBoundary(
+      "tandem_suggest",
+      async ({ from: rawFrom, to: rawTo, newText, reason, documentId, priority, textSnapshot }) => {
+        const da = getDocAndAnnotations(documentId);
+        if (!da) return noDocumentError();
+        const from = toFlatOffset(rawFrom);
+        const to = toFlatOffset(rawTo);
+        const result = anchoredRange(da.ydoc, from, to, textSnapshot);
+        if (!result.ok) {
+          notifyRangeFailure(result, "tandem_suggest", documentId);
+          return rangeFailureToError(result);
+        }
+        const snap = captureSnapshot(da.ydoc, result.range.from, result.range.to);
+        const id = createAnnotation(
+          da.map,
+          da.ydoc,
+          "suggestion",
+          result,
+          JSON.stringify({ newText, reason: reason || "" }),
+          { ...priority ? { priority } : {}, textSnapshot: snap }
+        );
+        return mcpSuccess({ annotationId: id });
+      }
+    )
+  );
+  server.tool(
+    "tandem_flag",
+    "Flag a text range for attention (e.g., issues, concerns, or items needing review)",
+    {
+      from: z3.number().describe("Start position"),
+      to: z3.number().describe("End position"),
+      note: z3.string().optional().describe("Reason for flagging"),
+      documentId: z3.string().optional().describe("Target document ID (defaults to active document)"),
+      priority: AnnotationPrioritySchema.optional().describe(
+        "Annotation priority. Set to 'urgent' for critical issues that should be visible even when the user has interruption mode set to urgent-only. Flags and questions are implicitly urgent."
+      ),
+      textSnapshot: z3.string().optional().describe(
+        "Expected text at [from, to] \u2014 returns RANGE_MOVED with relocated range on mismatch, or RANGE_GONE if text was deleted"
+      )
+    },
+    withErrorBoundary(
+      "tandem_flag",
+      async ({ from: rawFrom, to: rawTo, note, documentId, priority, textSnapshot }) => {
+        const da = getDocAndAnnotations(documentId);
+        if (!da) return noDocumentError();
+        const from = toFlatOffset(rawFrom);
+        const to = toFlatOffset(rawTo);
+        const result = anchoredRange(da.ydoc, from, to, textSnapshot);
+        if (!result.ok) {
+          notifyRangeFailure(result, "tandem_flag", documentId);
+          return rangeFailureToError(result);
+        }
+        const snap = captureSnapshot(da.ydoc, result.range.from, result.range.to);
+        const id = createAnnotation(da.map, da.ydoc, "flag", result, note || "", {
+          ...priority ? { priority } : {},
+          textSnapshot: snap
+        });
+        return mcpSuccess({ annotationId: id });
+      }
+    )
+  );
+  server.tool(
+    "tandem_getAnnotations",
+    "Read all annotations, optionally filtered by author/type/status. For checking new user actions, prefer tandem_checkInbox.",
+    {
+      author: AuthorSchema.optional().describe("Filter by author"),
+      type: AnnotationTypeSchema.optional().describe("Filter by type"),
+      status: AnnotationStatusSchema.optional().describe("Filter by status"),
+      documentId: z3.string().optional().describe("Target document ID (defaults to active document)")
+    },
+    withErrorBoundary("tandem_getAnnotations", async ({ author, type, status, documentId }) => {
+      const da = getDocAndAnnotations(documentId);
+      if (!da) return noDocumentError();
+      let results = refreshAllRanges(collectAnnotations(da.map), da.ydoc, da.map);
+      if (author) results = results.filter((a) => a.author === author);
+      if (type) results = results.filter((a) => a.type === type);
+      if (status) results = results.filter((a) => a.status === status);
+      return mcpSuccess({ annotations: results, count: results.length });
+    })
+  );
+  server.tool(
+    "tandem_resolveAnnotation",
+    "Accept or dismiss an annotation",
+    {
+      id: z3.string().describe("Annotation ID"),
+      action: AnnotationActionSchema.describe("Action to take"),
+      documentId: z3.string().optional().describe("Target document ID (defaults to active document)")
+    },
+    withErrorBoundary("tandem_resolveAnnotation", async ({ id, action, documentId }) => {
+      const da = getDocAndAnnotations(documentId);
+      if (!da) return noDocumentError();
+      const ann = da.map.get(id);
+      if (!ann) return mcpError("INVALID_RANGE", `Annotation ${id} not found`);
+      const updated = {
+        ...ann,
+        status: action === "accept" ? "accepted" : "dismissed"
+      };
+      da.ydoc.transact(() => da.map.set(id, updated), MCP_ORIGIN);
+      return mcpSuccess({ id, status: updated.status });
+    })
+  );
+  server.tool(
+    "tandem_removeAnnotation",
+    "Remove an annotation entirely",
+    {
+      id: z3.string().describe("Annotation ID"),
+      documentId: z3.string().optional().describe("Target document ID (defaults to active document)")
+    },
+    withErrorBoundary("tandem_removeAnnotation", async ({ id, documentId }) => {
+      const da = getDocAndAnnotations(documentId);
+      if (!da) return noDocumentError();
+      if (!da.map.has(id)) return mcpError("INVALID_RANGE", `Annotation ${id} not found`);
+      da.ydoc.transact(() => da.map.delete(id), MCP_ORIGIN);
+      return mcpSuccess({ removed: true, id });
+    })
+  );
+  server.tool(
+    "tandem_editAnnotation",
+    "Edit the content of an existing annotation. For suggestions, use newText/reason params; for other types, use content.",
+    {
+      id: z3.string().describe("Annotation ID"),
+      content: z3.string().optional().describe("New text for non-suggestion annotations"),
+      newText: z3.string().optional().describe("For suggestions: new replacement text"),
+      reason: z3.string().optional().describe("For suggestions: new reason"),
+      documentId: z3.string().optional().describe("Target document ID (defaults to active document)")
+    },
+    withErrorBoundary(
+      "tandem_editAnnotation",
+      async ({ id, content, newText, reason, documentId }) => {
+        const da = getDocAndAnnotations(documentId);
+        if (!da) return noDocumentError();
+        const ann = da.map.get(id);
+        if (!ann) return mcpError("INVALID_RANGE", `Annotation ${id} not found`);
+        if (ann.status !== "pending") {
+          return mcpError("INVALID_RANGE", `Cannot edit a ${ann.status} annotation`);
+        }
+        let updatedContent;
+        if (ann.type === "suggestion") {
+          if (content !== void 0 && newText === void 0 && reason === void 0) {
+            updatedContent = content;
+          } else if (newText !== void 0 || reason !== void 0) {
+            let existing;
+            try {
+              existing = JSON.parse(ann.content);
+            } catch {
+              console.error(
+                `[tandem_editAnnotation] Malformed existing content for suggestion ${id}`
+              );
+              return mcpError(
+                "INVALID_RANGE",
+                `Suggestion ${id} has malformed content \u2014 cannot merge fields. Use 'content' to replace entirely.`
+              );
+            }
+            updatedContent = JSON.stringify({
+              newText: newText !== void 0 ? newText : existing.newText,
+              reason: reason !== void 0 ? reason : existing.reason
+            });
+          } else {
+            return mcpError(
+              "INVALID_RANGE",
+              "No editable fields provided. Use newText/reason for suggestions, or content."
+            );
+          }
+        } else {
+          if (content === void 0) {
+            return mcpError(
+              "INVALID_RANGE",
+              "No editable fields provided. Use content for non-suggestion annotations."
+            );
+          }
+          updatedContent = content;
+        }
+        const updated = { ...ann, content: updatedContent, editedAt: Date.now() };
+        da.ydoc.transact(() => da.map.set(id, updated), MCP_ORIGIN);
+        return mcpSuccess({ id, content: updatedContent, editedAt: updated.editedAt });
+      }
+    )
+  );
+  server.tool(
+    "tandem_exportAnnotations",
+    "Export all annotations as a formatted summary. Useful for review reports, especially on read-only .docx files.",
+    {
+      format: ExportFormatSchema.optional().describe("Output format (default: markdown)"),
+      documentId: z3.string().optional().describe("Target document ID (defaults to active document)")
+    },
+    withErrorBoundary("tandem_exportAnnotations", async ({ format, documentId }) => {
+      const da = getDocAndAnnotations(documentId);
+      if (!da) return noDocumentError();
+      const annotations = refreshAllRanges(collectAnnotations(da.map), da.ydoc, da.map);
+      const { ydoc } = da;
+      if (format === "json") {
+        const fullText = extractText(ydoc);
+        const enriched = annotations.map((ann) => ({
+          ...ann,
+          textSnippet: fullText.slice(
+            Math.max(0, ann.range.from),
+            Math.min(fullText.length, ann.range.to)
+          )
+        }));
+        return mcpSuccess({ annotations: enriched, count: enriched.length });
+      }
+      const markdown = exportAnnotations(ydoc, annotations);
+      return mcpSuccess({ markdown, count: annotations.length });
+    })
+  );
+}
+
+// src/server/mcp/api-routes.ts
+init_constants();
+init_document_model();
+init_file_opener();
+init_document_service();
+function isHostAllowed(host) {
+  const reqHost = (host ?? "").split(":")[0];
+  return reqHost === "localhost" || reqHost === "127.0.0.1";
+}
+var LOCALHOST_ORIGIN_RE = /^https?:\/\/(localhost|127\.0\.0\.1)(:\d+)?$/;
+function isLocalhostOrigin(origin) {
+  return LOCALHOST_ORIGIN_RE.test(origin ?? "");
+}
+function errorCodeToHttpStatus(code) {
+  switch (code) {
+    case "ENOENT":
+    case "FILE_NOT_FOUND":
+      return 404;
+    case "INVALID_PATH":
+    case "UNSUPPORTED_FORMAT":
+      return 400;
+    case "FILE_TOO_LARGE":
+      return 413;
+    case "EBUSY":
+    case "EPERM":
+      return 423;
+    case "EACCES":
+      return 403;
+    default:
+      return 500;
+  }
+}
+function apiMiddleware(req, res, next) {
+  if (!isHostAllowed(req.headers.host)) {
+    res.status(403).json({ error: "FORBIDDEN", message: "Host not allowed." });
+    return;
+  }
+  const origin = req.headers.origin;
+  res.header("Access-Control-Allow-Origin", isLocalhostOrigin(origin) ? origin : "null");
+  res.header("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+  res.header("Access-Control-Allow-Headers", "Content-Type");
+  if (req.method === "OPTIONS") {
+    res.sendStatus(204);
+    return;
+  }
+  next();
+}
+function errorCodeToLabel(code) {
+  switch (code) {
+    case "ENOENT":
+    case "FILE_NOT_FOUND":
+      return "FILE_NOT_FOUND";
+    case "INVALID_PATH":
+      return "INVALID_PATH";
+    case "UNSUPPORTED_FORMAT":
+      return "UNSUPPORTED_FORMAT";
+    case "FILE_TOO_LARGE":
+      return "FILE_TOO_LARGE";
+    case "EBUSY":
+    case "EPERM":
+      return "FILE_LOCKED";
+    case "EACCES":
+      return "PERMISSION_DENIED";
+    default:
+      return "INTERNAL";
+  }
+}
+function sendApiError(res, err) {
+  const e = err;
+  const code = e.code ?? "";
+  const status = errorCodeToHttpStatus(code);
+  const label = errorCodeToLabel(code);
+  const msg = label === "FILE_LOCKED" ? "File is locked by another program." : e.message ?? String(err);
+  if (status === 500) console.error("[Tandem] Unhandled API error:", err);
+  res.status(status).json({ error: label, message: msg });
+}
+function notifyStreamHandler(req, res) {
+  res.writeHead(200, {
+    "Content-Type": "text/event-stream",
+    "Cache-Control": "no-cache",
+    Connection: "keep-alive"
+  });
+  res.write(": connected\n\n");
+  function cleanup() {
+    clearInterval(keepalive);
+    unsubscribe2();
+  }
+  const unsubscribe2 = subscribe2((notification) => {
+    try {
+      res.write(`data: ${JSON.stringify(notification)}
+
+`);
+    } catch (err) {
+      console.error(
+        "[NotifyStream] Write failed, cleaning up:",
+        err instanceof Error ? err.message : err
+      );
+      cleanup();
+    }
+  });
+  const keepalive = setInterval(() => {
+    try {
+      if (!res.writableEnded) res.write(": keepalive\n\n");
+    } catch {
+      cleanup();
+    }
+  }, CHANNEL_SSE_KEEPALIVE_MS);
+  req.on("close", () => {
+    cleanup();
+    console.error("[NotifyStream] Client disconnected from /api/notify-stream");
+  });
+  console.error("[NotifyStream] Client connected to /api/notify-stream");
+}
+function registerApiRoutes(app, largeBody) {
+  app.get("/api/notify-stream", apiMiddleware, notifyStreamHandler);
+  app.options("/api/open", apiMiddleware);
+  app.post("/api/open", apiMiddleware, largeBody, async (req, res) => {
+    const { filePath, force } = req.body ?? {};
+    if (!filePath || typeof filePath !== "string") {
+      res.status(400).json({ error: "BAD_REQUEST", message: "filePath is required" });
+      return;
+    }
+    try {
+      const result = await openFileByPath(filePath, { force: force === true });
+      res.json({ data: result });
+    } catch (err) {
+      sendApiError(res, err);
+    }
+  });
+  app.options("/api/close", apiMiddleware);
+  app.post("/api/close", apiMiddleware, largeBody, async (req, res) => {
+    const { documentId } = req.body ?? {};
+    if (!documentId || typeof documentId !== "string") {
+      res.status(400).json({ error: "BAD_REQUEST", message: "documentId is required" });
+      return;
+    }
+    try {
+      const result = await closeDocumentById(documentId);
+      if (!result.success) {
+        res.status(404).json({ error: "NOT_FOUND", message: result.error });
+        return;
+      }
+      res.json({
+        data: { closedPath: result.closedPath, activeDocumentId: result.activeDocumentId }
+      });
+    } catch (err) {
+      sendApiError(res, err);
+    }
+  });
+  app.options("/api/upload", apiMiddleware);
+  app.post("/api/upload", apiMiddleware, largeBody, async (req, res) => {
+    const { fileName, content } = req.body ?? {};
+    if (!fileName || typeof fileName !== "string") {
+      res.status(400).json({ error: "BAD_REQUEST", message: "fileName is required" });
+      return;
+    }
+    if (content === void 0 || content === null) {
+      res.status(400).json({ error: "BAD_REQUEST", message: "content is required" });
+      return;
+    }
+    if (typeof content !== "string") {
+      res.status(400).json({ error: "BAD_REQUEST", message: "content must be a base64 string" });
+      return;
+    }
+    try {
+      const format = detectFormat(fileName);
+      const decoded = format === "docx" ? Buffer.from(content, "base64") : String(content);
+      const result = await openFileFromContent(fileName, decoded);
+      res.json({ data: result });
+    } catch (err) {
+      sendApiError(res, err);
+    }
+  });
+  app.options("/api/convert", apiMiddleware);
+  app.post("/api/convert", apiMiddleware, largeBody, async (req, res) => {
+    const { documentId, outputPath } = req.body ?? {};
+    if (documentId !== void 0 && typeof documentId !== "string") {
+      res.status(400).json({ error: "BAD_REQUEST", message: "documentId must be a string" });
+      return;
+    }
+    if (outputPath !== void 0 && typeof outputPath !== "string") {
+      res.status(400).json({ error: "BAD_REQUEST", message: "outputPath must be a string" });
+      return;
+    }
+    try {
+      const result = await convertToMarkdown(
+        documentId,
+        outputPath
+      );
+      res.json({ data: result });
+    } catch (err) {
+      sendApiError(res, err);
+    }
+  });
+}
+
+// src/server/mcp/awareness.ts
+init_provider();
+import { z as z4 } from "zod";
+init_utils();
+init_constants();
+init_queue();
+var surfacedIds = /* @__PURE__ */ new Set();
+function registerAwarenessTools(server) {
+  server.tool(
+    "tandem_getSelections",
+    "Get text currently selected by the user in the editor",
+    {
+      documentId: z4.string().optional().describe("Target document ID (defaults to active document)")
+    },
+    withErrorBoundary("tandem_getSelections", async ({ documentId }) => {
+      const current = getCurrentDoc(documentId);
+      if (!current) return noDocumentError();
+      const doc = getOrCreateDocument(current.docName);
+      const userAwareness = doc.getMap(Y_MAP_USER_AWARENESS);
+      const selection = userAwareness.get("selection");
+      if (!selection || selection.from === selection.to) {
+        return mcpSuccess({ selections: [], message: "No text selected" });
+      }
+      return mcpSuccess({
+        selections: [{ from: selection.from, to: selection.to }],
+        timestamp: selection.timestamp
+      });
+    })
+  );
+  server.tool(
+    "tandem_getActivity",
+    "Check if the user is actively editing and where their cursor is",
+    {
+      documentId: z4.string().optional().describe("Target document ID (defaults to active document)")
+    },
+    withErrorBoundary("tandem_getActivity", async ({ documentId }) => {
+      const current = getCurrentDoc(documentId);
+      if (!current) return noDocumentError();
+      const doc = getOrCreateDocument(current.docName);
+      const userAwareness = doc.getMap(Y_MAP_USER_AWARENESS);
+      const activity = userAwareness.get("activity");
+      if (!activity) {
+        return mcpSuccess({
+          active: false,
+          cursor: null,
+          lastEdit: null,
+          message: "No activity detected"
+        });
+      }
+      const isActive = activity.isTyping || Date.now() - activity.lastEdit < 1e4;
+      return mcpSuccess({
+        active: isActive,
+        isTyping: activity.isTyping,
+        cursor: activity.cursor,
+        lastEdit: activity.lastEdit
+      });
+    })
+  );
+  server.tool(
+    "tandem_checkInbox",
+    "Check for user actions you haven't seen yet \u2014 new highlights, comments, questions, flags, and responses to your annotations. Call this after completing any task, between steps, and whenever you pause. Low token cost.",
+    {
+      documentId: z4.string().optional().describe("Target document ID (defaults to active document)")
+    },
+    withErrorBoundary("tandem_checkInbox", async ({ documentId }) => {
+      const current = getCurrentDoc(documentId);
+      if (!current) return noDocumentError();
+      const doc = getOrCreateDocument(current.docName);
+      const annotationsMap = doc.getMap(Y_MAP_ANNOTATIONS);
+      const allAnnotations = collectAnnotations(annotationsMap);
+      const fullText = extractText(doc);
+      const userActions = [];
+      const userResponses = [];
+      const unsurfaced = [];
+      doc.transact(() => {
+        for (const raw of allAnnotations) {
+          if (surfacedIds.has(raw.id)) continue;
+          unsurfaced.push(refreshRange(raw, doc, annotationsMap));
+        }
+      }, MCP_ORIGIN);
+      for (const ann of unsurfaced) {
+        const snippet = safeSlice2(fullText, ann.range.from, ann.range.to);
+        if (ann.author === "user") {
+          userActions.push({ ...ann, textSnippet: snippet });
+          surfacedIds.add(ann.id);
+        } else if (ann.author === "claude" && ann.status !== "pending") {
+          userResponses.push({ ...ann, textSnippet: snippet });
+          surfacedIds.add(ann.id);
+        }
+      }
+      const ctrlDoc = getOrCreateDocument(CTRL_ROOM);
+      const chatMap = ctrlDoc.getMap(Y_MAP_CHAT);
+      const chatMessages = [];
+      chatMap.forEach((value) => {
+        const msg = value;
+        if (msg.author === "user" && !msg.read) {
+          chatMessages.push({
+            id: msg.id,
+            text: msg.text,
+            timestamp: msg.timestamp,
+            ...msg.documentId ? { documentId: msg.documentId } : {},
+            ...msg.anchor ? { anchor: msg.anchor } : {},
+            ...msg.replyTo ? { replyTo: msg.replyTo } : {}
+          });
+          ctrlDoc.transact(() => chatMap.set(msg.id, { ...msg, read: true }), MCP_ORIGIN);
+        }
+      });
+      const userAwareness = doc.getMap(Y_MAP_USER_AWARENESS);
+      const selection = userAwareness.get("selection");
+      const activity = userAwareness.get("activity");
+      const interruptionMode = userAwareness.get("interruptionMode") ?? INTERRUPTION_MODE_DEFAULT;
+      const hasSelection = selection && selection.from !== selection.to;
+      const selectedText = hasSelection ? safeSlice2(fullText, selection.from, selection.to) : null;
+      const parts = [];
+      if (userActions.length > 0) {
+        const typeCounts = {};
+        for (const a of userActions) {
+          typeCounts[a.type] = (typeCounts[a.type] || 0) + 1;
+        }
+        const typeList = Object.entries(typeCounts).map(([t, n]) => `${n} ${t}${n > 1 ? "s" : ""}`).join(", ");
+        parts.push(`${userActions.length} new: ${typeList}`);
+      }
+      if (userResponses.length > 0) {
+        const statusCounts = {};
+        for (const r of userResponses) {
+          statusCounts[r.status] = (statusCounts[r.status] || 0) + 1;
+        }
+        const statusList = Object.entries(statusCounts).map(([s, n]) => `${n} ${s}`).join(", ");
+        parts.push(statusList);
+      }
+      if (chatMessages.length > 0) {
+        parts.push(`${chatMessages.length} new chat message${chatMessages.length > 1 ? "s" : ""}`);
+      }
+      const summary = parts.length > 0 ? parts.join(". ") + "." : "No new actions.";
+      const hasNew = userActions.length > 0 || userResponses.length > 0 || chatMessages.length > 0;
+      return mcpSuccess({
+        summary,
+        hasNew,
+        interruptionMode,
+        userActions,
+        userResponses,
+        chatMessages,
+        activity: {
+          isTyping: activity?.isTyping ?? false,
+          cursor: activity?.cursor ?? null,
+          lastEdit: activity?.lastEdit ?? null,
+          selectedText
+        }
+      });
+    })
+  );
+  server.tool(
+    "tandem_reply",
+    "Send a chat message to the user in the Tandem sidebar. Use this to respond to chat messages from tandem_checkInbox.",
+    {
+      text: z4.string().describe("Your message to the user"),
+      replyTo: z4.string().optional().describe("ID of the user message you are replying to"),
+      documentId: z4.string().optional().describe("Document context for this reply (defaults to active document)")
+    },
+    withErrorBoundary("tandem_reply", async ({ text, replyTo, documentId }) => {
+      const ctrlDoc = getOrCreateDocument(CTRL_ROOM);
+      const chatMap = ctrlDoc.getMap(Y_MAP_CHAT);
+      const id = generateMessageId();
+      const current = getCurrentDoc(documentId);
+      const docId = documentId ?? current?.id ?? void 0;
+      const msg = {
+        id,
+        author: "claude",
+        text,
+        timestamp: Date.now(),
+        ...docId ? { documentId: docId } : {},
+        ...replyTo ? { replyTo } : {},
+        read: true
+      };
+      ctrlDoc.transact(() => chatMap.set(id, msg), MCP_ORIGIN);
+      return mcpSuccess({ sent: true, messageId: id });
+    })
+  );
+}
+function safeSlice2(text, from, to) {
+  const start = Math.max(0, Math.min(from, text.length));
+  const end = Math.max(start, Math.min(to, text.length));
+  const snippet = text.slice(start, end);
+  return snippet.length > 100 ? snippet.slice(0, 97) + "..." : snippet;
+}
+
+// src/server/mcp/channel-routes.ts
+init_constants();
+init_utils();
+init_queue();
+
+// src/server/events/sse.ts
+init_constants();
+init_queue();
+function sseHandler(req, res) {
+  res.writeHead(200, {
+    "Content-Type": "text/event-stream",
+    "Cache-Control": "no-cache",
+    Connection: "keep-alive"
+  });
+  const lastEventId = req.headers["last-event-id"];
+  if (lastEventId) {
+    const missed = replaySince(lastEventId);
+    for (const event of missed) {
+      writeEvent(res, event);
+    }
+  }
+  res.write(": connected\n\n");
+  let keepalive;
+  const onEvent = (event) => {
+    try {
+      writeEvent(res, event);
+    } catch (err) {
+      console.error(
+        "[SSE] Write failed, cleaning up subscriber:",
+        err instanceof Error ? err.message : err
+      );
+      clearInterval(keepalive);
+      unsubscribe(onEvent);
+    }
+  };
+  subscribe(onEvent);
+  keepalive = setInterval(() => {
+    res.write(": keepalive\n\n");
+  }, CHANNEL_SSE_KEEPALIVE_MS);
+  req.on("close", () => {
+    clearInterval(keepalive);
+    unsubscribe(onEvent);
+    console.error("[SSE] Client disconnected from /api/events");
+  });
+  console.error("[SSE] Client connected to /api/events");
+}
+function writeEvent(res, event) {
+  res.write(`id: ${event.id}
+`);
+  res.write(`data: ${JSON.stringify(event)}
+
+`);
+}
+
+// src/server/mcp/channel-routes.ts
+init_provider();
+var pendingPermissions = /* @__PURE__ */ new Map();
+var PERMISSION_TTL_MS = 3e4;
+function registerChannelRoutes(app, apiMiddleware2) {
+  app.get("/api/events", apiMiddleware2, sseHandler);
+  app.options("/api/channel-awareness", apiMiddleware2);
+  app.post("/api/channel-awareness", apiMiddleware2, (req, res) => {
+    const { documentId, status, active, focusParagraph } = req.body ?? {};
+    if (typeof status !== "string") {
+      res.status(400).json({ error: "BAD_REQUEST", message: "status is required" });
+      return;
+    }
+    const docId = typeof documentId === "string" ? documentId : null;
+    if (docId) {
+      const doc = getOrCreateDocument(docId);
+      const awarenessMap = doc.getMap(Y_MAP_AWARENESS);
+      const state = {
+        status,
+        timestamp: Date.now(),
+        active: active === true,
+        focusParagraph: typeof focusParagraph === "number" ? focusParagraph : null
+      };
+      doc.transact(() => awarenessMap.set("claude", state), MCP_ORIGIN);
+    }
+    res.json({ ok: true, written: !!docId });
+  });
+  app.options("/api/channel-error", apiMiddleware2);
+  app.post("/api/channel-error", apiMiddleware2, (req, res) => {
+    const { error, message } = req.body ?? {};
+    console.error(`[Channel] Error: ${error} \u2014 ${message}`);
+    res.json({ ok: true });
+  });
+  app.options("/api/channel-reply", apiMiddleware2);
+  app.post("/api/channel-reply", apiMiddleware2, (req, res) => {
+    const { text, documentId, replyTo } = req.body ?? {};
+    if (typeof text !== "string") {
+      res.status(400).json({ error: "BAD_REQUEST", message: "text is required" });
+      return;
+    }
+    const ctrlDoc = getOrCreateDocument(CTRL_ROOM);
+    const chatMap = ctrlDoc.getMap(Y_MAP_CHAT);
+    const id = generateMessageId();
+    const msg = {
+      id,
+      author: "claude",
+      text,
+      timestamp: Date.now(),
+      ...typeof documentId === "string" ? { documentId } : {},
+      ...typeof replyTo === "string" ? { replyTo } : {},
+      read: true
+    };
+    ctrlDoc.transact(() => chatMap.set(id, msg), MCP_ORIGIN);
+    res.json({ sent: true, messageId: id });
+  });
+  app.options("/api/channel-permission", apiMiddleware2);
+  app.post("/api/channel-permission", apiMiddleware2, (req, res) => {
+    const { requestId, toolName, description, inputPreview } = req.body ?? {};
+    if (typeof requestId !== "string" || typeof toolName !== "string") {
+      res.status(400).json({ error: "BAD_REQUEST", message: "requestId and toolName required" });
+      return;
+    }
+    pendingPermissions.set(requestId, {
+      requestId,
+      toolName,
+      description: description ?? "",
+      inputPreview: inputPreview ?? "",
+      createdAt: Date.now()
+    });
+    console.error(`[Channel] Permission request: ${toolName} \u2014 ${description} (id: ${requestId})`);
+    res.json({ ok: true });
+  });
+  app.get("/api/channel-permission", apiMiddleware2, (_req, res) => {
+    const now = Date.now();
+    for (const [id, perm] of pendingPermissions) {
+      if (now - perm.createdAt > PERMISSION_TTL_MS) pendingPermissions.delete(id);
+    }
+    res.json({ pending: Array.from(pendingPermissions.values()) });
+  });
+  app.options("/api/channel-permission-verdict", apiMiddleware2);
+  app.post("/api/channel-permission-verdict", apiMiddleware2, (req, res) => {
+    const { requestId, approved } = req.body ?? {};
+    if (typeof requestId !== "string") {
+      res.status(400).json({ error: "BAD_REQUEST", message: "requestId is required" });
+      return;
+    }
+    pendingPermissions.delete(requestId);
+    console.error(`[Channel] Permission verdict: ${requestId} \u2192 ${approved ? "allow" : "deny"}`);
+    res.json({ ok: true, requestId, behavior: approved ? "allow" : "deny" });
+  });
+  app.options("/api/launch-claude", apiMiddleware2);
+  app.post("/api/launch-claude", apiMiddleware2, async (_req, res) => {
+    try {
+      const { launchClaude: launchClaude2 } = await Promise.resolve().then(() => (init_launcher(), launcher_exports));
+      const result = launchClaude2();
+      res.json(result);
+    } catch (err) {
+      console.error("[Tandem] Failed to launch Claude:", err);
+      res.status(500).json({
+        error: "LAUNCH_FAILED",
+        message: err instanceof Error ? err.message : String(err)
+      });
+    }
+  });
+}
+
+// src/server/mcp/navigation.ts
+init_constants();
+init_types();
+init_queue();
+init_provider();
+import { z as z5 } from "zod";
+function getFullText(docName) {
+  const doc = getOrCreateDocument(docName);
+  return extractText(doc);
+}
+function searchText(fullText, query, useRegex) {
+  const matches = [];
+  try {
+    const pattern = useRegex ? new RegExp(query, "gi") : new RegExp(escapeRegex(query), "gi");
+    let match;
+    while ((match = pattern.exec(fullText)) !== null) {
+      matches.push({
+        from: toFlatOffset(match.index),
+        to: toFlatOffset(match.index + match[0].length),
+        text: match[0]
+      });
+    }
+  } catch (err) {
+    return { matches: [], error: `Invalid regex: ${getErrorMessage(err)}` };
+  }
+  return { matches };
+}
+function findOccurrence(fullText, pattern, occurrence = 1) {
+  const regex = new RegExp(escapeRegex(pattern), "g");
+  let match;
+  let count = 0;
+  while ((match = regex.exec(fullText)) !== null) {
+    count++;
+    if (count === occurrence) {
+      return {
+        from: toFlatOffset(match.index),
+        to: toFlatOffset(match.index + match[0].length),
+        text: match[0]
+      };
+    }
+  }
+  return {
+    error: `Text "${pattern}" not found (occurrence ${occurrence}, found ${count} total)`,
+    totalCount: count
+  };
+}
+function extractContext(fullText, from, to, windowSize = 500) {
+  const contextStart = toFlatOffset(Math.max(0, from - windowSize));
+  const contextEnd = toFlatOffset(Math.min(fullText.length, to + windowSize));
+  return {
+    context: fullText.slice(contextStart, contextEnd),
+    selection: fullText.slice(from, to),
+    contextRange: { from: contextStart, to: contextEnd },
+    selectionRange: { from, to }
+  };
+}
+function registerNavigationTools(server) {
+  server.tool(
+    "tandem_search",
+    "Search for text in the document. Returns matching positions.",
+    {
+      query: z5.string().describe("Search query (supports regex)"),
+      regex: z5.boolean().optional().describe("Treat query as regex"),
+      documentId: z5.string().optional().describe("Target document ID (defaults to active document)")
+    },
+    withErrorBoundary("tandem_search", async ({ query, regex, documentId }) => {
+      const current = getCurrentDoc(documentId);
+      if (!current) return noDocumentError();
+      const fullText = getFullText(current.docName);
+      const result = searchText(fullText, query, regex);
+      if (result.error) return mcpError("FORMAT_ERROR", result.error);
+      return mcpSuccess({ matches: result.matches, count: result.matches.length });
+    })
+  );
+  server.tool(
+    "tandem_resolveRange",
+    "Find text and return a valid range. Safer than raw character offsets under concurrent editing.",
+    {
+      pattern: z5.string().describe("Text to find"),
+      occurrence: z5.number().optional().describe("Which occurrence (1-based, default 1)"),
+      documentId: z5.string().optional().describe("Target document ID (defaults to active document)")
+    },
+    withErrorBoundary("tandem_resolveRange", async ({ pattern, occurrence = 1, documentId }) => {
+      const current = getCurrentDoc(documentId);
+      if (!current) return noDocumentError();
+      const fullText = getFullText(current.docName);
+      const result = findOccurrence(fullText, pattern, occurrence);
+      if ("error" in result) return mcpError("INVALID_RANGE", result.error);
+      return mcpSuccess(result);
+    })
+  );
+  server.tool(
+    "tandem_setStatus",
+    'Update Claude status text shown to user (e.g., "Reviewing cost figures..."). Tip: call tandem_checkInbox after completing work to see if the user has responded.',
+    {
+      text: z5.string().describe("Status text"),
+      focusParagraph: z5.number().optional().describe("Index of paragraph Claude is focusing on"),
+      documentId: z5.string().optional().describe("Target document ID (defaults to active document)")
+    },
+    withErrorBoundary("tandem_setStatus", async ({ text, focusParagraph, documentId }) => {
+      const current = getCurrentDoc(documentId);
+      if (!current) {
+        return mcpSuccess({
+          status: text,
+          warning: "No document open \u2014 status not broadcast to editor."
+        });
+      }
+      const doc = getOrCreateDocument(current.docName);
+      const awarenessMap = doc.getMap(Y_MAP_AWARENESS);
+      doc.transact(
+        () => awarenessMap.set("claude", {
+          status: text,
+          timestamp: Date.now(),
+          active: true,
+          focusParagraph: focusParagraph ?? null
+        }),
+        MCP_ORIGIN
+      );
+      return mcpSuccess({ status: text });
+    })
+  );
+  server.tool(
+    "tandem_getContext",
+    "Read content around a range without pulling the full document. Reduces token usage.",
+    {
+      from: z5.number().describe("Start position"),
+      to: z5.number().describe("End position"),
+      windowSize: z5.number().optional().describe("Characters of context before/after (default 500)"),
+      documentId: z5.string().optional().describe("Target document ID (defaults to active document)")
+    },
+    withErrorBoundary(
+      "tandem_getContext",
+      async ({ from: rawFrom, to: rawTo, windowSize = 500, documentId }) => {
+        const current = getCurrentDoc(documentId);
+        if (!current) return noDocumentError();
+        const from = toFlatOffset(rawFrom);
+        const to = toFlatOffset(rawTo);
+        const fullText = getFullText(current.docName);
+        return mcpSuccess(extractContext(fullText, from, to, windowSize));
+      }
+    )
+  );
+}
+
+// src/server/mcp/server.ts
+var esmRequire = createRequire(import.meta.url);
+var APP_VERSION = "0.0.0-unknown";
+try {
+  APP_VERSION = esmRequire("../../package.json").version;
+} catch (err) {
+  console.error(
+    `[Tandem] Could not read version from package.json: ${err instanceof Error ? err.message : err}`
+  );
+}
+var __dirname = dirname(fileURLToPath(import.meta.url));
+var CLIENT_DIST = join(__dirname, "../client");
+var mcpServer = null;
+var currentTransport = null;
+var connectingPromise = null;
+function createMcpServer() {
+  const server = new McpServer({
+    name: "tandem",
+    version: APP_VERSION
+  });
+  registerDocumentTools(server);
+  registerAnnotationTools(server);
+  registerNavigationTools(server);
+  registerAwarenessTools(server);
+  return server;
+}
+function jsonrpcId(body) {
+  return body && typeof body === "object" && !Array.isArray(body) && "id" in body ? body.id : null;
+}
+function sendJsonRpcError(res, status, code, message, id = null) {
+  res.status(status).json({ jsonrpc: "2.0", error: { code, message }, id });
+}
+async function connectFreshTransport() {
+  if (!mcpServer) throw new Error("mcpServer not initialized");
+  const doConnect = async () => {
+    if (currentTransport) {
+      console.error("[Tandem] Closing previous MCP transport session");
+      await mcpServer.close();
+      currentTransport = null;
+    }
+    const transport = new StreamableHTTPServerTransport({
+      sessionIdGenerator: () => randomUUID3()
+    });
+    await mcpServer.connect(transport);
+    currentTransport = transport;
+    console.error("[Tandem] New MCP session established");
+  };
+  const promise = (connectingPromise ?? Promise.resolve()).then(doConnect);
+  connectingPromise = promise;
+  await promise;
+  if (connectingPromise === promise) connectingPromise = null;
+}
+async function closeMcpSession() {
+  if (currentTransport && mcpServer) {
+    await mcpServer.close();
+    currentTransport = null;
+  }
+}
+async function startMcpServerStdio() {
+  const server = createMcpServer();
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+async function startMcpServerHttp(port, host = "127.0.0.1") {
+  mcpServer = createMcpServer();
+  const { default: express } = await import("express");
+  const app = express();
+  const largeBody = express.json({ limit: "70mb" });
+  const mcpApp = createMcpExpressApp({ host });
+  mcpApp.post("/mcp", async (req, res) => {
+    const body = req.body;
+    const isInit = isInitializeRequest(body) || Array.isArray(body) && body.some(isInitializeRequest);
+    if (isInit) {
+      console.error("[Tandem] Received initialize request, rotating transport");
+      try {
+        await connectFreshTransport();
+      } catch (err) {
+        console.error("[Tandem] Failed to create new transport:", err);
+        sendJsonRpcError(res, 500, -32603, "Internal error", jsonrpcId(body));
+        return;
+      }
+    }
+    if (!currentTransport) {
+      sendJsonRpcError(res, 503, -32e3, "No active session", jsonrpcId(body));
+      return;
+    }
+    await currentTransport.handleRequest(req, res, body);
+  });
+  mcpApp.get("/mcp", async (req, res) => {
+    if (!currentTransport) {
+      sendJsonRpcError(res, 503, -32e3, "No active session");
+      return;
+    }
+    await currentTransport.handleRequest(req, res, req.body);
+  });
+  mcpApp.delete("/mcp", async (req, res) => {
+    if (!currentTransport) {
+      sendJsonRpcError(res, 404, -32001, "Session not found");
+      return;
+    }
+    await currentTransport.handleRequest(req, res, req.body);
+    currentTransport = null;
+  });
+  app.get("/health", (_req, res) => {
+    res.json({
+      status: "ok",
+      version: APP_VERSION,
+      transport: "http",
+      hasSession: currentTransport !== null
+    });
+  });
+  app.get(
+    "/.well-known/oauth-protected-resource/mcp",
+    (_req, res) => {
+      res.header("Access-Control-Allow-Origin", "*");
+      res.json({
+        resource: `http://localhost:${port}/mcp`,
+        bearer_methods_supported: []
+      });
+    }
+  );
+  app.get(
+    "/.well-known/oauth-protected-resource",
+    (_req, res) => {
+      res.header("Access-Control-Allow-Origin", "*");
+      res.json({
+        resource: `http://localhost:${port}/mcp`,
+        bearer_methods_supported: []
+      });
+    }
+  );
+  app.use(mcpApp);
+  registerApiRoutes(app, largeBody);
+  registerChannelRoutes(app, apiMiddleware);
+  if (existsSync(CLIENT_DIST)) {
+    app.use(express.static(CLIENT_DIST, { index: "index.html" }));
+    const indexPath = join(CLIENT_DIST, "index.html");
+    app.get("/{*path}", (_req, res) => {
+      res.sendFile(indexPath);
+    });
+    console.error(`[Tandem] Serving client from ${CLIENT_DIST}`);
+  } else {
+    console.error(`[Tandem] No client dist at ${CLIENT_DIST} \u2014 run 'npm run build' first`);
+  }
+  return new Promise((resolve, reject) => {
+    const httpServer2 = app.listen(port, host, () => {
+      httpServer2.removeListener("error", reject);
+      httpServer2.on("error", (err) => console.error("[Tandem] HTTP server error:", err));
+      console.error(`[Tandem] MCP HTTP server on http://${host}:${port}/mcp`);
+      if (process.env.TANDEM_OPEN_BROWSER === "1") {
+        if (existsSync(CLIENT_DIST)) {
+          openBrowser(`http://localhost:${port}`);
+        } else {
+          console.error("[Tandem] Skipping browser open \u2014 no client assets found");
+        }
+      }
+      resolve(httpServer2);
+    });
+    httpServer2.on("error", reject);
+  });
+}
+
+// src/server/index.ts
+init_provider();
+init_constants();
+init_manager();
+init_platform();
+
+// src/server/error-filter.ts
+function isKnownHocuspocusError(err) {
+  if (!(err instanceof Error)) return false;
+  if ("code" in err) {
+    const code = err.code;
+    if (typeof code === "string" && code.startsWith("WS_ERR_")) {
+      return true;
+    }
+  }
+  const msg = err.message;
+  if (msg.startsWith("WebSocket is not open")) return true;
+  if (msg === "Unexpected end of array" || msg === "Integer out of Range") return true;
+  if (msg.startsWith("Received a message with an unknown type:")) return true;
+  return false;
+}
+
+// src/server/index.ts
+init_queue();
+init_document_service();
+init_file_opener();
+init_document_model();
+
+// src/server/mcp/tutorial-annotations.ts
+init_constants();
+init_queue();
+init_positions2();
+init_types2();
+init_document_model();
+var TUTORIAL_ANNOTATIONS = [
+  {
+    id: `${TUTORIAL_ANNOTATION_PREFIX}highlight-1`,
+    type: "highlight",
+    targetText: "collaborative document editor",
+    content: "This is a highlight \u2014 it marks text for attention without suggesting changes.",
+    color: "yellow"
+  },
+  {
+    id: `${TUTORIAL_ANNOTATION_PREFIX}comment-1`,
+    type: "comment",
+    targetText: "review your documents",
+    content: "Comments let you or Claude leave notes on specific text passages."
+  },
+  {
+    id: `${TUTORIAL_ANNOTATION_PREFIX}suggest-1`,
+    type: "suggestion",
+    targetText: "simplify onboarding",
+    content: JSON.stringify({
+      newText: "streamline onboarding",
+      reason: "More precise verb choice"
+    })
+  }
+];
+function injectTutorialAnnotations(doc) {
+  const map = doc.getMap(Y_MAP_ANNOTATIONS);
+  if (map.has(`${TUTORIAL_ANNOTATION_PREFIX}highlight-1`)) return;
+  const fullText = extractText(doc);
+  if (!fullText) {
+    console.error("[tutorial] Y.Doc has no text content \u2014 cannot inject tutorial annotations");
+    return;
+  }
+  let injected = 0;
+  doc.transact(() => {
+    for (const def of TUTORIAL_ANNOTATIONS) {
+      const idx = fullText.indexOf(def.targetText);
+      if (idx === -1) {
+        console.error(`[tutorial] Target text "${def.targetText}" not found \u2014 skipping ${def.id}`);
+        continue;
+      }
+      const result = anchoredRange(
+        doc,
+        toFlatOffset(idx),
+        toFlatOffset(idx + def.targetText.length),
+        def.targetText
+      );
+      if (!result.ok) {
+        console.error(
+          `[tutorial] anchoredRange failed for "${def.targetText}" \u2014 skipping ${def.id}`
+        );
+        continue;
+      }
+      const annotation = {
+        id: def.id,
+        author: "claude",
+        type: def.type,
+        range: result.range,
+        relRange: result.relRange,
+        content: def.content,
+        status: "pending",
+        timestamp: Date.now(),
+        color: def.color,
+        textSnapshot: def.targetText
+      };
+      map.set(def.id, annotation);
+      injected++;
+    }
+  }, MCP_ORIGIN);
+  console.error(
+    `[tutorial] Injected ${injected}/${TUTORIAL_ANNOTATIONS.length} tutorial annotations`
+  );
+}
+
+// src/server/index.ts
+console.log = console.error;
+console.warn = console.error;
+console.info = console.error;
+var transportMode = (process.env.TANDEM_TRANSPORT || "http").toLowerCase();
+var wsPort = parseInt(process.env.TANDEM_PORT || String(DEFAULT_WS_PORT), 10);
+var mcpPort = parseInt(process.env.TANDEM_MCP_PORT || String(DEFAULT_MCP_PORT), 10);
+var httpServer = null;
+var isShuttingDown = false;
+function handleFatalError(label, value) {
+  if (value instanceof Error && isKnownHocuspocusError(value)) {
+    console.error("[Tandem] Known WS error (swallowed):", value.message, value.stack);
+    return;
+  }
+  if (isShuttingDown) {
+    console.error(`[Tandem] ${label} during shutdown (ignored):`, value);
+    return;
+  }
+  if (value instanceof Error) {
+    console.error(`[Tandem] ${label} (FATAL):`, value.name, value.message, value.stack);
+  } else {
+    console.error(`[Tandem] ${label} (FATAL):`, value);
+  }
+  process.exit(1);
+}
+process.on("uncaughtException", (err) => handleFatalError("uncaughtException", err));
+process.on("unhandledRejection", (reason) => handleFatalError("unhandledRejection", reason));
+process.on("exit", (code) => {
+  console.error(`[Tandem] Process exiting with code ${code}`);
+});
+if (transportMode === "stdio") {
+  process.stdin.on("end", () => {
+    console.error("[Tandem] stdin ended (MCP transport closed)");
+  });
+}
+async function shutdown(signal) {
+  if (isShuttingDown) return;
+  isShuttingDown = true;
+  console.error(`[Tandem] ${signal} received, saving session...`);
+  try {
+    await saveCurrentSession();
+    stopAutoSave();
+  } catch (err) {
+    console.error("[Tandem] Session save on shutdown failed:", err);
+  }
+  try {
+    await closeMcpSession();
+  } catch (err) {
+    console.error("[Tandem] MCP session close on shutdown failed:", err);
+  }
+  if (httpServer) {
+    httpServer.close();
+  }
+  process.exit(0);
+}
+process.on("SIGTERM", () => shutdown("SIGTERM"));
+process.on("SIGINT", () => shutdown("SIGINT"));
+async function main() {
+  console.error(`[Tandem] Starting server (transport: ${transportMode})...`);
+  cleanupSessions().then((n) => {
+    if (n > 0) console.error(`[Tandem] Cleaned up ${n} stale session(s)`);
+  }).catch((err) => {
+    console.error("[Tandem] Failed to clean up stale sessions:", err);
+  });
+  const previousActiveDocId = await restoreCtrlSession().catch((err) => {
+    console.error("[Tandem] Failed to restore chat history:", err);
+    return null;
+  });
+  await restoreOpenDocuments(previousActiveDocId).catch((err) => {
+    console.error("[Tandem] Failed to restore open documents:", err);
+  });
+  writeGenerationId();
+  attachCtrlObservers();
+  setDocLifecycleCallbacks(
+    (docName, newDoc) => {
+      if (docName === CTRL_ROOM) {
+        reattachCtrlObservers();
+      } else {
+        reattachObservers(docName, newDoc);
+      }
+    },
+    (docName) => {
+      detachObservers(docName);
+    }
+  );
+  if (transportMode === "http") {
+    freePort(wsPort);
+    freePort(mcpPort);
+    await Promise.all([waitForPort(wsPort), waitForPort(mcpPort)]);
+    const [srv] = await Promise.all([
+      startMcpServerHttp(mcpPort),
+      startHocuspocus(wsPort).then(() => {
+        console.error(`[Tandem] Hocuspocus WebSocket server running on ws://localhost:${wsPort}`);
+      })
+    ]);
+    httpServer = srv;
+    if (getOpenDocs().size === 0 && !process.env.TANDEM_NO_SAMPLE) {
+      const samplePath = path8.resolve(
+        path8.dirname(fileURLToPath2(import.meta.url)),
+        "../../sample/welcome.md"
+      );
+      openFileByPath(samplePath).then(() => {
+        const doc = getOrCreateDocument(docIdFromPath(samplePath));
+        injectTutorialAnnotations(doc);
+      }).catch((err) => {
+        if (err.code === "ENOENT") {
+          console.error("[Tandem] Sample file not found (skipping):", samplePath);
+        } else {
+          console.error("[Tandem] Failed to auto-open sample document:", err);
+        }
+      });
+    }
+    console.error("");
+    console.error(`  Tandem v${APP_VERSION}`);
+    console.error("");
+    console.error(`  MCP HTTP:    http://localhost:${mcpPort}/mcp`);
+    console.error(`  WebSocket:   ws://localhost:${wsPort}`);
+    console.error(`  Health:      http://localhost:${mcpPort}/health`);
+    console.error("");
+    console.error("  Open Claude Code in this directory to connect.");
+    console.error("");
+  } else {
+    (async () => {
+      freePort(wsPort);
+      await waitForPort(wsPort);
+      await startHocuspocus(wsPort);
+      console.error(`[Tandem] Hocuspocus WebSocket server running on ws://localhost:${wsPort}`);
+    })().catch((err) => {
+      console.error("[Tandem] Hocuspocus startup error:", err);
+    });
+    await startMcpServerStdio();
+    console.error("[Tandem] MCP server running on stdio");
+  }
+}
+main().catch((err) => {
+  console.error("[Tandem] Fatal error:", err);
+  process.exit(1);
+});
+//# sourceMappingURL=index.js.map