tandem-editor 0.11.2 → 0.12.0

package/dist/server/index.js

@@ -40,7 +40,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/shared/constants.ts
-var DEFAULT_WS_PORT, DEFAULT_MCP_PORT, TANDEM_REPO_URL, TANDEM_ISSUES_NEW_URL, SUPPORTED_EXTENSIONS, MAX_FILE_SIZE, MAX_WS_PAYLOAD, IDLE_TIMEOUT, SESSION_MAX_AGE, TANDEM_MODE_DEFAULT, SELECTION_DWELL_DEFAULT_MS, SELECTION_DWELL_MIN_MS, SELECTION_DWELL_MAX_MS, 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_MODE, Y_MAP_DWELL_MS, Y_MAP_CHAT, Y_MAP_DOCUMENT_META, Y_MAP_ANNOTATION_REPLIES, Y_MAP_SAVED_AT_VERSION, Y_MAP_AUTHORSHIP, Y_MAP_SELECTION, Y_MAP_ACTIVITY, Y_MAP_OPEN_DOCUMENTS, Y_MAP_ACTIVE_DOCUMENT_ID, Y_MAP_GENERATION_ID, Y_MAP_STORE_READ_ONLY, NOTIFICATION_BUFFER_SIZE, TUTORIAL_ANNOTATION_PREFIX, CHANNEL_EVENT_BUFFER_SIZE, CHANNEL_EVENT_BUFFER_AGE_MS, CHANNEL_SSE_KEEPALIVE_MS, TOKEN_FILE_NAME, DEFAULT_BIND_HOST, TANDEM_ALLOW_UNAUTHENTICATED_LAN_ENV, TAURI_HOSTNAME;
+var DEFAULT_WS_PORT, DEFAULT_MCP_PORT, TANDEM_REPO_URL, TANDEM_ISSUES_NEW_URL, SUPPORTED_EXTENSIONS, MAX_FILE_SIZE, SESSION_MAX_AGE, TANDEM_MODE_DEFAULT, SELECTION_DWELL_DEFAULT_MS, SELECTION_DWELL_MIN_MS, SELECTION_DWELL_MAX_MS, 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_MODE, Y_MAP_DWELL_MS, Y_MAP_CHAT, Y_MAP_DOCUMENT_META, Y_MAP_ANNOTATION_REPLIES, Y_MAP_SAVED_AT_VERSION, Y_MAP_AUTHORSHIP, Y_MAP_SELECTION, Y_MAP_ACTIVITY, Y_MAP_CLAUDE, Y_MAP_OPEN_DOCUMENTS, Y_MAP_ACTIVE_DOCUMENT_ID, Y_MAP_GENERATION_ID, Y_MAP_READ_ONLY, Y_MAP_STORE_READ_ONLY, NOTIFICATION_BUFFER_SIZE, TUTORIAL_ANNOTATION_PREFIX, CHANNEL_EVENT_BUFFER_SIZE, CHANNEL_EVENT_BUFFER_AGE_MS, CHANNEL_SSE_KEEPALIVE_MS, TOKEN_FILE_NAME, DEFAULT_BIND_HOST, TANDEM_ALLOW_UNAUTHENTICATED_LAN_ENV, TAURI_HOSTNAME;
 var init_constants = __esm({
   "src/shared/constants.ts"() {
     "use strict";
@@ -50,8 +50,6 @@ var init_constants = __esm({
     TANDEM_ISSUES_NEW_URL = `${TANDEM_REPO_URL}/issues/new`;
     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;
     TANDEM_MODE_DEFAULT = "tandem";
     SELECTION_DWELL_DEFAULT_MS = 1e3;
@@ -73,9 +71,11 @@ var init_constants = __esm({
     Y_MAP_AUTHORSHIP = "authorship";
     Y_MAP_SELECTION = "selection";
     Y_MAP_ACTIVITY = "activity";
+    Y_MAP_CLAUDE = "claude";
     Y_MAP_OPEN_DOCUMENTS = "openDocuments";
     Y_MAP_ACTIVE_DOCUMENT_ID = "activeDocumentId";
     Y_MAP_GENERATION_ID = "generationId";
+    Y_MAP_READ_ONLY = "readOnly";
     Y_MAP_STORE_READ_ONLY = "storeReadOnly";
     NOTIFICATION_BUFFER_SIZE = 50;
     TUTORIAL_ANNOTATION_PREFIX = "tutorial-";
@@ -18580,7 +18580,7 @@ var init_constructs = __esm({
 });
 
 // node_modules/micromark/lib/create-tokenizer.js
-function createTokenizer(parser2, initialize, from3) {
+function createTokenizer(parser, initialize, from3) {
   let point3 = {
     _bufferIndex: -1,
     _index: 0,
@@ -18609,7 +18609,7 @@ function createTokenizer(parser2, initialize, from3) {
     defineSkip,
     events: [],
     now,
-    parser: parser2,
+    parser,
     previous: null,
     sliceSerialize,
     sliceStream,
@@ -18917,7 +18917,7 @@ function parse(options) {
     /** @type {FullNormalizedExtension} */
     combineExtensions([constructs_exports, ...settings.extensions || []])
   );
-  const parser2 = {
+  const parser = {
     constructs: constructs2,
     content: create9(content2),
     defined: [],
@@ -18927,11 +18927,11 @@ function parse(options) {
     string: create9(string),
     text: create9(text3)
   };
-  return parser2;
+  return parser;
   function create9(initial2) {
     return creator;
     function creator(from3) {
-      return createTokenizer(parser2, initial2, from3);
+      return createTokenizer(parser, initial2, from3);
     }
   }
 }
@@ -19828,8 +19828,8 @@ var init_mdast_util_from_markdown = __esm({
 // node_modules/remark-parse/lib/index.js
 function remarkParse(options) {
   const self2 = this;
-  self2.parser = parser2;
-  function parser2(doc) {
+  self2.parser = parser;
+  function parser(doc) {
     return fromMarkdown(doc, {
       ...self2.data("settings"),
       ...options,
@@ -21027,9 +21027,9 @@ var init_lib22 = __esm({
       parse(file) {
         this.freeze();
         const realFile = vfile(file);
-        const parser2 = this.parser || this.Parser;
-        assertParser("parse", parser2);
-        return parser2(String(realFile), realFile);
+        const parser = this.parser || this.Parser;
+        assertParser("parse", parser);
+        return parser(String(realFile), realFile);
       }
       /**
        * Process the given file as configured on the processor.
@@ -21914,15 +21914,50 @@ var init_mdast_ydoc = __esm({
 });
 
 // src/server/file-io/markdown.ts
+function normalizeLabel(s) {
+  return s.replace(/[\t\n\r ]+/g, " ").trim().toLowerCase();
+}
 function loadMarkdown(doc, markdown) {
-  const tree = parser.parse(markdown);
+  const tree = mdParser.parse(markdown);
   mdastToYDoc(doc, tree);
 }
 function saveMarkdown(doc) {
-  const tree = yDocToMdast(doc);
-  return serializer.stringify(tree);
+  return serializeMdast(yDocToMdast(doc));
+}
+function serializeMdast(tree) {
+  const refDefs = /* @__PURE__ */ new Set();
+  visit(tree, "definition", (node2) => {
+    refDefs.add(node2.identifier);
+  });
+  return unified().use(remarkGfm).use(remarkStringify, {
+    ...stringifyOptions,
+    handlers: {
+      // Call state.safe() first (mirroring the default text handler) so
+      // block-context escapes (line-leading `# `, `- `, `> `, fence runs,
+      // table pipes, setext underlines) remain intact, then selectively
+      // un-escape intra-text noise that the default `unsafe` table over-flags.
+      //
+      // GFM extensions (autolink-literal `@`/`.`/`:`, strikethrough `~~`,
+      // table `|`) register no `text` handler and contribute `unsafe` entries
+      // that flow through safe(). Of those, only `~` is un-escaped below
+      // (single `~` is harmless because GFM strikethrough requires `~~`).
+      text(node2, _parent, state, info) {
+        let s = state.safe(node2.value, info);
+        const nextStartsBracket = typeof info.after === "string" && info.after.startsWith("[");
+        s = s.replace(/\\\[([^\\\]\n`]+)\](?!\s*[:([])/g, (match, label, offset) => {
+          const atEnd = offset + match.length === s.length;
+          if (atEnd && nextStartsBracket) return match;
+          return refDefs.has(normalizeLabel(label)) ? match : `[${label}]`;
+        });
+        s = s.replace(/(?<=\w)\\_(?=\w)/g, "_");
+        s = s.replace(/(?<![`\\])\\`(?!`)/g, "`");
+        s = s.replace(/\\~(?!~)/g, "~");
+        return s;
+      }
+    }
+  }).stringify(tree);
 }
-var parser, serializer;
+var mdParser, stringifyOptions;
 var init_markdown = __esm({
   "src/server/file-io/markdown.ts"() {
     "use strict";
@@ -21930,15 +21965,16 @@ var init_markdown = __esm({
     init_remark_parse();
     init_remark_stringify();
     init_unified();
+    init_unist_util_visit();
     init_mdast_ydoc();
-    parser = unified().use(remarkParse).use(remarkGfm).freeze();
-    serializer = unified().use(remarkGfm).use(remarkStringify, {
+    mdParser = unified().use(remarkParse).use(remarkGfm).freeze();
+    stringifyOptions = {
       bullet: "-",
       emphasis: "*",
       strong: "*",
       listItemIndent: "one",
       rule: "-"
-    }).freeze();
+    };
   }
 });
 
@@ -51802,8 +51838,8 @@ var require_parser = __commonJS({
     "use strict";
     var TokenIterator = require_TokenIterator();
     exports3.Parser = function(options) {
-      var parseTokens = function(parser2, tokens) {
-        return parser2(new TokenIterator(tokens));
+      var parseTokens = function(parser, tokens) {
+        return parser(new TokenIterator(tokens));
       };
       return {
         parseTokens
@@ -52127,16 +52163,16 @@ var require_rules = __commonJS({
         parsers = Array.prototype.slice.call(arguments, 1);
       }
       return function(input) {
-        return lazyIterators.fromArray(parsers).map(function(parser2) {
-          return parser2(input);
+        return lazyIterators.fromArray(parsers).map(function(parser) {
+          return parser(input);
         }).filter(function(result2) {
           return result2.isSuccess() || result2.isError();
         }).first() || describeTokenMismatch(input, name2);
       };
     };
-    exports3.then = function(parser2, func) {
+    exports3.then = function(parser, func) {
       return function(input) {
-        var result2 = parser2(input);
+        var result2 = parser(input);
         if (!result2.map) {
           console.log(result2);
         }
@@ -52146,19 +52182,19 @@ var require_rules = __commonJS({
     exports3.sequence = function() {
       var parsers = Array.prototype.slice.call(arguments, 0);
       var rule = function(input) {
-        var result2 = _3.foldl(parsers, function(memo, parser2) {
+        var result2 = _3.foldl(parsers, function(memo, parser) {
           var result3 = memo.result;
           var hasCut = memo.hasCut;
           if (!result3.isSuccess()) {
             return { result: result3, hasCut };
           }
-          var subResult = parser2(result3.remaining());
+          var subResult = parser(result3.remaining());
           if (subResult.isCut()) {
             return { result: result3, hasCut: true };
           } else if (subResult.isSuccess()) {
             var values2;
-            if (parser2.isCaptured) {
-              values2 = result3.value().withValue(parser2, subResult.value());
+            if (parser.isCaptured) {
+              values2 = result3.value().withValue(parser, subResult.value());
             } else {
               values2 = result3.value();
             }
@@ -52536,8 +52572,8 @@ var require_bottom_up = __commonJS({
     }
     exports3.infix = function(name2, ruleBuilder) {
       function map5(func) {
-        return exports3.infix(name2, function(parser2) {
-          var rule = ruleBuilder(parser2);
+        return exports3.infix(name2, function(parser) {
+          var rule = ruleBuilder(parser);
           return function(tokens) {
             var result2 = rule(tokens);
             return result2.map(function(right) {
@@ -53089,8 +53125,8 @@ var require_style_reader = __commonJS({
     );
     function parseString(rule, string5) {
       var tokens = tokenise(string5);
-      var parser2 = lop.Parser();
-      var parseResult = parser2.parseTokens(rule, tokens);
+      var parser = lop.Parser();
+      var parseResult = parser.parseTokens(rule, tokens);
       if (parseResult.isSuccess()) {
         return results.success(parseResult.value());
       } else {
@@ -55712,8 +55748,8 @@ var init_dist2 = __esm({
         this.options = options ?? defaultOptions;
         this.elementCB = elementCB ?? null;
       }
-      onparserinit(parser2) {
-        this.parser = parser2;
+      onparserinit(parser) {
+        this.parser = parser;
       }
       // Resets the handler back to starting state
       onreset() {
@@ -60792,7 +60828,7 @@ var init_types2 = __esm({
 });
 
 // src/shared/types.ts
-var AnnotationTypeSchema, AnnotationStatusSchema, HighlightColorSchema, SeveritySchema, TandemModeSchema, AuthorSchema, ReplyAuthorSchema, AnnotationActionSchema, ExportFormatSchema, DocumentFormatSchema, ToolErrorCodeSchema;
+var AnnotationTypeSchema, AnnotationStatusSchema, HighlightColorSchema, SeveritySchema, TandemModeSchema, AuthorSchema, ReplyAuthorSchema, AnnotationActionSchema, ExportFormatSchema, DocumentFormatSchema, ToolErrorCodeSchema, ChannelErrorCodeSchema;
 var init_types3 = __esm({
   "src/shared/types.ts"() {
     "use strict";
@@ -60815,9 +60851,13 @@ var init_types3 = __esm({
       "FILE_NOT_FOUND",
       "NO_DOCUMENT",
       "INVALID_RANGE",
+      "INVALID_ARGUMENT",
+      "NOT_FOUND",
+      "ANNOTATION_RESOLVED",
       "FORMAT_ERROR",
       "PERMISSION_DENIED"
     ]);
+    ChannelErrorCodeSchema = external_exports.enum(["CHANNEL_CONNECT_FAILED", "MONITOR_CONNECT_FAILED"]);
   }
 });
 
@@ -67354,7 +67394,7 @@ async function startHocuspocus(port) {
         throw new Error("Connection rejected: missing origin header");
       }
       const url = new URL(origin);
-      if (url.hostname !== "localhost" && url.hostname !== "127.0.0.1" && url.hostname !== TAURI_HOSTNAME) {
+      if (url.hostname !== "127.0.0.1" && url.hostname !== TAURI_HOSTNAME) {
         console.error(`[Hocuspocus] Rejected connection from origin: ${origin}`);
         throw new Error("Connection rejected: invalid origin");
       }
@@ -67924,7 +67964,7 @@ function makeAwarenessObserver(deps) {
   const userAwareness = doc.getMap(Y_MAP_USER_AWARENESS);
   let selectionDwellTimer = null;
   const awarenessObs = (event, txn) => {
-    if (txn.origin === MCP_ORIGIN) return;
+    if (txn.origin === MCP_ORIGIN || txn.origin === FILE_SYNC_ORIGIN) return;
     if (event.keysChanged.has(Y_MAP_SELECTION)) {
       const selection = userAwareness.get(Y_MAP_SELECTION);
       if (selectionDwellTimer) {
@@ -68169,13 +68209,18 @@ function refreshRange(ann, ydoc, map5) {
   if (map5) map5.set(ann.id, updated);
   return updated;
 }
-function refreshAllRanges(annotations, ydoc, map5) {
+function refreshAllRanges(annotations, ydoc, map5, opts) {
   const results = [];
-  ydoc.transact(() => {
+  const run2 = () => {
     for (const ann of annotations) {
       results.push(refreshRange(ann, ydoc, map5));
     }
-  }, MCP_ORIGIN);
+  };
+  if (opts?.skipTransact) {
+    run2();
+  } else {
+    ydoc.transact(run2, MCP_ORIGIN);
+  }
   return results;
 }
 var init_positions2 = __esm({
@@ -69350,7 +69395,7 @@ function registerDocumentTools(server) {
           const doc = getOrCreateDocument(current.docName);
           const awarenessMap = doc.getMap(Y_MAP_AWARENESS);
           doc.transact(
-            () => awarenessMap.set("claude", {
+            () => awarenessMap.set(Y_MAP_CLAUDE, {
               status: text5,
               timestamp: Date.now(),
               active: true,
@@ -69540,6 +69585,13 @@ function addReplyToAnnotation(ydoc, annotationsMap, annotationId, text5, author,
   const raw = annotationsMap.get(annotationId);
   if (!raw) return { ok: false, error: `Annotation ${annotationId} not found`, code: "NOT_FOUND" };
   const ann = sanitizeAnnotation(raw, makeOnLossy(void 0));
+  if (ann.type !== "comment") {
+    return {
+      ok: false,
+      error: `Cannot reply to a ${ann.type} annotation; only comments support replies`,
+      code: "INVALID_ARGUMENT"
+    };
+  }
   if (ann.status !== "pending") {
     return {
       ok: false,
@@ -69787,7 +69839,7 @@ function registerAnnotationTools(server) {
       const repliesMap = getRepliesMap(da.ydoc);
       const annotationsWithReplies = results.map((ann) => ({
         ...ann,
-        replies: collectRepliesForAnnotation(repliesMap, ann.id)
+        replies: ann.type === "comment" ? collectRepliesForAnnotation(repliesMap, ann.id) : []
       }));
       return mcpSuccess({
         annotations: annotationsWithReplies,
@@ -69808,8 +69860,11 @@ function registerAnnotationTools(server) {
       const da = getDocAndAnnotations(documentId);
       if (!da) return noDocumentError();
       const raw = da.map.get(id2);
-      if (!raw) return mcpError("INVALID_RANGE", `Annotation ${id2} not found`);
+      if (!raw) return mcpError("NOT_FOUND", `Annotation ${id2} not found`);
       const ann = sanitizeAnnotation(raw, makeOnLossy(da.docHash));
+      if (ann.status !== "pending") {
+        return mcpError("ANNOTATION_NOT_PENDING", `Annotation ${id2} is already ${ann.status}`);
+      }
       const updated = {
         ...ann,
         status: action === "accept" ? "accepted" : "dismissed",
@@ -69830,7 +69885,7 @@ function registerAnnotationTools(server) {
       const da = getDocAndAnnotations(documentId);
       if (!da) return noDocumentError();
       const result2 = removeAnnotationById(da.ydoc, da.map, da.filePath, id2);
-      if (!result2.ok) return mcpError("INVALID_RANGE", result2.error);
+      if (!result2.ok) return mcpError("NOT_FOUND", result2.error);
       return mcpSuccess({ removed: true, id: id2 });
     })
   );
@@ -69850,20 +69905,20 @@ function registerAnnotationTools(server) {
         const da = getDocAndAnnotations(documentId);
         if (!da) return noDocumentError();
         const raw = da.map.get(id2);
-        if (!raw) return mcpError("INVALID_RANGE", `Annotation ${id2} not found`);
+        if (!raw) return mcpError("NOT_FOUND", `Annotation ${id2} not found`);
         const ann = sanitizeAnnotation(raw, makeOnLossy(da.docHash));
         if (ann.status !== "pending") {
-          return mcpError("INVALID_RANGE", `Cannot edit a ${ann.status} annotation`);
+          return mcpError("ANNOTATION_RESOLVED", `Cannot edit a ${ann.status} annotation`);
         }
         if (content3 === void 0 && newText === void 0 && reason === void 0) {
           return mcpError(
-            "INVALID_RANGE",
+            "INVALID_ARGUMENT",
             "No editable fields provided. Use content, newText, or reason."
           );
         }
         if (newText !== void 0 && ann.type !== "comment") {
           return mcpError(
-            "INVALID_RANGE",
+            "INVALID_ARGUMENT",
             `Cannot set replacement text on a ${ann.type} annotation. Only comments support suggestedText.`
           );
         }
@@ -69903,7 +69958,8 @@ function registerAnnotationTools(server) {
         const fullText = extractText(ydoc);
         const enriched = exportable.map((ann) => ({
           ...ann,
-          replies: collectRepliesForAnnotation(repliesMap, ann.id),
+          // ADR-027: only comments surface replies (see tandem_getAnnotations).
+          replies: ann.type === "comment" ? collectRepliesForAnnotation(repliesMap, ann.id) : [],
           textSnippet: fullText.slice(
             Math.max(0, ann.range.from),
             Math.min(fullText.length, ann.range.to)
@@ -69935,7 +69991,7 @@ function registerAnnotationTools(server) {
         MCP_ORIGIN
       );
       if (!result2.ok) {
-        const code3 = result2.code === "NOT_FOUND" ? "NOT_FOUND" : result2.code === "ANNOTATION_RESOLVED" ? "ANNOTATION_RESOLVED" : "INVALID_RANGE";
+        const code3 = result2.code === "NOT_FOUND" ? "NOT_FOUND" : result2.code === "ANNOTATION_RESOLVED" ? "ANNOTATION_RESOLVED" : result2.code === "INVALID_ARGUMENT" ? "INVALID_ARGUMENT" : "INVALID_RANGE";
         return mcpError(code3, result2.error);
       }
       return mcpSuccess({ replyId: result2.replyId, annotationId });
@@ -69972,6 +70028,7 @@ var init_annotations2 = __esm({
 var file_opener_exports = {};
 __export(file_opener_exports, {
   SUPPORTED_EXTENSIONS: () => SUPPORTED_EXTENSIONS,
+  __testEvictPartialDocState: () => evictPartialDocState,
   openFileByPath: () => openFileByPath,
   openFileFromContent: () => openFileFromContent,
   openScratchpad: () => openScratchpad
@@ -69995,7 +70052,8 @@ async function openFileByPath(filePath, options) {
     const forceReload = options?.force === true;
     if (forceReload) {
       const doc2 = getDocument(id2) ?? getOrCreateDocument(id2);
-      await clearAndReload(id2, doc2, resolved, format, existing);
+      const reloadBuffer = format === "docx" ? await fs4.readFile(resolved) : await fs4.readFile(resolved, "utf-8");
+      await clearAndReload(id2, doc2, resolved, format, existing, reloadBuffer);
       addDoc(id2, { id: id2, filePath: resolved, format, readOnly: readOnly2, source: "file" });
       setActiveDocId(id2);
       await wireAnnotationStore(id2, doc2, resolved);
@@ -70027,7 +70085,7 @@ async function openFileByPath(filePath, options) {
   const doc = getOrCreateDocument(id2);
   const restoredFromSession = await maybeRestoreSession(resolved, doc, fileName);
   if (!restoredFromSession) {
-    await loadContentIntoDoc(doc, format, resolved);
+    await loadContentIntoDoc(doc, format, resolved, id2);
   }
   await finalizeDocOpen(id2, doc, resolved, fileName, format, readOnly2);
   return {
@@ -70062,8 +70120,10 @@ async function openFileFromContent(fileName, content3) {
   const syntheticPath = `${UPLOAD_PREFIX}${randomUUID2()}/${fileName}`;
   const id2 = docIdFromPath(syntheticPath);
   const doc = getOrCreateDocument(id2);
-  const adapter = getAdapter(format);
-  await adapter.load(doc, content3);
+  await populateDocFromContent(doc, format, content3, id2, {
+    displayName: fileName,
+    dedupSource: syntheticPath
+  });
   addDoc(id2, { id: id2, filePath: syntheticPath, format, readOnly: readOnly2, source: "upload" });
   setActiveDocId(id2);
   writeDocMeta(doc, id2, fileName, format, readOnly2);
@@ -70151,7 +70211,7 @@ function handleAlreadyOpen(id2, doc, format, resolved, readOnly2, existing, expl
   if (explicitReadOnly && !existing.readOnly) {
     addDoc(id2, { ...existing, readOnly: true });
     const meta2 = doc.getMap(Y_MAP_DOCUMENT_META);
-    doc.transact(() => meta2.set("readOnly", true), MCP_ORIGIN);
+    doc.transact(() => meta2.set(Y_MAP_READ_ONLY, true), MCP_ORIGIN);
   }
   setActiveDocId(id2);
   broadcastOpenDocs();
@@ -70185,11 +70245,131 @@ async function maybeRestoreSession(resolved, doc, fileName) {
   }
   return false;
 }
-async function loadContentIntoDoc(doc, format, resolved) {
-  const adapter = getAdapter(format);
-  const isDocx = format === "docx";
-  const fileContent = isDocx ? await fs4.readFile(resolved) : await fs4.readFile(resolved, "utf-8");
-  await adapter.load(doc, fileContent);
+async function prepareContent(format, source, ctx) {
+  if (format === "docx") {
+    if (!Buffer.isBuffer(source)) {
+      throw Object.assign(new Error("prepareContent: docx requires Buffer source"), {
+        code: "INVALID_SOURCE"
+      });
+    }
+    const buffer3 = source;
+    const [html2, comments] = await Promise.all([
+      loadDocx(buffer3),
+      extractDocxComments(buffer3).catch((err) => {
+        console.error("[docx-comments] Comment extraction failed:", err);
+        pushNotification({
+          id: generateNotificationId(),
+          type: "annotation-error",
+          severity: "warning",
+          message: `Failed to import Word comments from ${ctx.displayName}. Document opened without comments.`,
+          dedupKey: `docx-comments:${ctx.dedupSource}`,
+          timestamp: Date.now()
+        });
+        return [];
+      })
+    ]);
+    return { format: "docx", html: html2, comments };
+  }
+  const content3 = typeof source === "string" ? source : source.toString("utf-8");
+  if (format === "md") return { format: "md", content: content3 };
+  return { format: "other", content: content3 };
+}
+function applyPreparedContent(doc, prepared, ctx) {
+  switch (prepared.format) {
+    case "docx": {
+      htmlToYDoc(doc, prepared.html);
+      if (prepared.comments.length > 0) {
+        const annotMap = doc.getMap(Y_MAP_ANNOTATIONS);
+        const before2 = new Set(annotMap.keys());
+        try {
+          injectCommentsAsAnnotations(doc, prepared.comments);
+        } catch (err) {
+          for (const k of annotMap.keys()) {
+            if (!before2.has(k)) annotMap.delete(k);
+          }
+          console.error(
+            "[docx-comments] inject failed mid-transact; document loads without imported comments:",
+            err
+          );
+          pushNotification({
+            id: generateNotificationId(),
+            type: "annotation-error",
+            severity: "warning",
+            message: `Failed to import some Word comments from ${ctx.displayName}. Document opened, but comments may be missing.`,
+            dedupKey: `docx-comments-inject:${ctx.dedupSource}`,
+            timestamp: Date.now()
+          });
+        }
+      }
+      return;
+    }
+    case "md":
+      loadMarkdown(doc, prepared.content);
+      return;
+    case "other":
+      populateYDoc(doc, prepared.content);
+      return;
+  }
+}
+async function loadContentIntoDoc(doc, format, resolved, docId) {
+  const buffer3 = await fs4.readFile(resolved);
+  await populateDocFromContent(doc, format, buffer3, docId, {
+    displayName: path8.basename(resolved),
+    dedupSource: resolved
+  });
+}
+async function populateDocFromContent(doc, format, source, docId, ctx) {
+  const prepared = await prepareContent(format, source, ctx);
+  try {
+    doc.transact(() => applyPreparedContent(doc, prepared, ctx), MCP_ORIGIN);
+  } catch (err) {
+    let cleanupOk = true;
+    try {
+      doc.transact(() => {
+        const fragment = doc.getXmlFragment("default");
+        fragment.delete(0, fragment.length);
+        const annotations = doc.getMap(Y_MAP_ANNOTATIONS);
+        for (const k of [...annotations.keys()]) annotations.delete(k);
+      }, MCP_ORIGIN);
+    } catch (cleanupErr) {
+      cleanupOk = false;
+      console.error(
+        "[Tandem] populateDocFromContent: cleanup after populate failure also failed:",
+        cleanupErr
+      );
+      try {
+        evictPartialDocState(doc, docId);
+      } catch (evictErr) {
+        console.error(
+          "[Tandem] populateDocFromContent: eviction after cleanup failure also failed:",
+          evictErr
+        );
+      }
+    }
+    console.error(
+      "[Tandem] populateDocFromContent: populate failed; partial state cleared before rethrow.",
+      { format, displayName: ctx.displayName, cleanupOk },
+      err
+    );
+    throw err;
+  }
+}
+function evictPartialDocState(doc, docId) {
+  if (docId) {
+    clearFileSyncContext(docId);
+  }
+  doc.transact(() => {
+    const annotations = doc.getMap(Y_MAP_ANNOTATIONS);
+    annotations.forEach((_3, k) => annotations.delete(k));
+    const annotationReplies = doc.getMap(Y_MAP_ANNOTATION_REPLIES);
+    annotationReplies.forEach((_3, k) => annotationReplies.delete(k));
+    const awareness = doc.getMap(Y_MAP_AWARENESS);
+    awareness.forEach((_3, k) => awareness.delete(k));
+    const userAwareness = doc.getMap(Y_MAP_USER_AWARENESS);
+    userAwareness.forEach((_3, k) => userAwareness.delete(k));
+    const fragment = doc.getXmlFragment("default");
+    fragment.delete(0, fragment.length);
+  }, FILE_SYNC_ORIGIN);
 }
 async function finalizeDocOpen(id2, doc, resolved, fileName, format, readOnly2) {
   addDoc(id2, { id: id2, filePath: resolved, format, readOnly: readOnly2, source: "file" });
@@ -70226,7 +70406,7 @@ async function wireAnnotationStore(id2, doc, filePath) {
     });
   }
 }
-async function clearAndReload(id2, doc, filePath, format, existing) {
+async function clearAndReload(id2, doc, resolved, format, existing, source) {
   console.error(`[Tandem] clearAndReload: reloading ${id2} from disk`);
   const dropped = clearFileSyncContext(id2);
   if (dropped) {
@@ -70236,25 +70416,12 @@ async function clearAndReload(id2, doc, filePath, format, existing) {
       console.error("[Tandem] clearAndReload: store.clear failed for %s:", id2, err);
     }
   }
+  const ctx = {
+    displayName: path8.basename(resolved),
+    dedupSource: resolved
+  };
+  const prepared = await prepareContent(format, source, ctx);
   const isDocx = format === "docx";
-  let preparedHtml;
-  let preparedComments;
-  let preparedContent;
-  if (isDocx) {
-    const buffer3 = await fs4.readFile(filePath);
-    [preparedHtml, preparedComments] = await Promise.all([
-      loadDocx(buffer3),
-      extractDocxComments(buffer3).catch((err) => {
-        console.error(
-          "[docx-comments] Comment extraction failed; document will reload without imported comments:",
-          err
-        );
-        return [];
-      })
-    ]);
-  } else {
-    preparedContent = await fs4.readFile(filePath, "utf-8");
-  }
   try {
     doc.transact(() => {
       const annotations = doc.getMap(Y_MAP_ANNOTATIONS);
@@ -70265,21 +70432,12 @@ async function clearAndReload(id2, doc, filePath, format, existing) {
       awareness.forEach((_3, k) => awareness.delete(k));
       const userAwareness = doc.getMap(Y_MAP_USER_AWARENESS);
       userAwareness.forEach((_3, k) => userAwareness.delete(k));
-      if (isDocx && preparedHtml !== void 0) {
-        htmlToYDoc(doc, preparedHtml);
-        if (preparedComments && preparedComments.length > 0) {
-          injectCommentsAsAnnotations(doc, preparedComments);
-        }
-      } else if (format === "md" && preparedContent !== void 0) {
-        loadMarkdown(doc, preparedContent);
-      } else if (preparedContent !== void 0) {
-        populateYDoc(doc, preparedContent);
-      }
+      applyPreparedContent(doc, prepared, ctx);
       const meta2 = doc.getMap(Y_MAP_DOCUMENT_META);
-      meta2.set("readOnly", isDocx);
+      meta2.set(Y_MAP_READ_ONLY, isDocx);
       meta2.set("format", format);
       meta2.set("documentId", id2);
-      meta2.set("fileName", path8.basename(filePath));
+      meta2.set("fileName", path8.basename(resolved));
       meta2.set(Y_MAP_SAVED_AT_VERSION, Date.now());
     }, MCP_ORIGIN);
     attachObservers(id2, doc);
@@ -70307,7 +70465,7 @@ async function initSavedBaseline(doc, filePath) {
 function writeDocMeta(doc, id2, fileName, format, readOnly2) {
   const meta2 = doc.getMap(Y_MAP_DOCUMENT_META);
   doc.transact(() => {
-    meta2.set("readOnly", readOnly2);
+    meta2.set(Y_MAP_READ_ONLY, readOnly2);
     meta2.set("format", format);
     meta2.set("documentId", id2);
     meta2.set("fileName", fileName);
@@ -70354,7 +70512,7 @@ async function reloadFromDisk(id2, filePath, format) {
       } else {
         populateYDoc(doc, fileContent);
       }
-    }, MCP_ORIGIN);
+    }, FILE_SYNC_ORIGIN);
     const annotationMap = doc.getMap(Y_MAP_ANNOTATIONS);
     const annotations = [];
     const reloadDocHash = docHash(filePath);
@@ -70367,8 +70525,8 @@ async function reloadFromDisk(id2, filePath, format) {
       )
     );
     if (annotations.length > 0) {
-      const refreshed = refreshAllRanges(annotations, doc, annotationMap);
       doc.transact(() => {
+        const refreshed = refreshAllRanges(annotations, doc, annotationMap, { skipTransact: true });
         for (const ann of refreshed) {
           if (!ann.textSnapshot) continue;
           const vr = validateRange(doc, ann.range.from, ann.range.to, {
@@ -70840,7 +70998,8 @@ function makeRepliesObserver(deps) {
       const reply = repliesMap.get(key);
       if (!reply || reply.author !== "user") continue;
       const parentAnn = annotationsMap.get(reply.annotationId);
-      const textSnippet = parentAnn?.textSnapshot ?? "";
+      if (!parentAnn || parentAnn.type !== "comment") continue;
+      const textSnippet = parentAnn.textSnapshot ?? "";
       pushEvent2({
         id: generateEventId(),
         type: "annotation:reply",
@@ -72687,133 +72846,6 @@ var require_browser = __commonJS({
   }
 });
 
-// node_modules/has-flag/index.js
-var require_has_flag = __commonJS({
-  "node_modules/has-flag/index.js"(exports3, module3) {
-    "use strict";
-    module3.exports = (flag, argv = process.argv) => {
-      const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
-      const position2 = argv.indexOf(prefix + flag);
-      const terminatorPosition = argv.indexOf("--");
-      return position2 !== -1 && (terminatorPosition === -1 || position2 < terminatorPosition);
-    };
-  }
-});
-
-// node_modules/supports-color/index.js
-var require_supports_color = __commonJS({
-  "node_modules/supports-color/index.js"(exports3, module3) {
-    "use strict";
-    var os2 = __require("os");
-    var tty = __require("tty");
-    var hasFlag = require_has_flag();
-    var { env: env3 } = process;
-    var flagForceColor;
-    if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) {
-      flagForceColor = 0;
-    } else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) {
-      flagForceColor = 1;
-    }
-    function envForceColor() {
-      if ("FORCE_COLOR" in env3) {
-        if (env3.FORCE_COLOR === "true") {
-          return 1;
-        }
-        if (env3.FORCE_COLOR === "false") {
-          return 0;
-        }
-        return env3.FORCE_COLOR.length === 0 ? 1 : Math.min(Number.parseInt(env3.FORCE_COLOR, 10), 3);
-      }
-    }
-    function translateLevel(level) {
-      if (level === 0) {
-        return false;
-      }
-      return {
-        level,
-        hasBasic: true,
-        has256: level >= 2,
-        has16m: level >= 3
-      };
-    }
-    function supportsColor2(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
-      const noFlagForceColor = envForceColor();
-      if (noFlagForceColor !== void 0) {
-        flagForceColor = noFlagForceColor;
-      }
-      const forceColor2 = sniffFlags ? flagForceColor : noFlagForceColor;
-      if (forceColor2 === 0) {
-        return 0;
-      }
-      if (sniffFlags) {
-        if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) {
-          return 3;
-        }
-        if (hasFlag("color=256")) {
-          return 2;
-        }
-      }
-      if (haveStream && !streamIsTTY && forceColor2 === void 0) {
-        return 0;
-      }
-      const min5 = forceColor2 || 0;
-      if (env3.TERM === "dumb") {
-        return min5;
-      }
-      if (process.platform === "win32") {
-        const osRelease = os2.release().split(".");
-        if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
-          return Number(osRelease[2]) >= 14931 ? 3 : 2;
-        }
-        return 1;
-      }
-      if ("CI" in env3) {
-        if (["TRAVIS", "CIRCLECI", "APPVEYOR", "GITLAB_CI", "GITHUB_ACTIONS", "BUILDKITE", "DRONE"].some((sign) => sign in env3) || env3.CI_NAME === "codeship") {
-          return 1;
-        }
-        return min5;
-      }
-      if ("TEAMCITY_VERSION" in env3) {
-        return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env3.TEAMCITY_VERSION) ? 1 : 0;
-      }
-      if (env3.COLORTERM === "truecolor") {
-        return 3;
-      }
-      if ("TERM_PROGRAM" in env3) {
-        const version3 = Number.parseInt((env3.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
-        switch (env3.TERM_PROGRAM) {
-          case "iTerm.app":
-            return version3 >= 3 ? 3 : 2;
-          case "Apple_Terminal":
-            return 2;
-        }
-      }
-      if (/-256(color)?$/i.test(env3.TERM)) {
-        return 2;
-      }
-      if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env3.TERM)) {
-        return 1;
-      }
-      if ("COLORTERM" in env3) {
-        return 1;
-      }
-      return min5;
-    }
-    function getSupportLevel(stream, options = {}) {
-      const level = supportsColor2(stream, {
-        streamIsTTY: stream && stream.isTTY,
-        ...options
-      });
-      return translateLevel(level);
-    }
-    module3.exports = {
-      supportsColor: getSupportLevel,
-      stdout: getSupportLevel({ isTTY: tty.isatty(1) }),
-      stderr: getSupportLevel({ isTTY: tty.isatty(2) })
-    };
-  }
-});
-
 // node_modules/debug/src/node.js
 var require_node2 = __commonJS({
   "node_modules/debug/src/node.js"(exports3, module3) {
@@ -72833,7 +72865,7 @@ var require_node2 = __commonJS({
     );
     exports3.colors = [6, 2, 3, 4, 5, 1];
     try {
-      const supportsColor2 = require_supports_color();
+      const supportsColor2 = __require("supports-color");
       if (supportsColor2 && (supportsColor2.stderr || supportsColor2).level >= 2) {
         exports3.colors = [
           20,
@@ -102722,7 +102754,6 @@ var require_dist3 = __commonJS({
 // src/server/mcp/launcher.ts
 var launcher_exports = {};
 __export(launcher_exports, {
-  killClaude: () => killClaude,
   launchClaude: () => launchClaude
 });
 import { spawn } from "child_process";
@@ -102731,7 +102762,7 @@ function launchClaude() {
     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 tandemUrl = `http://127.0.0.1:${process.env.TANDEM_MCP_PORT || DEFAULT_MCP_PORT}`;
   const args2 = [
     "--dangerously-load-development-channels",
     "server:tandem-channel",
@@ -102777,20 +102808,6 @@ function launchClaude() {
   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 code3 = err.code;
-      if (code3 !== "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"() {
@@ -114664,33 +114681,34 @@ function createAuthMiddleware(getToken) {
   };
 }
 
-// src/server/open-browser.ts
-import { execFile } from "child_process";
-function openBrowser(url) {
-  let command;
-  let args2;
-  if (process.platform === "win32") {
-    command = "cmd";
-    args2 = ["/c", "start", "", url];
-  } else if (process.platform === "darwin") {
-    command = "open";
-    args2 = [url];
-  } else {
-    command = "xdg-open";
-    args2 = [url];
-  }
-  execFile(command, args2, (err) => {
-    if (err) {
-      console.error("[Tandem] Could not open browser automatically.");
-      console.error(`[Tandem] Open this URL manually: ${url}`);
-    }
-  });
-}
-
 // src/server/mcp/server.ts
 init_platform();
 init_annotations2();
 
+// src/shared/api-paths.ts
+var API_EVENTS = "/api/events";
+var API_NOTIFY_STREAM = "/api/notify-stream";
+var API_CHANNEL_AWARENESS = "/api/channel-awareness";
+var API_CHANNEL_ERROR = "/api/channel-error";
+var API_CHANNEL_REPLY = "/api/channel-reply";
+var API_CHANNEL_PERMISSION = "/api/channel-permission";
+var API_CHANNEL_PERMISSION_VERDICT = "/api/channel-permission-verdict";
+var API_LAUNCH_CLAUDE = "/api/launch-claude";
+var API_MODE = "/api/mode";
+var API_INFO = "/api/info";
+var API_OPEN = "/api/open";
+var API_CLOSE = "/api/close";
+var API_SAVE = "/api/save";
+var API_UPLOAD = "/api/upload";
+var API_SCRATCHPAD = "/api/scratchpad";
+var API_CONVERT = "/api/convert";
+var API_APPLY_CHANGES = "/api/apply-changes";
+var API_ANNOTATION_REPLY = "/api/annotation-reply";
+var API_REMOVE_ANNOTATION = "/api/remove-annotation";
+var API_CHAT = "/api/chat";
+var API_SETUP = "/api/setup";
+var API_ROTATE_TOKEN = "/api/rotate-token";
+
 // src/server/mcp/api-routes.ts
 init_constants();
 
@@ -114720,7 +114738,7 @@ function handleAnnotationReply(req, res) {
   const annotationsMap = ydoc.getMap(Y_MAP_ANNOTATIONS);
   const result2 = addReplyToAnnotation(ydoc, annotationsMap, annotationId, text5, "user");
   if (!result2.ok) {
-    const status = result2.code === "ANNOTATION_RESOLVED" ? 409 : 404;
+    const status = result2.code === "ANNOTATION_RESOLVED" ? 409 : result2.code === "INVALID_ARGUMENT" ? 400 : 404;
     console.warn(`[Tandem] API error (${status}): annotation reply failed: ${result2.error}`);
     pushNotification({
       id: generateNotificationId(),
@@ -114945,11 +114963,15 @@ function errorCodeToHttpStatus(code3) {
     case "ENOENT":
     case "FILE_NOT_FOUND":
     case "NO_DOCUMENT":
+    case "NOT_FOUND":
       return 404;
     case "INVALID_PATH":
     case "UNSUPPORTED_FORMAT":
     case "NO_SUGGESTIONS":
+    case "INVALID_ARGUMENT":
       return 400;
+    case "ANNOTATION_RESOLVED":
+      return 409;
     case "FILE_TOO_LARGE":
       return 413;
     case "EBUSY":
@@ -114968,12 +114990,16 @@ function errorCodeToLabel(code3) {
     case "ENOENT":
     case "FILE_NOT_FOUND":
     case "NO_DOCUMENT":
+    case "NOT_FOUND":
       return "NOT_FOUND";
     case "INVALID_PATH":
       return "INVALID_PATH";
     case "UNSUPPORTED_FORMAT":
     case "NO_SUGGESTIONS":
+    case "INVALID_ARGUMENT":
       return "BAD_REQUEST";
+    case "ANNOTATION_RESOLVED":
+      return "ANNOTATION_RESOLVED";
     case "FILE_TOO_LARGE":
       return "FILE_TOO_LARGE";
     case "EBUSY":
@@ -115320,7 +115346,7 @@ var SKILL_CONTENT = readFileSync(SKILL_PATH, "utf-8");
 var __dirname2 = dirname2(fileURLToPath3(import.meta.url));
 var PACKAGE_ROOT = resolve3(__dirname2, "../..");
 var CHANNEL_DIST = resolve3(PACKAGE_ROOT, "dist/channel/index.js");
-var MCP_URL = `http://localhost:${DEFAULT_MCP_PORT}`;
+var MCP_URL = `http://127.0.0.1:${DEFAULT_MCP_PORT}`;
 function buildMcpEntries(channelPath, opts = {}) {
   const isDesktop = opts.targetKind === "claude-desktop";
   let tandemEntry;
@@ -115584,7 +115610,7 @@ async function handleUpload(req, res) {
 // src/server/mcp/api-routes.ts
 function isHostAllowed(host, extraHosts = []) {
   const reqHost = (host ?? "").split(":")[0];
-  if (reqHost === "localhost" || reqHost === "127.0.0.1" || reqHost === TAURI_HOSTNAME) {
+  if (reqHost === "127.0.0.1" || reqHost === TAURI_HOSTNAME) {
     return true;
   }
   return extraHosts.includes(reqHost);
@@ -115593,7 +115619,7 @@ function escapeRegExp2(s) {
   return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 var LOCALHOST_ORIGIN_RE = new RegExp(
-  `^https?://(localhost|127\\.0\\.0\\.1|${escapeRegExp2(TAURI_HOSTNAME)})(:\\d+)?$`
+  `^https?://(127\\.0\\.0\\.1|${escapeRegExp2(TAURI_HOSTNAME)})(:\\d+)?$`
 );
 function isLocalhostOrigin(origin) {
   return LOCALHOST_ORIGIN_RE.test(origin ?? "");
@@ -115617,32 +115643,32 @@ function createApiMiddleware(extraHosts = []) {
 }
 var apiMiddleware = createApiMiddleware();
 function registerApiRoutes(app, largeBody, token, mw, setCurrentToken, getCurrentToken, infoHandlerDeps) {
-  app.get("/api/info", mw, makeInfoHandler(infoHandlerDeps));
-  app.get("/api/notify-stream", mw, handleNotifyStream);
-  app.get("/api/mode", mw, handleMode);
-  app.options("/api/open", mw);
-  app.post("/api/open", mw, largeBody, handleOpen);
-  app.options("/api/close", mw);
-  app.post("/api/close", mw, largeBody, handleClose);
-  app.options("/api/save", mw);
-  app.post("/api/save", mw, largeBody, handleSave);
-  app.options("/api/upload", mw);
-  app.post("/api/upload", mw, largeBody, handleUpload);
-  app.options("/api/scratchpad", mw);
-  app.post("/api/scratchpad", mw, handleScratchpad);
-  app.options("/api/convert", mw);
-  app.post("/api/convert", mw, largeBody, handleConvert);
-  app.options("/api/apply-changes", mw);
-  app.post("/api/apply-changes", mw, largeBody, handleApplyChanges);
-  app.options("/api/setup", mw);
-  app.post("/api/setup", mw, largeBody, makeSetupHandler({ token }));
-  app.options("/api/annotation-reply", mw);
-  app.post("/api/annotation-reply", mw, largeBody, handleAnnotationReply);
-  app.options("/api/remove-annotation", mw);
-  app.post("/api/remove-annotation", mw, largeBody, handleRemoveAnnotation);
-  app.options("/api/rotate-token", mw);
+  app.get(API_INFO, mw, makeInfoHandler(infoHandlerDeps));
+  app.get(API_NOTIFY_STREAM, mw, handleNotifyStream);
+  app.get(API_MODE, mw, handleMode);
+  app.options(API_OPEN, mw);
+  app.post(API_OPEN, mw, largeBody, handleOpen);
+  app.options(API_CLOSE, mw);
+  app.post(API_CLOSE, mw, largeBody, handleClose);
+  app.options(API_SAVE, mw);
+  app.post(API_SAVE, mw, largeBody, handleSave);
+  app.options(API_UPLOAD, mw);
+  app.post(API_UPLOAD, mw, largeBody, handleUpload);
+  app.options(API_SCRATCHPAD, mw);
+  app.post(API_SCRATCHPAD, mw, handleScratchpad);
+  app.options(API_CONVERT, mw);
+  app.post(API_CONVERT, mw, largeBody, handleConvert);
+  app.options(API_APPLY_CHANGES, mw);
+  app.post(API_APPLY_CHANGES, mw, largeBody, handleApplyChanges);
+  app.options(API_SETUP, mw);
+  app.post(API_SETUP, mw, largeBody, makeSetupHandler({ token }));
+  app.options(API_ANNOTATION_REPLY, mw);
+  app.post(API_ANNOTATION_REPLY, mw, largeBody, handleAnnotationReply);
+  app.options(API_REMOVE_ANNOTATION, mw);
+  app.post(API_REMOVE_ANNOTATION, mw, largeBody, handleRemoveAnnotation);
+  app.options(API_ROTATE_TOKEN, mw);
   app.post(
-    "/api/rotate-token",
+    API_ROTATE_TOKEN,
     mw,
     largeBody,
     makeRotateTokenHandler({ setCurrentToken, getCurrentToken })
@@ -115847,6 +115873,7 @@ function processUnsurfacedInboxAnnotations(unsurfaced, fullText, surfaced, wasCh
 
 // src/server/mcp/channel-routes.ts
 init_constants();
+init_types3();
 init_utils();
 init_queue();
 
@@ -115904,9 +115931,9 @@ 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) => {
+  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, focusOffset } = req.body ?? {};
     if (typeof status !== "string") {
       res.status(400).json({ error: "BAD_REQUEST", message: "status is required" });
@@ -115923,18 +115950,24 @@ function registerChannelRoutes(app, apiMiddleware2) {
         focusParagraph: typeof focusParagraph === "number" ? focusParagraph : null,
         focusOffset: typeof focusOffset === "number" ? focusOffset : null
       };
-      doc.transact(() => awarenessMap.set("claude", state), MCP_ORIGIN);
+      doc.transact(() => awarenessMap.set(Y_MAP_CLAUDE, state), MCP_ORIGIN);
     }
     res.json({ ok: true, written: !!docId });
   });
-  app.options("/api/channel-error", apiMiddleware2);
-  app.post("/api/channel-error", apiMiddleware2, (req, res) => {
+  app.options(API_CHANNEL_ERROR, apiMiddleware2);
+  app.post(API_CHANNEL_ERROR, apiMiddleware2, (req, res) => {
     const { error: error2, message } = req.body ?? {};
-    console.error(`[Channel] Error: ${error2} \u2014 ${message}`);
+    const parsed = ChannelErrorCodeSchema.safeParse(error2);
+    if (!parsed.success) {
+      console.error(`[Channel] Error: UNKNOWN_CODE (${String(error2)}) \u2014 ${message}`);
+      res.status(400).json({ error: "BAD_REQUEST", message: "error must be a known ChannelErrorCode" });
+      return;
+    }
+    console.error(`[Channel] Error: ${parsed.data} \u2014 ${message}`);
     res.json({ ok: true });
   });
-  app.options("/api/channel-reply", apiMiddleware2);
-  app.post("/api/channel-reply", apiMiddleware2, (req, res) => {
+  app.options(API_CHANNEL_REPLY, apiMiddleware2);
+  app.post(API_CHANNEL_REPLY, apiMiddleware2, (req, res) => {
     const { text: text5, documentId, replyTo } = req.body ?? {};
     if (typeof text5 !== "string") {
       res.status(400).json({ error: "BAD_REQUEST", message: "text is required" });
@@ -115955,8 +115988,8 @@ function registerChannelRoutes(app, apiMiddleware2) {
     ctrlDoc.transact(() => chatMap.set(id2, msg), MCP_ORIGIN);
     res.json({ sent: true, messageId: id2 });
   });
-  app.options("/api/channel-permission", apiMiddleware2);
-  app.post("/api/channel-permission", apiMiddleware2, (req, res) => {
+  app.options(API_CHANNEL_PERMISSION, apiMiddleware2);
+  app.post(API_CHANNEL_PERMISSION, apiMiddleware2, (req, res) => {
     const { requestId, toolName, description: description2, inputPreview } = req.body ?? {};
     if (typeof requestId !== "string" || typeof toolName !== "string") {
       res.status(400).json({ error: "BAD_REQUEST", message: "requestId and toolName required" });
@@ -115972,15 +116005,15 @@ function registerChannelRoutes(app, apiMiddleware2) {
     console.error(`[Channel] Permission request: ${toolName} \u2014 ${description2} (id: ${requestId})`);
     res.json({ ok: true });
   });
-  app.get("/api/channel-permission", apiMiddleware2, (_req, res) => {
+  app.get(API_CHANNEL_PERMISSION, apiMiddleware2, (_req, res) => {
     const now = Date.now();
     for (const [id2, perm] of pendingPermissions) {
       if (now - perm.createdAt > PERMISSION_TTL_MS) pendingPermissions.delete(id2);
     }
     res.json({ pending: Array.from(pendingPermissions.values()) });
   });
-  app.options("/api/channel-permission-verdict", apiMiddleware2);
-  app.post("/api/channel-permission-verdict", apiMiddleware2, (req, res) => {
+  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" });
@@ -115990,8 +116023,8 @@ function registerChannelRoutes(app, apiMiddleware2) {
     console.error(`[Channel] Permission verdict: ${requestId} \u2192 ${approved ? "allow" : "deny"}`);
     res.json({ ok: true, requestId, behavior: approved ? "allow" : "deny" });
   });
-  app.options("/api/chat", apiMiddleware2);
-  app.delete("/api/chat", apiMiddleware2, (_req, res) => {
+  app.options(API_CHAT, apiMiddleware2);
+  app.delete(API_CHAT, apiMiddleware2, (_req, res) => {
     const ctrlDoc = getOrCreateDocument(CTRL_ROOM);
     const chatMap = ctrlDoc.getMap(Y_MAP_CHAT);
     const count = chatMap.size;
@@ -116002,8 +116035,8 @@ function registerChannelRoutes(app, apiMiddleware2) {
     }, MCP_ORIGIN);
     res.json({ ok: true, cleared: count });
   });
-  app.options("/api/launch-claude", apiMiddleware2);
-  app.post("/api/launch-claude", apiMiddleware2, async (_req, res) => {
+  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 result2 = launchClaude2();
@@ -116146,7 +116179,7 @@ function registerNavigationTools(server) {
 
 // src/server/mcp/server.ts
 var esmRequire = createRequire(import.meta.url);
-var APP_VERSION = true ? "0.11.2" : _readVersionFromDisk();
+var APP_VERSION = true ? "0.12.0" : _readVersionFromDisk();
 var MCP_SDK_VERSION = true ? "1.27.1" : "0.0.0-unknown";
 var __dirname3 = dirname3(fileURLToPath4(import.meta.url));
 var CLIENT_DIST = join3(__dirname3, "../client");
@@ -116296,9 +116329,9 @@ async function startMcpServerHttp(port, host = DEFAULT_BIND_HOST, token, resolve
     (_req, res) => {
       res.header("Access-Control-Allow-Origin", "*");
       res.json({
-        resource: `http://localhost:${port}/mcp`,
+        resource: `http://127.0.0.1:${port}/mcp`,
         bearer_methods_supported: ["header"],
-        authorization_servers: [`http://localhost:${port}`]
+        authorization_servers: [`http://127.0.0.1:${port}`]
       });
     }
   );
@@ -116307,9 +116340,9 @@ async function startMcpServerHttp(port, host = DEFAULT_BIND_HOST, token, resolve
     (_req, res) => {
       res.header("Access-Control-Allow-Origin", "*");
       res.json({
-        resource: `http://localhost:${port}/mcp`,
+        resource: `http://127.0.0.1:${port}/mcp`,
         bearer_methods_supported: ["header"],
-        authorization_servers: [`http://localhost:${port}`]
+        authorization_servers: [`http://127.0.0.1:${port}`]
       });
     }
   );
@@ -116352,13 +116385,6 @@ async function startMcpServerHttp(port, host = DEFAULT_BIND_HOST, token, resolve
       httpServer2.removeListener("error", reject2);
       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 (existsSync2(CLIENT_DIST)) {
-          openBrowser(`http://localhost:${port}`);
-        } else {
-          console.error("[Tandem] Skipping browser open \u2014 no client assets found");
-        }
-      }
       resolve4(httpServer2);
     });
     httpServer2.on("error", reject2);
@@ -116430,10 +116456,17 @@ function injectTutorialAnnotations(doc) {
       }
       const annotation = {
         id: def.id,
-        author: "claude",
+        // Notes are user-private (ADR-027); Claude can't author user-private content.
+        // Comments and highlights are seeded as if Claude wrote them so the user
+        // sees the cross-author authorship indicator.
+        author: def.type === "note" ? "user" : "claude",
         type: def.type,
         range: result2.range,
-        relRange: result2.relRange,
+        // Only attach a CRDT-anchored relRange when fully resolved. Matches
+        // the reloadFromDisk pattern (file-opener.ts) — a partial anchor
+        // leaks a half-resolved RelativePosition that downstream code would
+        // re-anchor anyway via the lazy-attach path in refreshRange.
+        ...result2.fullyAnchored ? { relRange: result2.relRange } : {},
         content: def.content,
         status: "pending",
         timestamp: Date.now(),
@@ -116456,6 +116489,25 @@ init_notifications();
 init_platform();
 init_manager();
 
+// src/server/startup-file.ts
+init_document_service();
+init_file_opener();
+async function maybeOpenStartupFile(envPath) {
+  if (!envPath || envPath.trim() === "") return false;
+  let result2;
+  try {
+    result2 = await openFileByPath(envPath);
+  } catch (err) {
+    console.error(
+      `[Tandem] TANDEM_OPEN_FILE failed (${envPath}): ${err instanceof Error ? err.message : String(err)}`
+    );
+    return false;
+  }
+  setActiveDocId(result2.documentId);
+  console.error(`[Tandem] Opened TANDEM_OPEN_FILE on startup: ${envPath}`);
+  return true;
+}
+
 // src/server/version-check.ts
 import fs11 from "fs/promises";
 import path15 from "path";
@@ -116478,7 +116530,7 @@ async function checkVersionChange(currentVersion, versionFilePath) {
 
 // src/server/index.ts
 init_provider();
-var isProduction = process.env.TANDEM_OPEN_BROWSER === "1";
+var isProduction = process.env.TANDEM_TAURI_SIDECAR === "1";
 var SUPPRESSED_PATTERNS = [/^\[mammoth\]/, /Invalid access/i, /^\s*add yjs type/i];
 var originalStderrWrite = process.stderr.write.bind(process.stderr);
 if (isProduction) {
@@ -116709,7 +116761,12 @@ async function main2() {
     } catch (err) {
       console.error("[Tandem] Version check / changelog open failed (non-fatal):", err);
     }
+    const startupFileRequested = !!process.env.TANDEM_OPEN_FILE?.trim();
+    const startupFileOpened = await maybeOpenStartupFile(process.env.TANDEM_OPEN_FILE);
     if (docCount() === 0 && !process.env.TANDEM_NO_SAMPLE) {
+      if (startupFileRequested && !startupFileOpened) {
+        console.error("[Tandem] Falling back to welcome.md after TANDEM_OPEN_FILE failure");
+      }
       const sampleBase = process.env.TANDEM_DATA_DIR || projectRoot;
       const samplePath = path16.join(sampleBase, "sample/welcome.md");
       try {
@@ -116731,16 +116788,16 @@ async function main2() {
     const [srv] = await Promise.all([
       startMcpServerHttp(mcpPort, bindHost, authToken, resolvedLanIP),
       startHocuspocus(wsPort).then(() => {
-        console.error(`[Tandem] Hocuspocus WebSocket server running on ws://localhost:${wsPort}`);
+        console.error(`[Tandem] Hocuspocus WebSocket server running on ws://127.0.0.1:${wsPort}`);
       })
     ]);
     httpServer = srv;
     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(`  MCP HTTP:    http://127.0.0.1:${mcpPort}/mcp`);
+    console.error(`  WebSocket:   ws://127.0.0.1:${wsPort}`);
+    console.error(`  Health:      http://127.0.0.1:${mcpPort}/health`);
     console.error("");
     console.error("  Open Claude Code and ask Claude to review a document.");
     console.error("");
@@ -116753,7 +116810,7 @@ async function main2() {
         console.error(`[Tandem] ${err instanceof Error ? err.message : err} \u2014 proceeding anyway`);
       }
       await startHocuspocus(wsPort);
-      console.error(`[Tandem] Hocuspocus WebSocket server running on ws://localhost:${wsPort}`);
+      console.error(`[Tandem] Hocuspocus WebSocket server running on ws://127.0.0.1:${wsPort}`);
     })().catch((err) => {
       console.error("[Tandem] Hocuspocus startup error:", err);
     });