overleaf-review 0.5.0 → 0.6.0

package/dist/cli.js

@@ -1,577 +1,49 @@
 #!/usr/bin/env node
+import {
+  RestRequestError,
+  SNAPSHOTS_DIR,
+  TrackedChangeMutationError,
+  acceptChanges,
+  acquireMutationLock,
+  applyOtUpdateAndWait,
+  beginReceipt,
+  buildRejectionPlan,
+  config,
+  consolidateApply,
+  consolidatePreview,
+  deleteMessage,
+  deleteThread,
+  findRecentIdenticalMessage,
+  fingerprintRanges,
+  getCsrfToken,
+  getThreads,
+  joinDoc,
+  matchDocument,
+  mergeBaseDocuments,
+  observePostedThreadMessage,
+  openProject,
+  postThreadMessageDetailed,
+  push,
+  readReceipts,
+  remainingChangeIds,
+  saveCredentials,
+  saveProjectConfig,
+  setThreadResolved,
+  sha256,
+  snapshotRelativePath,
+  snapshotTimestamp,
+  threadMessageId,
+  threadMessages,
+  uniqueChangeIds,
+  updateReceipt,
+  uploadFile,
+  validateSession,
+  workspaceWritePath
+} from "./chunk-TWIDV42A.js";
 
 // src/commands/pull.ts
-import { writeFileSync as writeFileSync4, mkdirSync as mkdirSync4 } from "fs";
-import { join as join4 } from "path";
-
-// src/config.ts
-import "dotenv/config";
-
-// src/lib/credentials.ts
-import { readFileSync, writeFileSync, mkdirSync, chmodSync } from "fs";
-import { homedir } from "os";
+import { writeFileSync, mkdirSync } from "fs";
 import { join } from "path";
-function configDir() {
-  return process.env.OVERLEAF_REVIEW_CONFIG_DIR ?? join(homedir(), ".config", "overleaf-review");
-}
-function credentialsPath() {
-  return join(configDir(), "credentials.json");
-}
-function loadCredentials() {
-  try {
-    return JSON.parse(readFileSync(credentialsPath(), "utf8"));
-  } catch {
-    return {};
-  }
-}
-function saveCredentials(creds) {
-  mkdirSync(configDir(), { recursive: true });
-  const path = credentialsPath();
-  writeFileSync(path, JSON.stringify({ ...creds, savedAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2) + "\n");
-  chmodSync(path, 384);
-  return path;
-}
-
-// src/lib/project-config.ts
-import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, renameSync, unlinkSync } from "fs";
-import { join as join2 } from "path";
-var REPO_CONFIG_PATH = join2(".overleaf", "config.json");
-function loadProjectConfig() {
-  try {
-    return JSON.parse(readFileSync2(REPO_CONFIG_PATH, "utf8"));
-  } catch {
-    return {};
-  }
-}
-function saveProjectConfig(cfg) {
-  mkdirSync2(".overleaf", { recursive: true });
-  const temp = `${REPO_CONFIG_PATH}.tmp-${process.pid}-${Date.now()}`;
-  try {
-    writeFileSync2(temp, JSON.stringify(cfg, null, 2) + "\n", { mode: 384 });
-    renameSync(temp, REPO_CONFIG_PATH);
-  } catch (error) {
-    try {
-      unlinkSync(temp);
-    } catch {
-    }
-    throw error;
-  }
-  return REPO_CONFIG_PATH;
-}
-
-// src/config.ts
-function resolveBaseUrl() {
-  return process.env.OVERLEAF_BASE_URL ?? loadProjectConfig().baseUrl ?? loadCredentials().baseUrl ?? "https://www.overleaf.com";
-}
-function resolveSession2() {
-  const value = process.env.OVERLEAF_SESSION2 || loadCredentials().session2;
-  if (!value) {
-    throw new Error("Not authenticated \u2014 run `overleaf-review login` (or set OVERLEAF_SESSION2).");
-  }
-  return value;
-}
-function resolveProjectId() {
-  const value = process.env.OVERLEAF_PROJECT_ID || loadProjectConfig().projectId;
-  if (!value) {
-    throw new Error(
-      "No project linked \u2014 run `overleaf-review link --project <id>` (or set OVERLEAF_PROJECT_ID)."
-    );
-  }
-  return value;
-}
-var config = {
-  get baseUrl() {
-    return resolveBaseUrl();
-  },
-  get session2() {
-    return resolveSession2();
-  },
-  get projectId() {
-    return resolveProjectId();
-  },
-  /** Cookie header value used for both HTTP and the websocket handshake. */
-  get cookie() {
-    return `overleaf_session2=${this.session2}`;
-  }
-};
-
-// src/overleaf-socket.ts
-import WebSocket from "ws";
-function utf8Decode(binary) {
-  return Buffer.from(binary, "latin1").toString("utf8");
-}
-var OverleafSocket = class {
-  constructor(baseUrl, cookie, opts = {}) {
-    this.baseUrl = baseUrl;
-    this.debug = opts.debug ?? true;
-    for (const part of cookie.split(";")) {
-      const eq = part.indexOf("=");
-      if (eq > 0) this.cookies.set(part.slice(0, eq).trim(), part.slice(eq + 1).trim());
-    }
-  }
-  baseUrl;
-  ws;
-  ackId = 1;
-  pendingAcks = /* @__PURE__ */ new Map();
-  handlers = /* @__PURE__ */ new Map();
-  heartbeat;
-  debug;
-  cookies = /* @__PURE__ */ new Map();
-  /** Browser-like headers — Overleaf's proxy can 502 non-browser upgrades. */
-  get browserHeaders() {
-    return {
-      Cookie: this.cookieHeader,
-      Origin: this.baseUrl,
-      "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36"
-    };
-  }
-  get cookieHeader() {
-    return [...this.cookies].map(([k, v]) => `${k}=${v}`).join("; ");
-  }
-  /** Merge Set-Cookie values — notably the GCLB load-balancer affinity cookie. */
-  absorbCookies(setCookies) {
-    for (const sc of setCookies) {
-      const pair = sc.split(";", 1)[0];
-      const eq = pair.indexOf("=");
-      if (eq > 0) this.cookies.set(pair.slice(0, eq).trim(), pair.slice(eq + 1).trim());
-    }
-  }
-  /** Subscribe to a server-pushed event (e.g. otUpdateApplied). */
-  on(event, handler) {
-    const list = this.handlers.get(event) ?? [];
-    list.push(handler);
-    this.handlers.set(event, list);
-    return () => this.off(event, handler);
-  }
-  /** Remove a previously registered server-pushed event handler. */
-  off(event, handler) {
-    const list = this.handlers.get(event);
-    if (!list) return;
-    const next = list.filter((candidate) => candidate !== handler);
-    if (next.length) this.handlers.set(event, next);
-    else this.handlers.delete(event);
-  }
-  async connect(projectId) {
-    const handshakeUrl = `${this.baseUrl}/socket.io/1/?projectId=${projectId}&t=${Date.now()}`;
-    const res = await fetch(handshakeUrl, { headers: this.browserHeaders });
-    const setCookies = res.headers.getSetCookie?.() ?? [];
-    this.absorbCookies(setCookies);
-    if (this.debug) console.log(`[socket] cookies now: ${[...this.cookies.keys()].join(", ")}`);
-    if (!res.ok) {
-      throw new Error(
-        `socket.io handshake failed: ${res.status} ${res.statusText}. Check the session cookie and that the account is logged in.`
-      );
-    }
-    const body = await res.text();
-    const [sid, hbTimeout, , transports] = body.split(":");
-    if (this.debug) console.log(`[socket] handshake ok: ${body}`);
-    const wsUrl = `${this.baseUrl.replace(/^http/, "ws")}/socket.io/1/websocket/${sid}`;
-    if (this.debug) console.log(`[socket] transports=${transports}; ws=${wsUrl}`);
-    this.ws = new WebSocket(wsUrl, { headers: this.browserHeaders });
-    await new Promise((resolve3, reject2) => {
-      this.ws.once("open", () => resolve3());
-      this.ws.once("error", reject2);
-      this.ws.once("unexpected-response", (_req, response) => {
-        let errBody = "";
-        response.on("data", (chunk) => errBody += chunk.toString());
-        response.on(
-          "end",
-          () => reject2(
-            new Error(
-              `ws upgrade rejected: ${response.statusCode} ${response.statusMessage}
-  headers: ${JSON.stringify(response.headers)}
-  body: ${errBody.slice(0, 800)}`
-            )
-          )
-        );
-      });
-    });
-    this.ws.on("message", (data) => this.onFrame(utf8Decode(data.toString())));
-    const intervalMs = (Number(hbTimeout) || 30) * 800;
-    this.heartbeat = setInterval(() => this.send("2::"), intervalMs);
-    if (this.debug) console.log("[socket] websocket open");
-  }
-  /** Emit an event and resolve with the server's ack payload (array of args). */
-  emit(name, args, timeoutMs = 15e3) {
-    const id = this.ackId++;
-    return new Promise((resolve3, reject2) => {
-      const timer = setTimeout(() => {
-        this.pendingAcks.delete(id);
-        reject2(new Error(`emit('${name}') timed out after ${timeoutMs}ms with no ack`));
-      }, timeoutMs);
-      this.pendingAcks.set(id, (payload) => {
-        clearTimeout(timer);
-        resolve3(payload);
-      });
-      this.send(`5:${id}+::${JSON.stringify({ name, args })}`);
-    });
-  }
-  onFrame(frame) {
-    if (this.debug) console.log("[socket] <-", frame.slice(0, 200));
-    const type = frame[0];
-    const c1 = frame.indexOf(":");
-    const c2 = frame.indexOf(":", c1 + 1);
-    const c3 = frame.indexOf(":", c2 + 1);
-    const data = c3 === -1 ? "" : frame.slice(c3 + 1);
-    switch (type) {
-      case "2":
-        this.send("2::");
-        break;
-      case "5": {
-        try {
-          const { name, args } = JSON.parse(data);
-          for (const h of this.handlers.get(name) ?? []) h(args);
-        } catch {
-        }
-        break;
-      }
-      case "6": {
-        const plus = data.indexOf("+");
-        const ackId = Number(plus === -1 ? data : data.slice(0, plus));
-        const payload = plus === -1 ? [] : JSON.parse(data.slice(plus + 1));
-        this.pendingAcks.get(ackId)?.(payload);
-        this.pendingAcks.delete(ackId);
-        break;
-      }
-    }
-  }
-  send(frame) {
-    if (this.debug && !frame.startsWith("2")) console.log("[socket] ->", frame.slice(0, 200));
-    this.ws.send(frame);
-  }
-  close() {
-    if (this.heartbeat) clearInterval(this.heartbeat);
-    this.ws?.close();
-  }
-};
-
-// src/lib/session.ts
-function collectDocs(rootFolder) {
-  const out = [];
-  const walk = (folders, prefix) => {
-    for (const f of folders ?? []) {
-      const dir = f.name && f.name !== "rootFolder" ? prefix ? `${prefix}/${f.name}` : f.name : prefix;
-      for (const d of f.docs ?? []) {
-        out.push({ _id: d._id, name: d.name, path: dir ? `${dir}/${d.name}` : d.name });
-      }
-      walk(f.folders ?? [], dir);
-    }
-  };
-  walk(rootFolder ?? [], "");
-  return out;
-}
-async function openProject(opts = {}) {
-  const socket = new OverleafSocket(config.baseUrl, config.cookie, { debug: opts.debug ?? false });
-  const pushed = new Promise((resolve3) => socket.on("joinProjectResponse", resolve3));
-  await socket.connect(config.projectId);
-  const first = await Promise.race([
-    pushed,
-    new Promise((r) => setTimeout(() => r(null), 6e3))
-  ]);
-  let publicId = "";
-  let project;
-  if (first) {
-    publicId = first[0]?.publicId ?? "";
-    project = first[0]?.project;
-  } else {
-    const r = await socket.emit("joinProject", [{ project_id: config.projectId }]);
-    project = r[1];
-  }
-  return { socket, publicId, project, docs: collectDocs(project?.rootFolder) };
-}
-async function joinDoc(socket, docId) {
-  const res = await socket.emit("joinDoc", [docId, { encodeRanges: true }]);
-  const [err, lines, version, , ranges] = res;
-  if (err) throw new Error(`joinDoc error: ${JSON.stringify(err)}`);
-  return { version, lines: lines ?? [], ranges: ranges ?? {} };
-}
-async function applyOtUpdateAndWait(socket, docId, update, timeoutMs = 3e4) {
-  let timer;
-  let stopApplied = () => {
-  };
-  let stopError = () => {
-  };
-  const applied = new Promise((resolve3, reject2) => {
-    stopApplied = socket.on("otUpdateApplied", (args) => {
-      const event = args[0];
-      if (event?.doc === docId && Number.isSafeInteger(event.v) && event.v >= update.v && !Object.prototype.hasOwnProperty.call(event, "op")) {
-        resolve3();
-      }
-    });
-    stopError = socket.on("otUpdateError", (args) => {
-      const metadata = args[1];
-      if (metadata?.doc_id && metadata.doc_id !== docId) return;
-      reject2(new Error(`Overleaf failed to apply the OT update: ${JSON.stringify(args)}`));
-    });
-    timer = setTimeout(
-      () => reject2(new Error(`OT update for ${docId} was queued but not confirmed within ${timeoutMs}ms`)),
-      timeoutMs
-    );
-  });
-  void applied.catch(() => {
-  });
-  try {
-    const ack = await socket.emit("applyOtUpdate", [docId, update], timeoutMs);
-    if (ack?.[0]) throw new Error(`Overleaf rejected the OT update: ${JSON.stringify(ack[0])}`);
-    await applied;
-  } finally {
-    if (timer) clearTimeout(timer);
-    stopApplied();
-    stopError();
-  }
-}
-
-// src/lib/rest.ts
-var UA = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36";
-function headers(extra = {}) {
-  return { Cookie: config.cookie, "User-Agent": UA, Origin: config.baseUrl, ...extra };
-}
-async function getCsrfToken() {
-  const res = await fetch(`${config.baseUrl}/project/${config.projectId}`, { headers: headers() });
-  const html = await res.text();
-  const m = html.match(/<meta\s+name="ol-csrfToken"\s+content="([^"]+)"/) ?? html.match(/"csrfToken"\s*:\s*"([^"]+)"/) ?? html.match(/csrfToken\s*[:=]\s*["']([^"']+)["']/);
-  if (!m) {
-    throw new Error(
-      `CSRF token not found (HTTP ${res.status}). If this is a login page, the session cookie is invalid/expired.`
-    );
-  }
-  return m[1];
-}
-async function getThreads() {
-  const res = await fetch(`${config.baseUrl}/project/${config.projectId}/threads`, {
-    headers: headers()
-  });
-  if (!res.ok) throw new Error(`getThreads ${res.status}: ${(await res.text()).slice(0, 200)}`);
-  return res.json();
-}
-var RestRequestError = class extends Error {
-  constructor(message, status, responseBody) {
-    super(message);
-    this.status = status;
-    this.responseBody = responseBody;
-    this.name = "RestRequestError";
-  }
-  status;
-  responseBody;
-};
-function threadMessages(thread) {
-  if (!thread || typeof thread !== "object") return [];
-  const messages = thread.messages;
-  return Array.isArray(messages) ? messages.filter((message) => Boolean(message && typeof message === "object")) : [];
-}
-function threadMessageId(message) {
-  const value = message?.id ?? message?._id;
-  return typeof value === "string" && value ? value : void 0;
-}
-function timestampMs(message) {
-  const raw = message.timestamp ?? message.createdAt ?? message.created_at;
-  if (typeof raw === "number" && Number.isFinite(raw)) {
-    return raw < 1e11 ? raw * 1e3 : raw;
-  }
-  if (typeof raw === "string") {
-    const numeric = Number(raw);
-    if (Number.isFinite(numeric) && raw.trim()) {
-      return numeric < 1e11 ? numeric * 1e3 : numeric;
-    }
-    const parsed = Date.parse(raw);
-    if (Number.isFinite(parsed)) return parsed;
-  }
-  return void 0;
-}
-function findRecentIdenticalMessage(thread, content, nowMs = Date.now(), windowMs = 5 * 60 * 1e3) {
-  const earliest = nowMs - Math.max(0, windowMs);
-  return threadMessages(thread).filter((message) => {
-    if (message.content !== content) return false;
-    const timestamp = timestampMs(message);
-    return timestamp !== void 0 && timestamp >= earliest && timestamp <= nowMs + 6e4;
-  }).sort((a, b) => (timestampMs(b) ?? 0) - (timestampMs(a) ?? 0))[0];
-}
-function findNewIdenticalMessage(beforeThread, afterThread, content, returnedMessageId) {
-  const after = threadMessages(afterThread);
-  if (returnedMessageId) {
-    return after.find(
-      (message) => threadMessageId(message) === returnedMessageId && message.content === content
-    );
-  }
-  const beforeIds = new Set(
-    threadMessages(beforeThread).map(threadMessageId).filter((id) => Boolean(id))
-  );
-  const candidates = [...after].reverse().filter((message) => {
-    if (message.content !== content) return false;
-    const id = threadMessageId(message);
-    return Boolean(id && !beforeIds.has(id));
-  });
-  return candidates.length === 1 ? candidates[0] : void 0;
-}
-function extractPostedMessageId(value) {
-  if (!value || typeof value !== "object") return void 0;
-  const object = value;
-  for (const key of ["message_id", "messageId"]) {
-    if (typeof object[key] === "string" && object[key]) return object[key];
-  }
-  for (const key of ["message", "data"]) {
-    const nested = object[key];
-    if (nested && typeof nested === "object") {
-      const nestedId = threadMessageId(nested) ?? extractPostedMessageId(nested);
-      if (nestedId) return nestedId;
-    }
-  }
-  return threadMessageId(object);
-}
-async function observePostedThreadMessage(threadId, beforeThread, content, returnedMessageId, options = {}) {
-  const timeoutMs = Math.max(0, options.timeoutMs ?? 5e3);
-  const intervalMs = Math.max(10, options.intervalMs ?? 250);
-  const deadline = Date.now() + timeoutMs;
-  let attempts = 0;
-  let lastThread;
-  let lastError;
-  do {
-    attempts += 1;
-    try {
-      lastThread = (await getThreads())[threadId];
-      const message = findNewIdenticalMessage(
-        beforeThread,
-        lastThread,
-        content,
-        returnedMessageId
-      );
-      if (message) return { message, thread: lastThread, attempts };
-    } catch (error) {
-      lastError = error instanceof Error ? error.message : String(error);
-    }
-    if (Date.now() >= deadline) break;
-    await new Promise((resolve3) => setTimeout(resolve3, Math.min(intervalMs, deadline - Date.now())));
-  } while (Date.now() <= deadline);
-  return {
-    thread: lastThread,
-    attempts,
-    ...lastError ? { lastError } : {}
-  };
-}
-async function postThreadMessageDetailed(threadId, content, csrf) {
-  const res = await fetch(
-    `${config.baseUrl}/project/${config.projectId}/thread/${threadId}/messages`,
-    {
-      method: "POST",
-      headers: headers({ "Content-Type": "application/json", "X-CSRF-Token": csrf }),
-      body: JSON.stringify({ content })
-    }
-  );
-  const rawBody = await res.text();
-  if (!res.ok) {
-    throw new RestRequestError(
-      `postThreadMessage ${res.status}: ${rawBody.slice(0, 300)}`,
-      res.status,
-      rawBody.slice(0, 1e3)
-    );
-  }
-  let responseBody;
-  if (rawBody) {
-    try {
-      responseBody = JSON.parse(rawBody);
-    } catch {
-      responseBody = rawBody.slice(0, 1e3);
-    }
-  }
-  return {
-    status: res.status,
-    messageId: extractPostedMessageId(responseBody),
-    ...responseBody === void 0 ? {} : { responseBody }
-  };
-}
-async function setThreadResolved(docId, threadId, reopen, csrf) {
-  const action = reopen ? "reopen" : "resolve";
-  const res = await fetch(
-    `${config.baseUrl}/project/${config.projectId}/doc/${docId}/thread/${threadId}/${action}`,
-    { method: "POST", headers: headers({ "X-CSRF-Token": csrf }) }
-  );
-  if (!res.ok) {
-    throw new Error(`${action} thread ${res.status}: ${(await res.text()).slice(0, 200)}`);
-  }
-  return res.status;
-}
-async function acceptChanges(docId, changeIds, csrf) {
-  const res = await fetch(
-    `${config.baseUrl}/project/${config.projectId}/doc/${docId}/changes/accept`,
-    {
-      method: "POST",
-      headers: headers({ "X-CSRF-Token": csrf, "Content-Type": "application/json" }),
-      body: JSON.stringify({ change_ids: changeIds })
-    }
-  );
-  if (!res.ok) throw new Error(`acceptChanges ${res.status}: ${(await res.text()).slice(0, 200)}`);
-  return res.status;
-}
-async function uploadFile(folderId, name, bytes, csrf) {
-  const form = new FormData();
-  form.append("qqfile", new Blob([new Uint8Array(bytes)]), name);
-  form.append("name", name);
-  form.append("relativePath", "null");
-  const res = await fetch(
-    `${config.baseUrl}/project/${config.projectId}/upload?folder_id=${folderId}`,
-    // Deliberately no Content-Type — fetch sets the multipart boundary itself.
-    { method: "POST", headers: headers({ "X-CSRF-Token": csrf }), body: form }
-  );
-  if (!res.ok) throw new Error(`upload ${res.status}: ${(await res.text()).slice(0, 200)}`);
-  return res.json();
-}
-async function deleteMessage(threadId, messageId, csrf) {
-  const res = await fetch(
-    `${config.baseUrl}/project/${config.projectId}/thread/${threadId}/messages/${messageId}`,
-    { method: "DELETE", headers: headers({ "X-CSRF-Token": csrf }) }
-  );
-  if (!res.ok) throw new Error(`deleteMessage ${res.status}: ${(await res.text()).slice(0, 200)}`);
-  return res.status;
-}
-async function deleteThread(docId, threadId, csrf) {
-  const res = await fetch(
-    `${config.baseUrl}/project/${config.projectId}/doc/${docId}/thread/${threadId}`,
-    { method: "DELETE", headers: headers({ "X-CSRF-Token": csrf }) }
-  );
-  if (!res.ok) throw new Error(`deleteThread ${res.status}: ${(await res.text()).slice(0, 200)}`);
-  return res.status;
-}
-async function validateSession(baseUrl, session2) {
-  const res = await fetch(`${baseUrl}/project`, {
-    headers: { Cookie: `overleaf_session2=${session2}`, "User-Agent": UA },
-    redirect: "follow"
-  });
-  const html = await res.text();
-  if (!res.ok) throw new Error(`Session validation failed (HTTP ${res.status}); log in again or check access.`);
-  const looksLikeLogin = res.url.includes("/login") || /name="ol-page"\s+content="login"/.test(html) || html.includes('id="loginForm"');
-  if (looksLikeLogin) {
-    throw new Error("Session cookie is invalid or expired (got the login page).");
-  }
-  const m = html.match(/name="ol-usersEmail"\s+content="([^"]+)"/) ?? html.match(/"email":"([^"@]+@[^"]+)"/);
-  return m ? m[1] : "your Overleaf account";
-}
-function accountIdFromSettings(html) {
-  const tag = html.match(/<meta\b[^>]*\bname=["']ol-user["'][^>]*>/i)?.[0];
-  const encoded = tag?.match(/\bcontent=(?:"([^"]*)"|'([^']*)')/i);
-  if (!encoded) throw new Error("Authenticated account ID not found; refusing author-sensitive mutation.");
-  const json = (encoded[1] ?? encoded[2]).replace(/&(?:quot|apos|amp|lt|gt|#\d+|#x[0-9a-f]+);/gi, (entity) => {
-    const named = { "&quot;": '"', "&apos;": "'", "&amp;": "&", "&lt;": "<", "&gt;": ">" };
-    if (named[entity.toLowerCase()]) return named[entity.toLowerCase()];
-    const hex = entity.toLowerCase().startsWith("&#x");
-    return String.fromCodePoint(parseInt(entity.slice(hex ? 3 : 2, -1), hex ? 16 : 10));
-  });
-  const user = JSON.parse(json);
-  const id = user?.id ?? user?._id;
-  if (user?.id && user?._id && user.id !== user._id) throw new Error("Conflicting authenticated account IDs.");
-  if (typeof id !== "string" || !/^[0-9a-f]{24}$/i.test(id)) {
-    throw new Error("Invalid authenticated account ID; refusing author-sensitive mutation.");
-  }
-  return id;
-}
-async function getAuthenticatedUserId() {
-  const res = await fetch(`${config.baseUrl}/user/settings`, {
-    headers: headers(),
-    redirect: "error",
-    signal: AbortSignal.timeout(15e3)
-  });
-  if (!res.ok) throw new Error(`Account verification failed (HTTP ${res.status}); refresh login.`);
-  return accountIdFromSettings(await res.text());
-}
 
 // src/lib/anchors.ts
 function offsetToLine(lines, offset) {
@@ -593,156 +65,6 @@ function lineContext(lines, line, radius = 1) {
   return out.join("\n");
 }
 
-// src/lib/submission-lock.ts
-import { createHash, randomUUID } from "crypto";
-import {
-  closeSync,
-  existsSync as existsSync2,
-  fsyncSync,
-  mkdirSync as mkdirSync3,
-  openSync,
-  readFileSync as readFileSync3,
-  realpathSync as realpathSync2,
-  unlinkSync as unlinkSync2,
-  writeFileSync as writeFileSync3
-} from "fs";
-import { tmpdir } from "os";
-import { dirname as dirname2, join as join3 } from "path";
-
-// src/lib/workspace-path.ts
-import { existsSync, realpathSync } from "fs";
-import { dirname, isAbsolute, relative, resolve, sep } from "path";
-function isOutside(root, candidate) {
-  const rel = relative(root, candidate);
-  return rel === ".." || rel.startsWith(`..${sep}`) || isAbsolute(rel);
-}
-function workspaceRelativePath(input, root = process.cwd()) {
-  if (typeof input !== "string" || !input.length) throw new Error("workspace path is empty");
-  if (isAbsolute(input) || /^[\\/]/.test(input) || /^[a-zA-Z]:[\\/]/.test(input)) {
-    throw new Error(`Absolute paths are not allowed: ${input}`);
-  }
-  const portable = input.replace(/\\/g, "/");
-  if (portable.split("/").includes("..")) {
-    throw new Error(`Parent path traversal is not allowed: ${input}`);
-  }
-  const target = resolve(root, ...portable.split("/"));
-  const absoluteRoot = resolve(root);
-  if (isOutside(absoluteRoot, target) || target === absoluteRoot) {
-    throw new Error(`Path must identify a file inside the working tree: ${input}`);
-  }
-  return relative(absoluteRoot, target).split(sep).join("/");
-}
-function workspaceReadPath(input, root = process.cwd()) {
-  const rel = workspaceRelativePath(input, root);
-  const realRoot = realpathSync(root);
-  const lexicalTarget = resolve(root, ...rel.split("/"));
-  const realTarget = realpathSync(lexicalTarget);
-  if (isOutside(realRoot, realTarget) || realTarget === realRoot) {
-    throw new Error(`Path resolves outside the working tree: ${input}`);
-  }
-  return lexicalTarget;
-}
-function workspaceWritePath(input, root = process.cwd()) {
-  const rel = workspaceRelativePath(input, root);
-  const lexicalTarget = resolve(root, ...rel.split("/"));
-  const realRoot = realpathSync(root);
-  if (existsSync(lexicalTarget)) {
-    const target = realpathSync(lexicalTarget);
-    if (isOutside(realRoot, target) || target === realRoot) {
-      throw new Error(`Path resolves outside the working tree: ${input}`);
-    }
-    return lexicalTarget;
-  }
-  let ancestor = dirname(lexicalTarget);
-  while (!existsSync(ancestor)) {
-    const parent = dirname(ancestor);
-    if (parent === ancestor) throw new Error(`Cannot resolve a safe parent for ${input}`);
-    ancestor = parent;
-  }
-  const realAncestor = realpathSync(ancestor);
-  if (isOutside(realRoot, realAncestor)) {
-    throw new Error(`Path has an ancestor outside the working tree: ${input}`);
-  }
-  return lexicalTarget;
-}
-
-// src/lib/submission-lock.ts
-var MUTATION_LOCK_PATH = join3(".overleaf", "mutation.lock");
-function mutationLockPath(root = process.cwd()) {
-  const key = createHash("sha256").update(realpathSync2(root), "utf8").digest("hex").slice(0, 32);
-  return join3(tmpdir(), `overleaf-review-${key}.lock`);
-}
-function acquireMutationLock(projectId, options = {}) {
-  const root = options.root ?? process.cwd();
-  const path = options.path ? workspaceWritePath(options.path, root) : mutationLockPath(root);
-  const displayPath = options.path ?? path;
-  mkdirSync3(dirname2(path), { recursive: true });
-  const token = randomUUID();
-  let fd;
-  try {
-    fd = openSync(path, "wx", 384);
-  } catch (error) {
-    if (error.code !== "EEXIST") throw error;
-    let owner = "";
-    try {
-      const parsed = JSON.parse(readFileSync3(path, "utf8"));
-      const details = [
-        typeof parsed.pid === "number" ? `pid ${parsed.pid}` : void 0,
-        typeof parsed.startedAt === "string" ? `since ${parsed.startedAt}` : void 0,
-        typeof parsed.projectId === "string" ? `project ${parsed.projectId}` : void 0
-      ].filter(Boolean);
-      if (details.length) owner = ` (${details.join(", ")})`;
-    } catch {
-    }
-    throw new Error(
-      `Another overleaf-review mutation holds ${displayPath}${owner}. Wait for it to finish. If its process crashed, inspect any relevant receipt and live project before removing the lock manually.`,
-      { cause: error }
-    );
-  }
-  try {
-    writeFileSync3(
-      fd,
-      `${JSON.stringify(
-        {
-          token,
-          pid: process.pid,
-          projectId,
-          startedAt: (/* @__PURE__ */ new Date()).toISOString()
-        },
-        null,
-        2
-      )}
-`,
-      "utf8"
-    );
-    fsyncSync(fd);
-  } catch (error) {
-    closeSync(fd);
-    if (existsSync2(path)) unlinkSync2(path);
-    throw error;
-  }
-  closeSync(fd);
-  let released = false;
-  return {
-    path,
-    token,
-    release() {
-      if (released) return;
-      try {
-        const current = JSON.parse(readFileSync3(path, "utf8"));
-        if (current.token === token) unlinkSync2(path);
-        released = true;
-      } catch (error) {
-        if (error.code === "ENOENT") {
-          released = true;
-          return;
-        }
-        throw error;
-      }
-    }
-  };
-}
-
 // src/commands/pull.ts
 function buildMemberMap(project) {
   const map = {};
@@ -752,1665 +74,66 @@ function buildMemberMap(project) {
   };
   add(project?.owner);
   for (const m of project?.members ?? []) add(m);
-  return map;
-}
-async function pull(outDir = ".overleaf", options = {}) {
-  let mutationLock;
-  let opened;
-  try {
-    if (options.acquireLock !== false) mutationLock = acquireMutationLock(config.projectId);
-    opened = await openProject();
-    const { socket, project, docs } = opened;
-    const members = buildMemberMap(project);
-    const threads = await getThreads();
-    const comments = [];
-    const changes = [];
-    for (const doc of docs) {
-      const state = await joinDoc(socket, doc._id);
-      for (const c of state.ranges.comments ?? []) {
-        const line = offsetToLine(state.lines, c.op.p);
-        const thread = threads[c.op.t] ?? {};
-        comments.push({
-          doc: doc.path,
-          threadId: c.op.t,
-          anchor: c.op.c,
-          line: line + 1,
-          context: lineContext(state.lines, line),
-          resolved: Boolean(thread.resolved),
-          messages: (thread.messages ?? []).map((m) => ({
-            id: m.id,
-            author: m.user?.first_name ?? members[m.user_id] ?? m.user_id,
-            email: m.user?.email,
-            content: m.content,
-            timestamp: m.timestamp
-          }))
-        });
-      }
-      for (const ch of state.ranges.changes ?? []) {
-        const isInsert = typeof ch.op.i === "string";
-        const line = offsetToLine(state.lines, ch.op.p);
-        changes.push({
-          doc: doc.path,
-          id: ch.id,
-          type: isInsert ? "insert" : "delete",
-          text: isInsert ? ch.op.i : ch.op.d,
-          line: line + 1,
-          context: lineContext(state.lines, line),
-          author: members[ch.metadata?.user_id] ?? ch.metadata?.user_id ?? "unknown",
-          ts: ch.metadata?.ts
-        });
-      }
-    }
-    const data = {
-      project: project?.name ?? "(unknown)",
-      projectId: config.projectId,
-      pulledAt: (/* @__PURE__ */ new Date()).toISOString(),
-      comments,
-      changes
-    };
-    mkdirSync4(outDir, { recursive: true });
-    writeFileSync4(join4(outDir, "reviews.json"), JSON.stringify(data, null, 2) + "\n");
-    writeFileSync4(join4(outDir, "reviews.md"), renderMarkdown(data));
-    return data;
-  } finally {
-    try {
-      opened?.socket.close();
-    } finally {
-      mutationLock?.release();
-    }
-  }
-}
-function renderMarkdown(d) {
-  const L = [];
-  L.push(`# Overleaf review \u2014 ${d.project}`, "");
-  L.push(`_Pulled ${d.pulledAt} from project \`${d.projectId}\`._`, "");
-  L.push(`**${d.comments.length}** comment(s), **${d.changes.length}** tracked change(s).`, "");
-  L.push(
-    "_Act on these:_ `reply --thread <id> --message <text>` \xB7 `resolve --thread <id>` \xB7 `delete-comment --thread <id>` \xB7 `delete-message --message-id <id>` \xB7 `accept --change <id>` \xB7 `reject --change <id>`.",
-    ""
-  );
-  const byDoc = (items) => {
-    const m = /* @__PURE__ */ new Map();
-    for (const it of items) (m.get(it.doc) ?? m.set(it.doc, []).get(it.doc)).push(it);
-    return m;
-  };
-  if (d.comments.length) {
-    L.push("## Comments", "");
-    for (const [doc, items] of byDoc(d.comments)) {
-      L.push(`### ${doc}`, "");
-      for (const c of items) {
-        const flag = c.resolved ? " \u2014 \u2705 resolved" : "";
-        L.push(`#### \u{1F4AC} \u201C${c.anchor}\u201D \xB7 line ${c.line}${flag}`);
-        L.push(`\`thread ${c.threadId}\``);
-        L.push("```", c.context, "```");
-        for (const m of c.messages) {
-          L.push(`- **${m.author}**: ${m.content}  \`msg ${m.id}\``);
-        }
-        if (!c.messages.length) L.push("- _(no message text)_");
-        L.push("");
-      }
-    }
-  }
-  if (d.changes.length) {
-    L.push("## Tracked changes", "");
-    for (const [doc, items] of byDoc(d.changes)) {
-      L.push(`### ${doc}`, "");
-      for (const ch of items) {
-        const verb = ch.type === "insert" ? "inserted" : "deleted";
-        L.push(
-          `- **${verb}** at line ${ch.line} by ${ch.author} \xB7 \`change ${ch.id}\`: \`${ch.text.replace(/\n/g, "\u23CE")}\``
-        );
-        L.push("  ```", ch.context.replace(/^/gm, "  "), "  ```");
-      }
-      L.push("");
-    }
-  }
-  return L.join("\n");
-}
-
-// src/commands/push.ts
-import {
-  mkdirSync as mkdirSync7,
-  readFileSync as readFileSync6,
-  readdirSync as readdirSync2,
-  renameSync as renameSync4,
-  statSync,
-  unlinkSync as unlinkSync5,
-  writeFileSync as writeFileSync7
-} from "fs";
-import { createHash as createHash3 } from "crypto";
-import { dirname as dirname5, relative as relative2, resolve as resolvePath, sep as sep2 } from "path";
-
-// src/lib/review-edits.ts
-import { diffWordsWithSpace } from "diff";
-
-// src/lib/three-way.ts
-import { diffChars } from "diff";
-function textEdits(base, target) {
-  const edits = [];
-  let basePos = 0;
-  let pending;
-  const flush = () => {
-    if (!pending) return;
-    if (pending.start !== pending.end || pending.text.length) edits.push(pending);
-    pending = void 0;
-  };
-  for (const part of diffChars(base, target)) {
-    if (!part.added && !part.removed) {
-      flush();
-      basePos += part.value.length;
-      continue;
-    }
-    pending ??= { start: basePos, end: basePos, text: "" };
-    if (part.removed) {
-      pending.end += part.value.length;
-      basePos += part.value.length;
-    } else {
-      pending.text += part.value;
-    }
-  }
-  flush();
-  return edits;
-}
-function sameEdit(a, b) {
-  return a.start === b.start && a.end === b.end && a.text === b.text;
-}
-function reverseCodePoints(text) {
-  return Array.from(text).reverse().join("");
-}
-function ambiguousEditAnchors(base, target) {
-  const forward = textEdits(base, target);
-  const reverse = textEdits(reverseCodePoints(base), reverseCodePoints(target)).map((edit) => ({
-    start: base.length - edit.end,
-    end: base.length - edit.start,
-    text: reverseCodePoints(edit.text)
-  })).sort((a, b) => a.start - b.start || a.end - b.end);
-  const ambiguities = [];
-  const count = Math.max(forward.length, reverse.length);
-  for (let index = 0; index < count; index++) {
-    const forwardEdit = forward[index] ?? reverse[index];
-    const reverseEdit = reverse[index] ?? forward[index];
-    if (sameEdit(forwardEdit, reverseEdit)) continue;
-    ambiguities.push({
-      forward: forwardEdit,
-      reverse: reverseEdit,
-      envelopeStart: Math.min(forwardEdit.start, reverseEdit.start),
-      envelopeEnd: Math.max(
-        forwardEdit.start,
-        forwardEdit.end,
-        reverseEdit.start,
-        reverseEdit.end
-      )
-    });
-  }
-  return ambiguities;
-}
-function editTouchesEnvelope(edit, start, end) {
-  if (edit.start === edit.end) return edit.start >= start && edit.start <= end;
-  return edit.start <= end && edit.end >= start;
-}
-function editsConflict(a, b) {
-  const aInsert = a.start === a.end;
-  const bInsert = b.start === b.end;
-  if (aInsert && bInsert) return a.start === b.start;
-  if (aInsert) return a.start > b.start && a.start < b.end;
-  if (bInsert) return b.start > a.start && b.start < a.end;
-  return a.start < b.end && b.start < a.end;
-}
-function mapBasePosition(position, liveEdits, includeInsertionAtPosition) {
-  let mapped = position;
-  for (const edit of liveEdits) {
-    if (edit.start === edit.end) {
-      if (edit.start < position || includeInsertionAtPosition && edit.start === position) {
-        mapped += edit.text.length;
-      }
-      continue;
-    }
-    if (edit.end <= position) mapped += edit.text.length - (edit.end - edit.start);
-  }
-  return mapped;
-}
-function applyEdits(source, edits) {
-  let result = source;
-  const ordered = edits.map((edit, index) => ({ edit, index })).sort(
-    (a, b) => b.edit.start - a.edit.start || b.edit.end - a.edit.end || b.index - a.index
-  );
-  for (const { edit } of ordered) {
-    result = result.slice(0, edit.start) + edit.text + result.slice(edit.end);
-  }
-  return result;
-}
-function threeWayMerge(base, local, live) {
-  const localEdits = textEdits(base, local);
-  const liveEdits = textEdits(base, live);
-  const ambiguousAnchors = ambiguousEditAnchors(base, local);
-  const conflicts = [];
-  const alreadyAppliedLocalEdits = [];
-  const toApply = [];
-  for (const localEdit of localEdits) {
-    if (liveEdits.some((liveEdit) => sameEdit(localEdit, liveEdit))) {
-      alreadyAppliedLocalEdits.push(localEdit);
-      continue;
-    }
-    const ambiguity = ambiguousAnchors.find((candidate) => sameEdit(candidate.forward, localEdit));
-    if (ambiguity) {
-      const touching = liveEdits.filter(
-        (liveEdit) => editTouchesEnvelope(liveEdit, ambiguity.envelopeStart, ambiguity.envelopeEnd)
-      );
-      if (touching.length) {
-        for (const liveEdit of touching) {
-          conflicts.push({ local: localEdit, live: liveEdit, reason: "ambiguous-local-anchor" });
-        }
-        continue;
-      }
-    }
-    const overlapping = liveEdits.filter((liveEdit) => editsConflict(localEdit, liveEdit));
-    if (overlapping.length) {
-      for (const liveEdit of overlapping) {
-        conflicts.push({ local: localEdit, live: liveEdit, reason: "overlapping-edits" });
-      }
-      continue;
-    }
-    if (localEdit.start === localEdit.end) {
-      const point = mapBasePosition(localEdit.start, liveEdits, false);
-      toApply.push({ start: point, end: point, text: localEdit.text });
-    } else {
-      const start = mapBasePosition(localEdit.start, liveEdits, true);
-      const end = mapBasePosition(localEdit.end, liveEdits, false);
-      toApply.push({ start, end, text: localEdit.text });
-    }
-  }
-  return {
-    text: conflicts.length ? void 0 : applyEdits(live, toApply),
-    localEdits,
-    liveEdits,
-    appliedLocalEdits: toApply,
-    alreadyAppliedLocalEdits,
-    conflicts
-  };
-}
-
-// src/lib/review-edits.ts
-var MAX_GAP_CHARS = 40;
-var MAX_GAP_WORDS = 3;
-var MAX_GROUP_CHARS = 320;
-var BOUNDARY = /[.!?;:](?:["'”’\)\]]*)\s|[.!?;:]$|\r?\n\s*\r?\n|[\\$%{}&]/u;
-function buildReviewEdits(source, target, options = {}) {
-  if (options.explicitEdits) {
-    const edits2 = validateExplicitEdits(source, options.explicitEdits);
-    if (applyTextEdits(source, edits2) !== target) throw new Error("Explicit blocks do not reconstruct the intended file.");
-    for (const edit of edits2) {
-      if (options.protectedSpans?.some((span) => edit.start <= span.end && span.start <= edit.end)) {
-        throw new Error("Explicit block touches a comment, pending suggestion, or concurrent edit; narrow the block or resolve the conflict first.");
-      }
-    }
-    return edits2;
-  }
-  const edits = [];
-  let sourcePos = 0;
-  let pending;
-  const flush = () => {
-    if (pending) edits.push(pending);
-    pending = void 0;
-  };
-  for (const part of diffWordsWithSpace(source, target)) {
-    if (!part.added && !part.removed) {
-      flush();
-      sourcePos += part.value.length;
-    } else {
-      pending ??= { start: sourcePos, end: sourcePos, text: "" };
-      if (part.removed) {
-        sourcePos += part.value.length;
-        pending.end = sourcePos;
-      } else {
-        pending.text += part.value;
-      }
-    }
-  }
-  flush();
-  if (options.group === false) return edits;
-  const groups = [];
-  for (const edit of edits) {
-    const previous = groups[groups.length - 1];
-    if (!previous) {
-      groups.push({ ...edit });
-      continue;
-    }
-    const gap = source.slice(previous.end, edit.start);
-    const protectedGap = options.protectedSpans?.some(
-      (span) => span.start === span.end ? span.start >= previous.end && span.start <= edit.start : span.start < edit.start && span.end > previous.end
-    );
-    const canGroup = !protectedGap && gap.length <= MAX_GAP_CHARS && (gap.match(/\S+/gu)?.length ?? 0) <= MAX_GAP_WORDS && !BOUNDARY.test(source.slice(previous.start, edit.start)) && !BOUNDARY.test(previous.text + gap) && edit.end - previous.start <= MAX_GROUP_CHARS && previous.text.length + gap.length + edit.text.length <= MAX_GROUP_CHARS;
-    if (canGroup) {
-      previous.end = edit.end;
-      previous.text += gap + edit.text;
-    } else {
-      groups.push({ ...edit });
-    }
-  }
-  return groups;
-}
-function validateExplicitEdits(source, value) {
-  if (!Array.isArray(value) || !value.length) throw new Error("Explicit blocks must be a nonempty array.");
-  let previousEnd = -1;
-  return value.map((edit) => {
-    if (!edit || !Number.isSafeInteger(edit.start) || !Number.isSafeInteger(edit.end) || edit.start < 0 || edit.end < edit.start || edit.end > source.length || typeof edit.text !== "string" || edit.start <= previousEnd || source.slice(edit.start, edit.end) === edit.text) {
-      throw new Error("Explicit blocks must be valid, ordered, separated replacements with a text change.");
-    }
-    previousEnd = edit.end;
-    return { start: edit.start, end: edit.end, text: edit.text };
-  });
-}
-function applyTextEdits(source, edits) {
-  for (const edit of [...edits].reverse()) {
-    source = source.slice(0, edit.start) + edit.text + source.slice(edit.end);
-  }
-  return source;
-}
-function parseReplacementManifest(base, value) {
-  const manifest = value;
-  if (!Array.isArray(manifest?.replacements) || !manifest.replacements.length) {
-    throw new Error("Replacement manifest requires a nonempty replacements array.");
-  }
-  const edits = manifest.replacements.map((block) => {
-    if (!block || typeof block.before !== "string" || !block.before.length || typeof block.after !== "string" || block.occurrence !== void 0 && (!Number.isSafeInteger(block.occurrence) || block.occurrence < 1)) {
-      throw new Error("Each replacement requires nonempty before, after text, and optionally a positive occurrence.");
-    }
-    const matches = [];
-    for (let p = base.indexOf(block.before); p !== -1; p = base.indexOf(block.before, p + 1)) matches.push(p);
-    if (!matches.length || matches.length > 1 && block.occurrence === void 0) {
-      throw new Error("Replacement before text is absent or ambiguous in the saved base; specify occurrence for repeated text.");
-    }
-    const start = matches[(block.occurrence ?? 1) - 1];
-    if (start === void 0) throw new Error("Replacement occurrence is absent from the saved base.");
-    return { start, end: start + block.before.length, text: block.after };
-  }).sort((a, b) => a.start - b.start);
-  return validateExplicitEdits(base, edits);
-}
-function bindExplicitEdits(base, local, live, edits, options) {
-  const checked = validateExplicitEdits(base, edits);
-  if (applyTextEdits(base, checked) !== local) {
-    throw new Error("Replacement manifest must describe every local change exactly.");
-  }
-  const changes = textEdits(base, live);
-  const mapped = checked.map((edit) => {
-    let offset = 0;
-    for (const change of changes) {
-      if (change.start <= edit.end && edit.start <= change.end) {
-        throw new Error("A concurrent edit touches an explicit replacement block; refresh and re-plan.");
-      }
-      if (change.end < edit.start) offset += change.text.length - (change.end - change.start);
-    }
-    return { ...edit, start: edit.start + offset, end: edit.end + offset };
-  });
-  return { ...options, explicitEdits: mapped };
-}
-function reviewGroupingOptions(base, live, ranges, direct = false) {
-  const protectedSpans = [];
-  for (const range of ranges.changes ?? []) {
-    if (typeof range.op?.p === "number") {
-      protectedSpans.push({ start: range.op.p, end: range.op.p + (range.op.i?.length ?? 0) });
-    }
-  }
-  for (const range of ranges.comments ?? []) {
-    if (typeof range.op?.p === "number") {
-      protectedSpans.push({ start: range.op.p, end: range.op.p + (range.op.c?.length ?? 0) });
-    }
-  }
-  let offset = 0;
-  for (const edit of textEdits(base, live)) {
-    const start = edit.start + offset;
-    protectedSpans.push({ start, end: start + edit.text.length });
-    offset += edit.text.length - (edit.end - edit.start);
-  }
-  return { group: !direct, protectedSpans };
-}
-
-// src/lib/document-match.ts
-var AmbiguousDocumentError = class extends Error {
-  constructor(identifier, matches) {
-    super(
-      `Document name "${identifier}" is ambiguous (${matches.map((doc) => doc.path).join(", ")}); use the exact project path.`
-    );
-    this.name = "AmbiguousDocumentError";
-  }
-};
-function matchDocument(identifier, docs) {
-  const exact = docs.filter((doc) => doc.path === identifier);
-  if (exact.length > 1) throw new AmbiguousDocumentError(identifier, exact);
-  if (exact.length === 1) return exact[0];
-  if (identifier.includes("/") || identifier.includes("\\")) return void 0;
-  const basename3 = identifier.replace(/\\/g, "/").split("/").pop() ?? identifier;
-  const matches = docs.filter((doc) => doc.name === basename3);
-  if (matches.length > 1) throw new AmbiguousDocumentError(identifier, matches);
-  return matches[0];
-}
-
-// src/lib/receipts.ts
-import {
-  closeSync as closeSync2,
-  existsSync as existsSync3,
-  fsyncSync as fsyncSync2,
-  mkdirSync as mkdirSync5,
-  openSync as openSync2,
-  readFileSync as readFileSync4,
-  readdirSync,
-  renameSync as renameSync2,
-  unlinkSync as unlinkSync3,
-  writeFileSync as writeFileSync5
-} from "fs";
-import { randomUUID as randomUUID2 } from "crypto";
-import { basename, dirname as dirname3, join as join5 } from "path";
-var RECEIPT_SCHEMA_VERSION = 1;
-var DEFAULT_RECEIPTS_DIR = join5(".overleaf", "receipts");
-function safeFilenamePart(value) {
-  const safe = value.replace(/[^a-zA-Z0-9_-]+/g, "-").replace(/^-+|-+$/g, "");
-  return safe || "operation";
-}
-function writeJsonAtomic(path, value) {
-  const targetDir = dirname3(path);
-  mkdirSync5(targetDir, { recursive: true });
-  const tempPath = join5(
-    targetDir,
-    `.${basename(path)}.${process.pid}.${randomUUID2()}.tmp`
-  );
-  let fd;
-  try {
-    fd = openSync2(tempPath, "wx", 384);
-    writeFileSync5(fd, `${JSON.stringify(value, null, 2)}
-`, "utf8");
-    fsyncSync2(fd);
-    closeSync2(fd);
-    fd = void 0;
-    renameSync2(tempPath, path);
-    let dirFd;
-    try {
-      dirFd = openSync2(targetDir, "r");
-      fsyncSync2(dirFd);
-    } catch {
-    } finally {
-      if (dirFd !== void 0) closeSync2(dirFd);
-    }
-  } finally {
-    if (fd !== void 0) closeSync2(fd);
-    if (existsSync3(tempPath)) unlinkSync3(tempPath);
-  }
-}
-function beginReceipt(operation, details, options = {}) {
-  const now = (options.now ?? (() => /* @__PURE__ */ new Date()))().toISOString();
-  const operationId = options.operationId ?? randomUUID2();
-  const receipt = {
-    schemaVersion: RECEIPT_SCHEMA_VERSION,
-    operationId,
-    operation,
-    status: "started",
-    startedAt: now,
-    updatedAt: now,
-    details
-  };
-  const dir = options.receiptsDir ?? DEFAULT_RECEIPTS_DIR;
-  const timestamp = now.replace(/[:.]/g, "-");
-  const path = join5(dir, `${timestamp}-${safeFilenamePart(operation)}-${operationId}.json`);
-  writeJsonAtomic(path, receipt);
-  return { path, receipt };
-}
-function updateReceipt(handle, status, details, options = {}) {
-  const receipt = {
-    ...handle.receipt,
-    status,
-    updatedAt: (options.now ?? (() => /* @__PURE__ */ new Date()))().toISOString(),
-    details: { ...handle.receipt.details, ...details }
-  };
-  writeJsonAtomic(handle.path, receipt);
-  return { path: handle.path, receipt };
-}
-function readReceipts(receiptsDir = DEFAULT_RECEIPTS_DIR) {
-  let names;
-  try {
-    names = readdirSync(receiptsDir).filter((name) => name.endsWith(".json"));
-  } catch {
-    return [];
-  }
-  const receipts = [];
-  for (const name of names) {
-    const path = join5(receiptsDir, name);
-    try {
-      const receipt = JSON.parse(readFileSync4(path, "utf8"));
-      if (receipt?.schemaVersion === RECEIPT_SCHEMA_VERSION && typeof receipt.operationId === "string" && typeof receipt.operation === "string" && typeof receipt.updatedAt === "string" && receipt.details && typeof receipt.details === "object") {
-        receipts.push({ path, receipt });
-      }
-    } catch {
-    }
-  }
-  return receipts.sort((a, b) => b.receipt.updatedAt.localeCompare(a.receipt.updatedAt));
-}
-
-// src/lib/sync-state.ts
-import { createHash as createHash2 } from "crypto";
-import {
-  mkdirSync as mkdirSync6,
-  readFileSync as readFileSync5,
-  renameSync as renameSync3,
-  unlinkSync as unlinkSync4,
-  writeFileSync as writeFileSync6
-} from "fs";
-import { dirname as dirname4, join as join6 } from "path";
-var BASE_STATE_SCHEMA_VERSION = 1;
-var BASE_STATE_PATH = join6(".overleaf", "base.json");
-function sha256(text) {
-  return createHash2("sha256").update(text, "utf8").digest("hex");
-}
-function canonicalize(value) {
-  if (Array.isArray(value)) return value.map(canonicalize);
-  if (value && typeof value === "object") {
-    const out = {};
-    for (const key of Object.keys(value).sort()) {
-      const item = value[key];
-      if (item !== void 0) out[key] = canonicalize(item);
-    }
-    return out;
-  }
-  return value;
-}
-function stableJson(value) {
-  return JSON.stringify(canonicalize(value));
-}
-function sortedRanges(values) {
-  return (values ?? []).map(canonicalize).sort((a, b) => {
-    const left = stableJson(a);
-    const right = stableJson(b);
-    return left < right ? -1 : left > right ? 1 : 0;
-  });
-}
-function fingerprintRanges(ranges) {
-  return sha256(
-    stableJson({
-      comments: sortedRanges(ranges.comments),
-      changes: sortedRanges(ranges.changes)
-    })
-  );
-}
-function assertBaseState(value, path) {
-  if (!value || typeof value !== "object") throw new Error(`Invalid base state in ${path}`);
-  const state = value;
-  if (state.schemaVersion !== BASE_STATE_SCHEMA_VERSION || typeof state.projectId !== "string" || !state.documents || typeof state.documents !== "object") {
-    throw new Error(
-      `Unsupported or invalid base state in ${path}; run fetch to create a new synchronization base.`
-    );
-  }
-  for (const [docId, raw] of Object.entries(state.documents)) {
-    const doc = raw;
-    if (doc.docId !== docId || typeof doc.path !== "string" || typeof doc.text !== "string" || typeof doc.hash !== "string" || doc.hash !== sha256(doc.text)) {
-      throw new Error(`Invalid document ${docId} in ${path}`);
-    }
-  }
-}
-function loadBaseState(path = BASE_STATE_PATH) {
-  let raw;
-  try {
-    raw = readFileSync5(path, "utf8");
-  } catch (error) {
-    if (error.code === "ENOENT") return void 0;
-    throw error;
-  }
-  let parsed;
-  try {
-    parsed = JSON.parse(raw);
-  } catch {
-    throw new Error(`Invalid JSON in ${path}; run fetch to recreate the synchronization base.`);
-  }
-  assertBaseState(parsed, path);
-  return parsed;
-}
-function saveBaseState(state, path = BASE_STATE_PATH) {
-  mkdirSync6(dirname4(path), { recursive: true });
-  const temp = `${path}.tmp-${process.pid}-${Date.now()}`;
-  try {
-    writeFileSync6(temp, JSON.stringify(state, null, 2) + "\n", { mode: 384 });
-    renameSync3(temp, path);
-  } catch (error) {
-    try {
-      unlinkSync4(temp);
-    } catch {
-    }
-    throw error;
-  }
-}
-function mergeBaseDocuments(projectId, documents, path = BASE_STATE_PATH) {
-  const previous = loadBaseState(path);
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const state = {
-    schemaVersion: BASE_STATE_SCHEMA_VERSION,
-    projectId,
-    updatedAt: now,
-    documents: previous?.projectId === projectId ? { ...previous.documents } : {}
-  };
-  for (const doc of documents) state.documents[doc.docId] = doc;
-  saveBaseState(state, path);
-  return state;
-}
-
-// src/lib/tracked-overlap.ts
-function spanOverlapsEdit(start, end, edit) {
-  const editIsPoint = edit.start === edit.end;
-  const rangeIsPoint = start === end;
-  if (editIsPoint && rangeIsPoint) return edit.start === start;
-  if (editIsPoint) return edit.start > start && edit.start < end;
-  if (rangeIsPoint) return start >= edit.start && start < edit.end;
-  return edit.start < end && start < edit.end;
-}
-function overlapsEdit(change, edit) {
-  const p = change.op?.p;
-  if (typeof p !== "number") return false;
-  const inserted = typeof change.op?.i === "string" ? change.op.i : void 0;
-  const changeStart = p;
-  const changeEnd = p + (inserted?.length ?? 0);
-  return spanOverlapsEdit(changeStart, changeEnd, edit);
-}
-function findTrackedChangeOverlaps(changes, proposedEdits) {
-  const out = [];
-  for (const change of changes ?? []) {
-    for (const proposedEdit of proposedEdits) {
-      if (overlapsEdit(change, proposedEdit)) {
-        out.push({ changeId: change.id ?? "(unknown)", change, proposedEdit });
-      }
-    }
-  }
-  return out;
-}
-function findCommentOverlaps(comments, proposedEdits) {
-  const out = [];
-  for (const comment2 of comments ?? []) {
-    const p = comment2.op?.p;
-    const anchor = comment2.op?.c;
-    if (typeof p !== "number" || typeof anchor !== "string") continue;
-    for (const proposedEdit of proposedEdits) {
-      if (spanOverlapsEdit(p, p + anchor.length, proposedEdit)) {
-        out.push({
-          threadId: comment2.op?.t ?? comment2.id ?? "(unknown)",
-          position: p,
-          anchor,
-          comment: comment2,
-          proposedEdit
-        });
-      }
-    }
-  }
-  return out;
-}
-
-// src/lib/tracked-changes.ts
-import { randomBytes } from "crypto";
-var TRACKED_CHANGE_SEED_BYTES = 9;
-function createTrackedChangeSeed(bytes = randomBytes) {
-  const entropy = bytes(TRACKED_CHANGE_SEED_BYTES);
-  if (entropy.byteLength !== TRACKED_CHANGE_SEED_BYTES) {
-    throw new Error(
-      `tracked-change seed source returned ${entropy.byteLength} bytes; expected ${TRACKED_CHANGE_SEED_BYTES}`
-    );
-  }
-  return Buffer.from(entropy).toString("hex");
-}
-var TrackedChangeMutationError = class extends Error {
-  constructor(message, result, cause) {
-    super(message, cause === void 0 ? void 0 : { cause });
-    this.result = result;
-    this.name = "TrackedChangeMutationError";
-  }
-  result;
-};
-function uniqueChangeIds(changeIds) {
-  return [...new Set(changeIds)];
-}
-function changeIdsInRanges(ranges) {
-  return [...new Set(ranges.map((range) => range.id))];
-}
-function remainingChangeIds(ranges, requestedIds) {
-  const present = new Set(changeIdsInRanges(ranges));
-  return uniqueChangeIds(requestedIds).filter((id) => present.has(id));
-}
-function inverseOf(range) {
-  const { p, i, d } = range.op ?? {};
-  if (!Number.isSafeInteger(p) || p < 0) {
-    throw new Error(`tracked change ${range.id} has an invalid position: ${String(p)}`);
-  }
-  if (typeof i === "string" && d === void 0) return { p, d: i, u: true };
-  if (typeof d === "string" && i === void 0) return { p, i: d, u: true };
-  throw new Error(`tracked change ${range.id} does not contain exactly one insert/delete op`);
-}
-function applyUndo(text, op, changeId) {
-  if (op.p > text.length) {
-    throw new Error(
-      `tracked change ${changeId} starts at ${op.p}, beyond document length ${text.length}`
-    );
-  }
-  if ("d" in op) {
-    const actual = text.slice(op.p, op.p + op.d.length);
-    if (actual !== op.d) {
-      throw new Error(
-        `tracked insertion ${changeId} no longer matches document text at ${op.p}: expected ${JSON.stringify(op.d)}, found ${JSON.stringify(actual)}`
-      );
-    }
-    return text.slice(0, op.p) + text.slice(op.p + op.d.length);
-  }
-  return text.slice(0, op.p) + op.i + text.slice(op.p);
-}
-function buildRejectionPlan(currentText, ranges, requestedIds) {
-  const requested = new Set(uniqueChangeIds(requestedIds));
-  const fragments = ranges.filter((range) => requested.has(range.id));
-  fragments.sort((a, b) => b.op.p - a.op.p);
-  const operations = [];
-  let expectedText = currentText;
-  for (const range of fragments) {
-    const inverse = inverseOf(range);
-    expectedText = applyUndo(expectedText, inverse, range.id);
-    operations.push(inverse);
-  }
-  return {
-    changeIds: changeIdsInRanges(fragments),
-    fragmentCount: fragments.length,
-    operations,
-    expectedText
-  };
-}
-
-// src/lib/snapshots.ts
-import { join as join7 } from "path";
-var SNAPSHOTS_DIR = join7(".overleaf", "snapshots");
-function snapshotTimestamp(date = /* @__PURE__ */ new Date()) {
-  return date.toISOString().replace(/[:.]/g, "-");
-}
-function snapshotRelativePath(timestamp, projectPath, root = process.cwd()) {
-  if (!/^[0-9TZ-]+$/.test(timestamp)) throw new Error(`Invalid snapshot timestamp: ${timestamp}`);
-  const safeProjectPath = workspaceRelativePath(projectPath, root);
-  return workspaceRelativePath(join7(SNAPSHOTS_DIR, timestamp, safeProjectPath), root);
-}
-
-// src/commands/push.ts
-var PUSH_PLAN_SCHEMA_VERSION = 4;
-var PUSH_PLAN_KIND = "overleaf-review-push-plan";
-var PushSubmissionError = class extends Error {
-  constructor(message, receiptPath, status, documents, cause) {
-    super(message, cause === void 0 ? void 0 : { cause });
-    this.receiptPath = receiptPath;
-    this.status = status;
-    this.documents = documents;
-    this.name = "PushSubmissionError";
-  }
-  receiptPath;
-  status;
-  documents;
-};
-var PushPlanningError = class extends Error {
-  constructor(message, conflicts = [], overlaps = []) {
-    super(message);
-    this.conflicts = conflicts;
-    this.overlaps = overlaps;
-    this.name = "PushPlanningError";
-  }
-  conflicts;
-  overlaps;
-};
-var PushPlanValidationError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "PushPlanValidationError";
-  }
-};
-function validatePushOptions(opts) {
-  if (opts.edits && (opts.plan || !opts.file || opts.direct || opts.unsafeNoBase)) {
-    throw new Error("--edits requires --file and a saved base, and cannot be combined with --plan, --direct or --unsafe-no-base.");
-  }
-  if (opts.docName && !opts.file) {
-    throw new Error("--doc requires --file; bulk pushes cannot map multiple local files to one document.");
-  }
-}
-function buildOps(source, target, options = {}) {
-  const ops = [];
-  let offset = 0;
-  for (const edit of buildReviewEdits(source, target, options)) {
-    const p = edit.start + offset;
-    const deleted = source.slice(edit.start, edit.end);
-    if (deleted) ops.push({ p, d: deleted });
-    if (edit.text) ops.push({ p, i: edit.text });
-    offset += edit.text.length - deleted.length;
-  }
-  const rebuilt = applyOps(source, ops);
-  if (rebuilt !== target) {
-    throw new Error("internal error: generated OT operations do not reconstruct target text");
-  }
-  return ops;
-}
-function buildOperationFootprint(source, target, options = {}) {
-  return buildReviewEdits(source, target, options);
-}
-function applyOps(source, ops) {
-  let text = source;
-  for (const op of ops) {
-    if (!Number.isSafeInteger(op.p) || op.p < 0 || op.p > text.length) {
-      throw new Error(`invalid operation position ${String(op.p)} for ${text.length}-character text`);
-    }
-    const hasInsert = typeof op.i === "string";
-    const hasDelete = typeof op.d === "string";
-    if (hasInsert === hasDelete) throw new Error("operation must contain exactly one of i or d");
-    if (hasInsert) {
-      text = text.slice(0, op.p) + op.i + text.slice(op.p);
-    } else {
-      const deletion = op.d;
-      const actual = text.slice(op.p, op.p + deletion.length);
-      if (actual !== deletion) {
-        throw new Error(
-          `delete operation mismatch at ${op.p}: expected ${JSON.stringify(deletion)}, found ${JSON.stringify(actual)}`
-        );
-      }
-      text = text.slice(0, op.p) + text.slice(op.p + deletion.length);
-    }
-  }
-  return text;
-}
-function preview(op) {
-  const kind = op.i != null ? "insert" : "delete";
-  const text = (op.i ?? op.d ?? "").replace(/\n/g, "\u23CE");
-  const clip = text.length > 60 ? text.slice(0, 60) + "\u2026" : text;
-  return `  ${kind.padEnd(6)} @ ${String(op.p).padStart(5)}  "${clip}"`;
-}
-function toOverleafPath(file) {
-  return workspaceRelativePath(file);
-}
-var IGNORE_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", ".overleaf", "tmp", "dist"]);
-function discoverLocalTex(dir = process.cwd(), acc = []) {
-  for (const entry of readdirSync2(dir, { withFileTypes: true })) {
-    if (entry.name.startsWith(".") || IGNORE_DIRS.has(entry.name)) continue;
-    const full = resolvePath(dir, entry.name);
-    if (entry.isDirectory()) discoverLocalTex(full, acc);
-    else if (entry.name.endsWith(".tex")) {
-      acc.push(relative2(process.cwd(), full).split(sep2).join("/"));
-    }
-  }
-  return acc;
-}
-function pickDoc(file, docName, docs) {
-  return matchDocument(docName?.replace(/\\/g, "/") ?? toOverleafPath(file), docs);
-}
-function formatConflicts(conflicts) {
-  return conflicts.flatMap(
-    ({ docPath, conflicts: items }) => items.map(
-      ({ local, live, reason }) => reason === "ambiguous-local-anchor" ? `${docPath}: repeated-text anchor for local [${local.start},${local.end}) is ambiguous and its envelope is touched by live [${live.start},${live.end}); refresh and reapply this edit explicitly` : `${docPath}: local [${local.start},${local.end}) overlaps live [${live.start},${live.end})`
-    )
-  ).join("\n  ");
-}
-function serializeOverlaps(overlaps) {
-  return overlaps.map(({ changeId, proposedEdit, change }) => ({
-    changeId,
-    proposedEdit,
-    trackedOp: {
-      p: change.op?.p,
-      i: change.op?.i,
-      d: change.op?.d
-    }
-  })).sort((a, b) => {
-    const left = stableJson(a);
-    const right = stableJson(b);
-    return left < right ? -1 : left > right ? 1 : 0;
-  });
-}
-function serializeActiveTrackedRanges(changes) {
-  const ranges = (changes ?? []).map((change, index) => {
-    const id = change?.id;
-    const p = change?.op?.p;
-    const hasInsert = typeof change?.op?.i === "string";
-    const hasDelete = typeof change?.op?.d === "string";
-    if (typeof id !== "string" || !Number.isSafeInteger(p) || p < 0 || hasInsert === hasDelete) {
-      throw new Error(`Overleaf returned an invalid tracked range at index ${index}`);
-    }
-    return {
-      id,
-      op: {
-        p,
-        ...hasInsert ? { i: change.op.i } : { d: change.op.d }
-      },
-      ...change.metadata && typeof change.metadata === "object" ? { metadata: change.metadata } : {}
-    };
-  });
-  return ranges.sort((a, b) => {
-    const left = stableJson(a);
-    const right = stableJson(b);
-    return left < right ? -1 : left > right ? 1 : 0;
-  });
-}
-function serializeCommentOverlaps(overlaps) {
-  return overlaps.map(({ threadId, position, anchor, proposedEdit }) => ({
-    threadId,
-    position,
-    anchor,
-    proposedEdit
-  })).sort((a, b) => {
-    const left = stableJson(a);
-    const right = stableJson(b);
-    return left < right ? -1 : left > right ? 1 : 0;
-  });
-}
-async function createPlan(opts = {}) {
-  validatePushOptions(opts);
-  const manifest = opts.edits ? JSON.parse(readFileSync6(workspaceReadPath(opts.edits), "utf8")) : void 0;
-  if (opts.plan) throw new Error("createPlan does not accept an existing plan");
-  const basePath = opts.basePath ?? BASE_STATE_PATH;
-  const baseState = loadBaseState(basePath);
-  if (baseState && baseState.projectId !== config.projectId && !opts.unsafeNoBase) {
-    throw new PushPlanningError(
-      `Saved base belongs to project ${baseState.projectId}, not ${config.projectId}; run fetch first.`
-    );
-  }
-  const { socket, project, docs } = await openProject();
-  try {
-    const projectId = String(project?._id ?? config.projectId);
-    if (projectId !== config.projectId) {
-      throw new PushPlanningError(
-        `Connected project id ${projectId} does not match configured project ${config.projectId}.`
-      );
-    }
-    const files = opts.file ? [workspaceRelativePath(opts.file)] : discoverLocalTex();
-    if (!files.length) {
-      const emptyPlan = {
-        kind: PUSH_PLAN_KIND,
-        schemaVersion: PUSH_PLAN_SCHEMA_VERSION,
-        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-        projectId,
-        projectName: String(project?.name ?? "(unknown)"),
-        direct: Boolean(opts.direct),
-        unsafeNoBase: Boolean(opts.unsafeNoBase),
-        allowOverlap: Boolean(opts.allowOverlap),
-        documents: []
-      };
-      if (opts.planOut) writePushPlan(emptyPlan, opts.planOut);
-      return emptyPlan;
-    }
-    const documents = [];
-    const conflicts = [];
-    const blockedOverlaps = [];
-    for (const file of files) {
-      let local;
-      try {
-        local = readFileSync6(workspaceReadPath(file), "utf8");
-      } catch (error) {
-        throw new Error(`Cannot safely read ${file}: ${error.message}`);
-      }
-      const doc = pickDoc(file, opts.docName, docs);
-      if (!doc) {
-        throw new Error(
-          `No Overleaf document matches ${file}; push it with --file and --doc using the exact project path.`
-        );
-      }
-      const state = await joinDoc(socket, doc._id);
-      const live = state.lines.join("\n");
-      const savedBase = baseState?.projectId === projectId ? baseState.documents[doc._id] : void 0;
-      if (!savedBase && !opts.unsafeNoBase) {
-        throw new PushPlanningError(
-          `No saved synchronization base for ${doc.path}. Run fetch first, or explicitly use \`--unsafe-no-base\` to request legacy two-way behavior.`
-        );
-      }
-      const base = savedBase?.text ?? live;
-      const merge = threeWayMerge(base, local, live);
-      if (merge.conflicts.length) {
-        conflicts.push({ localPath: file, docPath: doc.path, conflicts: merge.conflicts });
-        continue;
-      }
-      const expected = merge.text;
-      const explicitEdits = manifest ? parseReplacementManifest(base, manifest) : void 0;
-      let grouping = reviewGroupingOptions(base, live, state.ranges, opts.direct);
-      if (explicitEdits) grouping = bindExplicitEdits(base, local, live, explicitEdits, grouping);
-      const ops = buildOps(live, expected, grouping);
-      if (!ops.length) continue;
-      const proposedEdits = buildOperationFootprint(live, expected, grouping);
-      const activeTrackedRanges = serializeActiveTrackedRanges(state.ranges.changes);
-      assertTrackedRangeBudget(activeTrackedRanges.length, ops.length, Boolean(opts.direct), doc.path);
-      const overlaps = serializeOverlaps(
-        findTrackedChangeOverlaps(state.ranges.changes, proposedEdits)
-      );
-      const commentOverlaps = serializeCommentOverlaps(
-        findCommentOverlaps(state.ranges.comments, proposedEdits)
-      );
-      if (overlaps.length && !opts.allowOverlap) {
-        blockedOverlaps.push({ localPath: file, docPath: doc.path, overlaps });
-        continue;
-      }
-      documents.push({
-        ...explicitEdits ? { explicitEdits } : {},
-        localPath: toOverleafPath(file),
-        docId: doc._id,
-        docPath: doc.path,
-        baseSource: savedBase ? "saved" : "live-unsafe",
-        baseHash: sha256(base),
-        localHash: sha256(local),
-        liveHash: sha256(live),
-        liveVersion: state.version,
-        rangeFingerprint: fingerprintRanges(state.ranges),
-        ops,
-        expectedHash: sha256(expected),
-        tcSeed: opts.direct ? null : createTrackedChangeSeed(),
-        activeTrackedRanges,
-        trackedChangeOverlaps: overlaps,
-        commentOverlaps
-      });
-    }
-    if (conflicts.length || blockedOverlaps.length) {
-      const parts = [];
-      if (conflicts.length) parts.push(`Concurrent edit conflicts:
-  ${formatConflicts(conflicts)}`);
-      if (blockedOverlaps.length) {
-        const lines = blockedOverlaps.flatMap(
-          ({ docPath, overlaps }) => overlaps.map(
-            ({ changeId, proposedEdit }) => `${docPath}: proposed [${proposedEdit.start},${proposedEdit.end}) overlaps change ${changeId}`
-          )
-        );
-        parts.push(
-          `Active tracked-change overlaps:
-  ${lines.join("\n  ")}
-Re-plan with --allow-overlap only after inspecting these changes.`
-        );
-      }
-      throw new PushPlanningError(parts.join("\n\n"), conflicts, blockedOverlaps);
-    }
-    const plan = {
-      kind: PUSH_PLAN_KIND,
-      schemaVersion: PUSH_PLAN_SCHEMA_VERSION,
-      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-      projectId,
-      projectName: String(project?.name ?? "(unknown)"),
-      direct: Boolean(opts.direct),
-      unsafeNoBase: documents.some((doc) => doc.baseSource === "live-unsafe"),
-      allowOverlap: Boolean(opts.allowOverlap),
-      documents
-    };
-    if (opts.planOut) writePushPlan(plan, opts.planOut);
-    return plan;
-  } finally {
-    socket.close();
-  }
-}
-function assertHash(value, field) {
-  if (typeof value !== "string" || !/^[0-9a-f]{64}$/.test(value)) {
-    throw new PushPlanValidationError(`Invalid ${field} in push plan`);
-  }
-}
-function validatePushPlan(value) {
-  if (!value || typeof value !== "object") throw new PushPlanValidationError("Push plan is not an object");
-  const plan = value;
-  if (plan.kind !== PUSH_PLAN_KIND || plan.schemaVersion !== PUSH_PLAN_SCHEMA_VERSION) {
-    throw new PushPlanValidationError("Unsupported push-plan kind or schema version; create a new plan with the current tool.");
-  }
-  if (typeof plan.projectId !== "string" || typeof plan.projectName !== "string" || typeof plan.createdAt !== "string" || typeof plan.direct !== "boolean" || typeof plan.unsafeNoBase !== "boolean" || typeof plan.allowOverlap !== "boolean" || !Array.isArray(plan.documents)) {
-    throw new PushPlanValidationError("Push plan is missing required fields");
-  }
-  const seen = /* @__PURE__ */ new Set();
-  const seenLocalPaths = /* @__PURE__ */ new Set();
-  for (const doc of plan.documents) {
-    if (doc?.explicitEdits !== void 0 && (!Array.isArray(doc.explicitEdits) || !doc.explicitEdits.length || !doc.explicitEdits.every(validTextEdit) || plan.direct || doc.baseSource !== "saved")) throw new PushPlanValidationError("Invalid explicit replacement blocks in push plan.");
-    if (!doc || typeof doc.localPath !== "string" || typeof doc.docId !== "string" || typeof doc.docPath !== "string" || doc.baseSource !== "saved" && doc.baseSource !== "live-unsafe" || !Number.isSafeInteger(doc.liveVersion) || doc.liveVersion < 0 || !Array.isArray(doc.ops) || doc.ops.length === 0 || !Array.isArray(doc.activeTrackedRanges) || !Array.isArray(doc.trackedChangeOverlaps) || !Array.isArray(doc.commentOverlaps)) {
-      throw new PushPlanValidationError("Push plan contains an invalid document");
-    }
-    try {
-      if (workspaceRelativePath(doc.localPath) !== doc.localPath || workspaceRelativePath(doc.docPath) !== doc.docPath) {
-        throw new Error("path is not normalized");
-      }
-    } catch (error) {
-      throw new PushPlanValidationError(
-        `Unsafe or invalid path in push plan: ${error.message}`
-      );
-    }
-    if (seen.has(doc.docId)) throw new PushPlanValidationError(`Duplicate document ${doc.docId} in plan`);
-    seen.add(doc.docId);
-    if (seenLocalPaths.has(doc.localPath)) {
-      throw new PushPlanValidationError(`Duplicate local path ${doc.localPath} in plan`);
-    }
-    seenLocalPaths.add(doc.localPath);
-    assertHash(doc.baseHash, "baseHash");
-    assertHash(doc.localHash, "localHash");
-    assertHash(doc.liveHash, "liveHash");
-    assertHash(doc.rangeFingerprint, "rangeFingerprint");
-    assertHash(doc.expectedHash, "expectedHash");
-    for (const op of doc.ops) {
-      if (!op || !Number.isSafeInteger(op.p) || op.p < 0 || typeof op.i === "string" === (typeof op.d === "string") || typeof (op.i ?? op.d) === "string" && (op.i ?? op.d).length === 0) {
-        throw new PushPlanValidationError(`Invalid operation in ${doc.docPath}`);
-      }
-    }
-    for (const range of doc.activeTrackedRanges) {
-      if (!range || typeof range.id !== "string" || !Number.isSafeInteger(range.op?.p) || range.op.p < 0 || typeof range.op.i === "string" === (typeof range.op.d === "string") || range.metadata !== void 0 && (!range.metadata || typeof range.metadata !== "object")) {
-        throw new PushPlanValidationError(`Invalid active tracked range in ${doc.docPath}`);
-      }
-    }
-    for (const overlap of doc.trackedChangeOverlaps) {
-      if (!overlap || typeof overlap.changeId !== "string" || !validTextEdit(overlap.proposedEdit) || !Number.isSafeInteger(overlap.trackedOp?.p)) {
-        throw new PushPlanValidationError(`Invalid tracked-change overlap in ${doc.docPath}`);
-      }
-    }
-    for (const overlap of doc.commentOverlaps) {
-      if (!overlap || typeof overlap.threadId !== "string" || !Number.isSafeInteger(overlap.position) || overlap.position < 0 || typeof overlap.anchor !== "string" || !validTextEdit(overlap.proposedEdit)) {
-        throw new PushPlanValidationError(`Invalid comment overlap in ${doc.docPath}`);
-      }
-    }
-    if (plan.direct) {
-      if (doc.tcSeed !== null) throw new PushPlanValidationError("Direct plan must not contain tcSeed");
-    } else if (typeof doc.tcSeed !== "string" || !/^[0-9a-f]{18}$/.test(doc.tcSeed)) {
-      throw new PushPlanValidationError(`Invalid tracked-change seed in ${doc.docPath}`);
-    }
-    if (!plan.allowOverlap && doc.trackedChangeOverlaps.length) {
-      throw new PushPlanValidationError("Plan contains blocked tracked-change overlaps");
-    }
-    if (doc.baseSource === "live-unsafe" && doc.baseHash !== doc.liveHash) {
-      throw new PushPlanValidationError(`Unsafe base must equal planned live text in ${doc.docPath}`);
-    }
-  }
-  return plan;
-}
-function validTextEdit(value) {
-  if (!value || typeof value !== "object") return false;
-  const edit = value;
-  return Boolean(
-    Number.isSafeInteger(edit.start) && Number.isSafeInteger(edit.end) && edit.start >= 0 && edit.end >= edit.start && typeof edit.text === "string"
-  );
-}
-function readPushPlan(path, workspaceRoot = process.cwd()) {
-  let parsed;
-  try {
-    parsed = JSON.parse(readFileSync6(workspaceReadPath(path, workspaceRoot), "utf8"));
-  } catch (error) {
-    throw new PushPlanValidationError(`Cannot read push plan ${path}: ${error.message}`);
-  }
-  return validatePushPlan(parsed);
-}
-function writePushPlan(plan, path, workspaceRoot = process.cwd()) {
-  validatePushPlan(plan);
-  const target = workspaceWritePath(path, workspaceRoot);
-  mkdirSync7(dirname5(target), { recursive: true });
-  const temp = `${target}.tmp-${process.pid}-${Date.now()}`;
-  try {
-    writeFileSync7(temp, JSON.stringify(plan, null, 2) + "\n", { mode: 384 });
-    renameSync4(temp, target);
-  } catch (error) {
-    try {
-      unlinkSync5(temp);
-    } catch {
-    }
-    throw error;
-  }
-}
-function trackedChangeIdsForSeed(seed, count) {
-  return Array.from(
-    { length: count },
-    (_, index) => `${seed}${(index + 1).toString(16).padStart(6, "0")}`
-  );
-}
-function errorMessage(error) {
-  return error instanceof Error ? error.message : String(error);
-}
-function overleafSnapshotHash(text) {
-  return createHash3("sha1").update(`blob ${text.length}\0`, "utf8").update(text, "utf8").digest("hex");
-}
-function validatePlannedIntent(planned, base, local, live, grouping = reviewGroupingOptions(base, live, {})) {
-  if (sha256(base) !== planned.baseHash) {
-    throw new PushPlanValidationError(`Synchronization base changed for ${planned.docPath}.`);
-  }
-  if (sha256(local) !== planned.localHash) {
-    throw new PushPlanValidationError(`${planned.localPath} changed after planning.`);
-  }
-  if (sha256(live) !== planned.liveHash) {
-    throw new PushPlanValidationError(`${planned.docPath} text changed after planning.`);
-  }
-  const merge = threeWayMerge(base, local, live);
-  if (merge.conflicts.length || merge.text === void 0) {
-    throw new PushPlanValidationError(
-      `${planned.docPath} no longer has the conflict-free intent recorded by the plan.`
-    );
-  }
-  const expected = merge.text;
-  if (stableJson(buildOps(live, expected, grouping)) !== stableJson(planned.ops) || sha256(expected) !== planned.expectedHash) {
-    throw new PushPlanValidationError(
-      `Operations in ${planned.docPath} do not match its saved Base\u2192Local intent.`
-    );
-  }
-  return expected;
-}
-function validateReviewBinding(planned, state, live, expected, allowOverlap, grouping) {
-  if (state.version !== planned.liveVersion) {
-    throw new PushPlanValidationError(
-      `${planned.docPath} version changed from ${planned.liveVersion} to ${state.version}; create a new plan.`
-    );
-  }
-  if (fingerprintRanges(state.ranges) !== planned.rangeFingerprint) {
-    throw new PushPlanValidationError(
-      `${planned.docPath} comments or tracked ranges changed after planning; create a new plan.`
-    );
-  }
-  const footprint = buildOperationFootprint(live, expected, grouping);
-  const activeTrackedRanges = serializeActiveTrackedRanges(state.ranges.changes);
-  const trackedOverlaps = serializeOverlaps(
-    findTrackedChangeOverlaps(state.ranges.changes, footprint)
-  );
-  const commentOverlaps = serializeCommentOverlaps(
-    findCommentOverlaps(state.ranges.comments, footprint)
-  );
-  if (stableJson(activeTrackedRanges) !== stableJson(planned.activeTrackedRanges)) {
-    throw new PushPlanValidationError(
-      `Active tracked-range data is invalid for ${planned.docPath}; create a new plan.`
-    );
-  }
-  if (stableJson(trackedOverlaps) !== stableJson(planned.trackedChangeOverlaps)) {
-    throw new PushPlanValidationError(
-      `Tracked-change overlap data is invalid for ${planned.docPath}; create a new plan.`
-    );
-  }
-  if (trackedOverlaps.length && !allowOverlap) {
-    throw new PushPlanValidationError(
-      `${planned.docPath} operations overlap active tracked changes; create a plan with --allow-overlap only after inspecting them.`
-    );
-  }
-  if (stableJson(commentOverlaps) !== stableJson(planned.commentOverlaps)) {
-    throw new PushPlanValidationError(
-      `Comment-overlap data is invalid for ${planned.docPath}; create a new plan.`
-    );
-  }
-}
-function baseTextForPlan(plan, planned, live, basePath) {
-  if (planned.baseSource === "live-unsafe") {
-    if (!plan.unsafeNoBase) {
-      throw new PushPlanValidationError(`${planned.docPath} uses an unauthorized unsafe base.`);
-    }
-    return live;
-  }
-  const state = loadBaseState(basePath);
-  const saved = state?.projectId === plan.projectId ? state.documents[planned.docId] : void 0;
-  if (!saved || saved.hash !== planned.baseHash || sha256(saved.text) !== planned.baseHash) {
-    throw new PushPlanValidationError(
-      `Synchronization base for ${planned.docPath} changed after planning; create a new plan.`
-    );
-  }
-  return saved.text;
-}
-async function bindPlanDocument(plan, planned, socket, basePath) {
-  let local;
-  try {
-    local = readFileSync6(workspaceReadPath(planned.localPath), "utf8");
-  } catch (error) {
-    throw new PushPlanValidationError(
-      `Cannot read planned local file ${planned.localPath}: ${errorMessage(error)}`
-    );
-  }
-  const state = await joinDoc(socket, planned.docId);
-  const live = state.lines.join("\n");
-  const base = baseTextForPlan(plan, planned, live, basePath);
-  let grouping = reviewGroupingOptions(base, live, state.ranges, plan.direct);
-  if (planned.explicitEdits) grouping = bindExplicitEdits(base, local, live, planned.explicitEdits, grouping);
-  const expected = validatePlannedIntent(planned, base, local, live, grouping);
-  validateReviewBinding(planned, state, live, expected, plan.allowOverlap, grouping);
-  assertTrackedRangeBudget(state.ranges.changes?.length ?? 0, planned.ops.length, plan.direct, planned.docPath);
-  return { plan: planned, state, expected };
-}
-var MAX_TRACKED_RANGES = 2e3;
-function assertTrackedRangeBudget(activeCount, operationCount, direct, docPath) {
-  if (direct || operationCount === 0) return;
-  if (activeCount + operationCount > MAX_TRACKED_RANGES) {
-    throw new PushPlanValidationError(
-      `${docPath}: ${activeCount} active tracked ranges + ${operationCount} proposed operations exceeds the conservative ${MAX_TRACKED_RANGES}-range budget. Overleaf rejects documents with too many tracked changes. Reduce the revision or arrange review of existing suggestions before submitting; smaller batches do not remove accumulated ranges.`
-    );
-  }
-}
-function verifiedTrackedIds(plan, planned, after) {
-  if (plan.direct) return [];
-  const actualIds = new Set((after.ranges.changes ?? []).map((change) => String(change.id)));
-  if (planned.trackedChangeOverlaps.length) {
-    const ids = [...actualIds].filter(
-      (id) => new RegExp(`^${planned.tcSeed}[0-9a-f]{6}$`).test(id)
-    );
-    if (!ids.length) {
-      throw new Error(
-        `Verification failed for ${planned.docPath}: no tracked ranges with seed ${planned.tcSeed} were created.`
-      );
-    }
-    return ids;
-  }
-  const expectedIds = trackedChangeIdsForSeed(planned.tcSeed, planned.ops.length);
-  const missing = expectedIds.filter((id) => !actualIds.has(id));
-  if (missing.length) {
-    throw new Error(
-      `Verification failed for ${planned.docPath}: tracked ranges were not created for ${missing.join(", ")}.`
-    );
-  }
-  return expectedIds;
-}
-function definitelyRejectedApply(error) {
-  const message = errorMessage(error);
-  return message.includes("Overleaf rejected the OT update") || message.includes("Overleaf failed to apply the OT update");
-}
-function initialReceiptDocuments(plan) {
-  return plan.documents.map((doc) => ({
-    docId: doc.docId,
-    docPath: doc.docPath,
-    localPath: doc.localPath,
-    opCount: doc.ops.length,
-    expectedHash: doc.expectedHash,
-    status: "pending",
-    mutationAttempted: false
-  }));
-}
-function pushReceiptNeedsQuarantine(receipt) {
-  if (receipt.status === "ambiguous") return true;
-  if (receipt.status !== "in_progress") return false;
-  const documents = receipt.details?.documents;
-  return Array.isArray(documents) && documents.some(
-    (document) => Boolean(document) && typeof document === "object" && (document.mutationAttempted === true || typeof document.mutationStartedAt === "string")
-  );
-}
-function receiptDocumentIds(receipt) {
-  const documents = receipt.details?.documents;
-  if (!Array.isArray(documents)) return [];
-  return documents.flatMap((document) => {
-    if (!document || typeof document !== "object") return [];
-    const docId = document.docId;
-    return typeof docId === "string" ? [docId] : [];
-  });
-}
-function quarantinedPlanDocuments(plan, receipts) {
-  const plannedIds = new Set(plan.documents.map((document) => document.docId));
-  const disposition = /* @__PURE__ */ new Map();
-  const newestFirst = [...receipts].sort(
-    (a, b) => String(b.receipt.updatedAt ?? "").localeCompare(String(a.receipt.updatedAt ?? ""))
-  );
-  for (const { receipt } of newestFirst) {
-    if (receipt.operation !== "push" || receipt.details?.projectId !== plan.projectId) {
-      continue;
-    }
-    const reconciles = receipt.status === "succeeded" && receipt.details.acknowledgedAmbiguousRetry === true;
-    const quarantines = pushReceiptNeedsQuarantine(receipt);
-    if (!reconciles && !quarantines) continue;
-    for (const docId of receiptDocumentIds(receipt)) {
-      if (plannedIds.has(docId) && !disposition.has(docId)) {
-        disposition.set(docId, reconciles ? "reconciled" : "quarantined");
-      }
-    }
-  }
-  return plan.documents.filter((document) => disposition.get(document.docId) === "quarantined").map((document) => document.docPath);
-}
-function synchronizeLocalAfterRemote(localPath, plannedLocalHash, remoteText, workspaceRoot = process.cwd()) {
-  const localFile = workspaceReadPath(localPath, workspaceRoot);
-  const currentLocal = readFileSync6(localFile, "utf8");
-  if (sha256(currentLocal) !== plannedLocalHash) {
-    throw new Error(`${localPath} changed while the plan was being submitted; local file left untouched.`);
-  }
-  if (currentLocal === remoteText) return {};
-  const timestamp = `${snapshotTimestamp()}-${process.pid}`;
-  const snapshotPath = snapshotRelativePath(timestamp, localPath, workspaceRoot);
-  const snapshotFile = workspaceWritePath(snapshotPath, workspaceRoot);
-  mkdirSync7(dirname5(snapshotFile), { recursive: true });
-  writeFileSync7(snapshotFile, currentLocal, { flag: "wx", mode: 384 });
-  const target = workspaceWritePath(localPath, workspaceRoot);
-  const temp = `${target}.tmp-${process.pid}-${Date.now()}`;
-  try {
-    writeFileSync7(temp, remoteText, { mode: statSync(localFile).mode & 511 });
-    if (sha256(readFileSync6(localFile, "utf8")) !== plannedLocalHash) {
-      throw new Error(`${localPath} changed while the plan was being submitted; local file left untouched.`);
-    }
-    renameSync4(temp, target);
-  } catch (error) {
-    try {
-      unlinkSync5(temp);
-    } catch {
-    }
-    throw error;
-  }
-  return { snapshotPath };
-}
-async function submitPlan(planOrPath, opts = {}) {
-  const plan = typeof planOrPath === "string" ? readPushPlan(planOrPath) : validatePushPlan(planOrPath);
-  const totalOps = plan.documents.reduce((sum, doc) => sum + doc.ops.length, 0);
-  const planHash = sha256(stableJson(plan));
-  const receiptDocuments = initialReceiptDocuments(plan);
-  let receipt = beginReceipt(
-    "push",
-    {
-      projectId: plan.projectId,
-      direct: plan.direct,
-      planCreatedAt: plan.createdAt,
-      planHash,
-      totalOps,
-      phase: "preflight",
-      plan,
-      documents: receiptDocuments
-    },
-    { receiptsDir: opts.receiptsDir }
-  );
-  const completed = [];
-  const basePath = opts.basePath ?? BASE_STATE_PATH;
-  let opened;
-  let mutationLock;
-  let unknownMutationOutcome = false;
-  let failureStatus;
-  try {
-    if (plan.projectId !== config.projectId) {
-      throw new PushPlanValidationError(
-        `Plan is for project ${plan.projectId}, but this repository is linked to ${config.projectId}.`
-      );
-    }
-    mutationLock = acquireMutationLock(plan.projectId);
-    const priorReceipts = readReceipts(opts.receiptsDir);
-    const quarantinedDocuments = quarantinedPlanDocuments(plan, priorReceipts);
-    if (quarantinedDocuments.length && !opts.allowAmbiguousRetry) {
-      throw new PushPlanValidationError(
-        `A prior push has an unresolved outcome for: ${quarantinedDocuments.join(", ")}. Wait for delayed updates, inspect Overleaf and its receipt, then create a fresh plan. Only after manual reconciliation may you submit with --acknowledge-ambiguous.`
-      );
-    }
-    if (!plan.documents.length) {
-      receipt = updateReceipt(receipt, "skipped", {
-        phase: "complete",
-        outcome: "empty_plan",
-        documents: receiptDocuments
-      });
-      return {
-        projectId: plan.projectId,
-        direct: plan.direct,
-        totalOps,
-        documents: completed,
-        receiptPath: receipt.path
-      };
-    }
+  return map;
+}
+async function pull(outDir = ".overleaf", options = {}) {
+  let mutationLock;
+  let opened;
+  try {
+    if (options.acquireLock !== false) mutationLock = acquireMutationLock(config.projectId);
     opened = await openProject();
     const { socket, project, docs } = opened;
-    const connectedProjectId = String(project?._id ?? config.projectId);
-    if (connectedProjectId !== plan.projectId) {
-      throw new PushPlanValidationError(
-        `Connected project ${connectedProjectId} does not match plan ${plan.projectId}.`
-      );
-    }
-    const docsById = new Map(docs.map((doc) => [doc._id, doc]));
-    for (const planned of plan.documents) {
-      const doc = docsById.get(planned.docId);
-      if (!doc || doc.path !== planned.docPath) {
-        throw new PushPlanValidationError(
-          `Document ${planned.docPath} (${planned.docId}) no longer exists at its planned path.`
-        );
-      }
-    }
-    for (const planned of plan.documents) {
-      await bindPlanDocument(plan, planned, socket, basePath);
-    }
-    receipt = updateReceipt(receipt, "in_progress", {
-      phase: "applying",
-      preflightVerifiedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      ...opts.allowAmbiguousRetry && quarantinedDocuments.length ? {
-        acknowledgedAmbiguousRetry: true,
-        reconciledAmbiguousDocuments: quarantinedDocuments
-      } : {},
-      documents: receiptDocuments
-    });
-    for (let index = 0; index < plan.documents.length; index++) {
-      const planned = plan.documents[index];
-      const { state, expected } = await bindPlanDocument(
-        plan,
-        planned,
-        socket,
-        basePath
-      );
-      receiptDocuments[index] = {
-        ...receiptDocuments[index],
-        status: "applying",
-        mutationAttempted: true,
-        mutationStartedAt: (/* @__PURE__ */ new Date()).toISOString()
-      };
-      receipt = updateReceipt(receipt, "in_progress", {
-        phase: "applying",
-        currentDocument: planned.docPath,
-        documents: receiptDocuments
-      });
-      unknownMutationOutcome = true;
-      let applyError;
-      try {
-        await applyOtUpdateAndWait(socket, planned.docId, {
-          doc: planned.docId,
-          op: planned.ops,
-          v: state.version,
-          meta: plan.direct ? {} : { tc: planned.tcSeed },
-          hash: overleafSnapshotHash(expected)
+    const members = buildMemberMap(project);
+    const threads = await getThreads();
+    const comments = [];
+    const changes = [];
+    for (const doc of docs) {
+      const state = await joinDoc(socket, doc._id);
+      for (const c of state.ranges.comments ?? []) {
+        const line = offsetToLine(state.lines, c.op.p);
+        const thread = threads[c.op.t] ?? {};
+        comments.push({
+          doc: doc.path,
+          threadId: c.op.t,
+          anchor: c.op.c,
+          line: line + 1,
+          context: lineContext(state.lines, line),
+          resolved: Boolean(thread.resolved),
+          messages: (thread.messages ?? []).map((m) => ({
+            id: m.id,
+            author: m.user?.first_name ?? members[m.user_id] ?? m.user_id,
+            email: m.user?.email,
+            content: m.content,
+            timestamp: m.timestamp
+          }))
         });
-      } catch (error) {
-        applyError = error;
-      }
-      let after;
-      try {
-        after = await joinDoc(socket, planned.docId);
-      } catch (readbackError) {
-        const definitelyRejected = Boolean(applyError && definitelyRejectedApply(applyError));
-        failureStatus = definitelyRejected ? "failed" : "ambiguous";
-        unknownMutationOutcome = !definitelyRejected;
-        receiptDocuments[index] = {
-          ...receiptDocuments[index],
-          status: failureStatus,
-          ...applyError ? { transportError: errorMessage(applyError) } : {},
-          error: `Readback failed: ${errorMessage(readbackError)}`
-        };
-        throw new Error(
-          `${planned.docPath} could not be verified after its update: ${errorMessage(readbackError)}`
-        );
-      }
-      const afterText = after.lines.join("\n");
-      if (afterText !== expected || sha256(afterText) !== planned.expectedHash) {
-        const definitelyRejected = Boolean(applyError && definitelyRejectedApply(applyError));
-        failureStatus = definitelyRejected ? "failed" : "ambiguous";
-        unknownMutationOutcome = !definitelyRejected;
-        receiptDocuments[index] = {
-          ...receiptDocuments[index],
-          status: failureStatus,
-          afterVersion: after.version,
-          ...applyError ? { transportError: errorMessage(applyError) } : {},
-          error: "Overleaf text does not match the planned result"
-        };
-        throw new Error(
-          `Verification failed for ${planned.docPath}: Overleaf text does not match the planned result.`
-        );
-      }
-      let trackedChangeIds;
-      try {
-        trackedChangeIds = verifiedTrackedIds(plan, planned, after);
-      } catch (error) {
-        const ambiguousTransport = Boolean(applyError && !definitelyRejectedApply(applyError));
-        unknownMutationOutcome = ambiguousTransport;
-        failureStatus = ambiguousTransport ? "ambiguous" : "failed";
-        receiptDocuments[index] = {
-          ...receiptDocuments[index],
-          status: failureStatus,
-          afterVersion: after.version,
-          ...applyError ? { transportError: errorMessage(applyError) } : {},
-          error: errorMessage(error)
-        };
-        throw error;
       }
-      unknownMutationOutcome = false;
-      try {
-        const localSync = synchronizeLocalAfterRemote(
-          planned.localPath,
-          planned.localHash,
-          afterText
-        );
-        if (localSync.snapshotPath) {
-          receiptDocuments[index] = {
-            ...receiptDocuments[index],
-            localSnapshotPath: localSync.snapshotPath
-          };
-        }
-        const base = {
-          docId: planned.docId,
-          path: planned.docPath,
-          text: afterText,
-          hash: planned.expectedHash,
-          version: after.version,
-          rangeFingerprint: fingerprintRanges(after.ranges),
-          fetchedAt: (/* @__PURE__ */ new Date()).toISOString()
-        };
-        mergeBaseDocuments(plan.projectId, [base], basePath);
-      } catch (error) {
-        failureStatus = "failed";
-        receiptDocuments[index] = {
-          ...receiptDocuments[index],
-          status: "remote_verified_local_failed",
-          afterVersion: after.version,
-          trackedChangeIds,
-          ...applyError ? { transportError: errorMessage(applyError) } : {},
-          error: errorMessage(error)
-        };
-        throw new Error(
-          `${planned.docPath} was verified on Overleaf, but local synchronization failed: ` + errorMessage(error)
-        );
+      for (const ch of state.ranges.changes ?? []) {
+        const isInsert = typeof ch.op.i === "string";
+        const line = offsetToLine(state.lines, ch.op.p);
+        changes.push({
+          doc: doc.path,
+          id: ch.id,
+          type: isInsert ? "insert" : "delete",
+          text: isInsert ? ch.op.i : ch.op.d,
+          line: line + 1,
+          context: lineContext(state.lines, line),
+          author: members[ch.metadata?.user_id] ?? ch.metadata?.user_id ?? "unknown",
+          ts: ch.metadata?.ts
+        });
       }
-      const result = {
-        docId: planned.docId,
-        docPath: planned.docPath,
-        version: after.version,
-        hash: planned.expectedHash,
-        trackedChangeIds
-      };
-      completed.push(result);
-      receiptDocuments[index] = {
-        ...receiptDocuments[index],
-        status: "verified",
-        verifiedAt: (/* @__PURE__ */ new Date()).toISOString(),
-        afterVersion: after.version,
-        trackedChangeIds,
-        ...applyError ? { transportError: errorMessage(applyError) } : {}
-      };
-      receipt = updateReceipt(receipt, "in_progress", {
-        phase: "applying",
-        completedDocuments: completed.map((doc) => doc.docPath),
-        documents: receiptDocuments
-      });
     }
-    receipt = updateReceipt(receipt, "succeeded", {
-      phase: "complete",
-      verifiedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      completedDocuments: completed.map((doc) => doc.docPath),
-      documents: receiptDocuments
-    });
-    return {
-      projectId: plan.projectId,
-      direct: plan.direct,
-      totalOps,
-      documents: completed,
-      receiptPath: receipt.path
+    const data = {
+      project: project?.name ?? "(unknown)",
+      projectId: config.projectId,
+      pulledAt: (/* @__PURE__ */ new Date()).toISOString(),
+      comments,
+      changes
     };
-  } catch (error) {
-    const status = failureStatus ?? (unknownMutationOutcome ? "ambiguous" : "failed");
-    receipt = updateReceipt(receipt, status, {
-      phase: status === "ambiguous" ? "mutation_outcome_unknown" : "failed",
-      failedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      error: errorMessage(error),
-      completedDocuments: completed.map((doc) => doc.docPath),
-      documents: receiptDocuments
-    });
-    throw new PushSubmissionError(
-      `${errorMessage(error)} Audit receipt: ${receipt.path}`,
-      receipt.path,
-      status,
-      receiptDocuments,
-      error
-    );
+    mkdirSync(outDir, { recursive: true });
+    writeFileSync(join(outDir, "reviews.json"), JSON.stringify(data, null, 2) + "\n");
+    writeFileSync(join(outDir, "reviews.md"), renderMarkdown(data));
+    return data;
   } finally {
     try {
       opened?.socket.close();
@@ -2419,76 +142,57 @@ async function submitPlan(planOrPath, opts = {}) {
     }
   }
 }
-function printPlan(plan) {
-  console.log(
-    plan.direct ? "Mode: DIRECT \u2014 plain edits (not marked as suggestions)" : "Mode: SUGGESTIONS \u2014 tracked changes for co-authors to accept/reject"
+function renderMarkdown(d) {
+  const L = [];
+  L.push(`# Overleaf review \u2014 ${d.project}`, "");
+  L.push(`_Pulled ${d.pulledAt} from project \`${d.projectId}\`._`, "");
+  L.push(`**${d.comments.length}** comment(s), **${d.changes.length}** tracked change(s).`, "");
+  L.push(
+    "_Act on these:_ `reply --thread <id> --message <text>` \xB7 `resolve --thread <id>` \xB7 `delete-comment --thread <id>` \xB7 `delete-message --message-id <id>` \xB7 `accept --change <id>` \xB7 `reject --change <id>`.",
+    ""
   );
-  for (const doc of plan.documents) {
-    const ins = doc.ops.filter((op) => op.i != null).length;
-    const del = doc.ops.filter((op) => op.d != null).length;
-    console.log(
-      `
-${doc.localPath} \u2192 ${doc.docPath} (v${doc.liveVersion}): ${doc.ops.length} op(s), ${ins} ins / ${del} del`
-    );
-    if (!plan.direct) {
-      console.log(
-        `  Tracked-range budget: ${doc.activeTrackedRanges.length} existing + ${doc.ops.length} proposed operations / ${MAX_TRACKED_RANGES}. A phrase replacement uses one deletion and one insertion.`
-      );
-    }
-    for (const op of doc.ops.slice(0, 12)) console.log(preview(op));
-    if (doc.ops.length > 12) console.log(`  \u2026 and ${doc.ops.length - 12} more`);
-    for (const overlap of doc.commentOverlaps) {
-      console.log(
-        `  \u2139\uFE0F  touches comment ${overlap.threadId} @ ${overlap.position}: ${JSON.stringify(overlap.anchor)}`
-      );
+  const byDoc = (items) => {
+    const m = /* @__PURE__ */ new Map();
+    for (const it of items) (m.get(it.doc) ?? m.set(it.doc, []).get(it.doc)).push(it);
+    return m;
+  };
+  if (d.comments.length) {
+    L.push("## Comments", "");
+    for (const [doc, items] of byDoc(d.comments)) {
+      L.push(`### ${doc}`, "");
+      for (const c of items) {
+        const flag = c.resolved ? " \u2014 \u2705 resolved" : "";
+        L.push(`#### \u{1F4AC} \u201C${c.anchor}\u201D \xB7 line ${c.line}${flag}`);
+        L.push(`\`thread ${c.threadId}\``);
+        L.push("```", c.context, "```");
+        for (const m of c.messages) {
+          L.push(`- **${m.author}**: ${m.content}  \`msg ${m.id}\``);
+        }
+        if (!c.messages.length) L.push("- _(no message text)_");
+        L.push("");
+      }
     }
   }
-}
-async function push(opts) {
-  validatePushOptions(opts);
-  if (opts.plan) {
-    const result2 = await submitPlan(opts.plan, {
-      basePath: opts.basePath,
-      receiptsDir: opts.receiptsDir,
-      allowAmbiguousRetry: opts.allowAmbiguousRetry
-    });
-    console.log(
-      `\u2705 Submitted and verified ${result2.totalOps} ${result2.direct ? "direct edit(s)" : "tracked suggestion(s)"} across ${result2.documents.length} file(s).`
-    );
-    console.log(`Audit receipt: ${result2.receiptPath}`);
-    return;
-  }
-  const plan = await createPlan(opts);
-  if (!plan.documents.length) {
-    console.log("Nothing to push \u2014 no unapplied local edits were found.");
-    if (opts.planOut) console.log(`Saved empty plan to ${opts.planOut}.`);
-    return;
-  }
-  printPlan(plan);
-  if (opts.planOut) {
-    console.log(`
-Saved binding plan to ${opts.planOut}; nothing sent to Overleaf.`);
-    return;
-  }
-  if (opts.dryRun) {
-    console.log("\n(dry run \u2014 nothing sent to Overleaf)");
-    return;
+  if (d.changes.length) {
+    L.push("## Tracked changes", "");
+    for (const [doc, items] of byDoc(d.changes)) {
+      L.push(`### ${doc}`, "");
+      for (const ch of items) {
+        const verb = ch.type === "insert" ? "inserted" : "deleted";
+        L.push(
+          `- **${verb}** at line ${ch.line} by ${ch.author} \xB7 \`change ${ch.id}\`: \`${ch.text.replace(/\n/g, "\u23CE")}\``
+        );
+        L.push("  ```", ch.context.replace(/^/gm, "  "), "  ```");
+      }
+      L.push("");
+    }
   }
-  const result = await submitPlan(plan, {
-    basePath: opts.basePath,
-    receiptsDir: opts.receiptsDir,
-    allowAmbiguousRetry: opts.allowAmbiguousRetry
-  });
-  console.log(
-    `
-\u2705 Pushed and verified ${result.totalOps} ${result.direct ? "direct edit(s)" : "tracked suggestion(s)"} across ${result.documents.length} file(s).`
-  );
-  console.log(`Audit receipt: ${result.receiptPath}`);
+  return L.join("\n");
 }
 
 // src/commands/fetch.ts
-import { writeFileSync as writeFileSync8, readFileSync as readFileSync7, mkdirSync as mkdirSync8, existsSync as existsSync4 } from "fs";
-import { dirname as dirname6 } from "path";
+import { writeFileSync as writeFileSync2, readFileSync, mkdirSync as mkdirSync2, existsSync } from "fs";
+import { dirname } from "path";
 async function fetchDocs(opts) {
   const { socket, project, docs } = await openProject();
   let mutationLock;
@@ -2523,7 +227,7 @@ async function fetchDocs(opts) {
     for (const { doc, localPath } of localTargets) {
       const state = await joinDoc(socket, doc._id);
       const remote = state.lines.join("\n");
-      const local = existsSync4(localPath) ? readFileSync7(localPath, "utf8") : null;
+      const local = existsSync(localPath) ? readFileSync(localPath, "utf8") : null;
       entries.push({
         doc,
         localPath,
@@ -2549,7 +253,7 @@ async function fetchDocs(opts) {
     if (!opts.dryRun) {
       for (const entry of changedEntries) {
         if (entry.local === null) continue;
-        const current = readFileSync7(entry.localPath, "utf8");
+        const current = readFileSync(entry.localPath, "utf8");
         if (current !== entry.local) {
           throw new Error(`${entry.doc.path} changed while fetch was reading the project; retry fetch.`);
         }
@@ -2560,15 +264,15 @@ async function fetchDocs(opts) {
         snapshotPath: workspaceWritePath(snapshotRelativePath(timestamp, entry.doc.path))
       }));
       for (const { entry, snapshotPath } of snapshotTargets) {
-        mkdirSync8(dirname6(snapshotPath), { recursive: true });
-        writeFileSync8(snapshotPath, entry.local, { mode: 384 });
+        mkdirSync2(dirname(snapshotPath), { recursive: true });
+        writeFileSync2(snapshotPath, entry.local, { mode: 384 });
       }
       if (snapshotTargets.length) {
         snapshotRoot = `${SNAPSHOTS_DIR}/${timestamp}`;
       }
       for (const { localPath, remote } of changedEntries) {
-        mkdirSync8(dirname6(localPath), { recursive: true });
-        writeFileSync8(localPath, remote);
+        mkdirSync2(dirname(localPath), { recursive: true });
+        writeFileSync2(localPath, remote);
       }
     }
     if (!opts.dryRun) mergeBaseDocuments(projectId, entries.map((entry) => entry.base));
@@ -2594,8 +298,8 @@ async function fetchDocs(opts) {
 }
 
 // src/commands/upload.ts
-import { readFileSync as readFileSync8 } from "fs";
-import { basename as basename2 } from "path";
+import { readFileSync as readFileSync2 } from "fs";
+import { basename } from "path";
 function findFolder(folder, wanted, prefix = "") {
   for (const f of folder?.folders ?? []) {
     const path = prefix ? `${prefix}/${f.name}` : f.name;
@@ -2622,8 +326,8 @@ async function upload(paths, folderName) {
     }
     const csrf = await getCsrfToken();
     for (const path of paths) {
-      const bytes = readFileSync8(path);
-      const res = await uploadFile(folderId, basename2(path), bytes, csrf);
+      const bytes = readFileSync2(path);
+      const res = await uploadFile(folderId, basename(path), bytes, csrf);
       console.log(`\u2705 Uploaded ${path} \u2192 ${res.entity_type} ${res.entity_id}`);
     }
   } finally {
@@ -2635,332 +339,8 @@ async function upload(paths, folderName) {
   }
 }
 
-// src/commands/consolidate.ts
-import { readFileSync as readFileSync9 } from "fs";
-
-// src/lib/consolidation.ts
-function checkedSnapshot(value) {
-  const snapshot = value;
-  if (!snapshot || typeof snapshot.projectId !== "string" || !snapshot.projectId || typeof snapshot.docId !== "string" || !snapshot.docId || typeof snapshot.docPath !== "string" || !Number.isSafeInteger(snapshot.version) || snapshot.version < 0 || typeof snapshot.text !== "string" || !Array.isArray(snapshot.ranges?.changes) || !Array.isArray(snapshot.ranges?.comments) || !snapshot.threads || typeof snapshot.threads !== "object" || Array.isArray(snapshot.threads)) throw new Error("Consolidation requires a full document snapshot: projectId, docId, docPath, version, text, ranges and threads.");
-  for (const range of snapshot.ranges.changes) {
-    const op = range?.op;
-    if (typeof range?.id !== "string" || !range.id || !op || !Number.isSafeInteger(op.p) || op.p < 0 || op.p > snapshot.text.length || typeof op.i === "string" === (typeof op.d === "string") || !(op.i ?? op.d)?.length || typeof op.i === "string" && snapshot.text.slice(op.p, op.p + op.i.length) !== op.i) throw new Error("Snapshot contains an invalid or stale tracked range.");
-  }
-  for (const range of snapshot.ranges.comments) {
-    const op = range?.op;
-    if (!op || !Number.isSafeInteger(op.p) || op.p < 0 || op.p > snapshot.text.length || typeof op.c !== "string" || typeof op.t !== "string" || snapshot.text.slice(op.p, op.p + op.c.length) !== op.c) throw new Error("Snapshot contains an invalid or stale comment anchor.");
-  }
-  return snapshot;
-}
-function touches(start, end, range) {
-  return start <= range.end && range.start <= end;
-}
-function protectedRanges(snapshot, selected) {
-  const ranges = [
-    ...snapshot.ranges.changes.filter((range) => !selected.has(range.id)).map((range) => ({
-      start: range.op.p,
-      end: range.op.p + (range.op.i?.length ?? 0),
-      kind: "unselected-change",
-      id: range.id
-    })),
-    ...snapshot.ranges.comments.map((range) => ({
-      start: range.op.p,
-      end: range.op.p + range.op.c.length,
-      kind: "comment",
-      id: range.op.t
-    }))
-  ];
-  return ranges.map((range) => ({ ...range, originalStart: range.start, originalEnd: range.end }));
-}
-function planConsolidation(value, authorId, requestedIds) {
-  const snapshot = structuredClone(checkedSnapshot(value));
-  if (!authorId) throw new Error("Choose the author id whose suggestions should be consolidated.");
-  const selectedIds = [...new Set(requestedIds ?? snapshot.ranges.changes.filter((range) => range.metadata?.user_id === authorId).map((range) => range.id))];
-  if (!selectedIds.length) throw new Error("No tracked changes match the selected author.");
-  const selected = new Set(selectedIds);
-  for (const id of selected) {
-    const fragments = snapshot.ranges.changes.filter((range) => range.id === id);
-    if (!fragments.length) throw new Error(`Tracked change ${id} is absent from the snapshot.`);
-    if (fragments.some((range) => range.metadata?.user_id !== authorId)) {
-      throw new Error(`Tracked change ${id} includes a different or unknown author.`);
-    }
-  }
-  const undo = buildRejectionPlan(snapshot.text, snapshot.ranges.changes, selectedIds);
-  const protectedState = protectedRanges(snapshot, selected);
-  const blockers = [];
-  for (const op of undo.operations) {
-    for (const range of protectedState) {
-      if (touches(op.p, op.p + ("d" in op ? op.d.length : 0), range)) {
-        blockers.push({ kind: range.kind, id: range.id, phase: "undo" });
-      }
-      const offset = "i" in op ? op.i.length : -op.d.length;
-      if (op.p < range.start) {
-        range.start += offset;
-        range.end += offset;
-      }
-    }
-  }
-  const grouping = { protectedSpans: protectedState };
-  const reapply = buildOps(undo.expectedText, snapshot.text, grouping);
-  const footprint = buildOperationFootprint(undo.expectedText, snapshot.text, grouping);
-  for (const edit of footprint) {
-    for (const range of protectedState) {
-      if (touches(edit.start, edit.end, range)) {
-        blockers.push({ kind: range.kind, id: range.id, phase: "reapply" });
-      }
-    }
-  }
-  if (applyOps(undo.expectedText, reapply) !== snapshot.text) {
-    throw new Error("Grouped revisions do not reconstruct the proposed text.");
-  }
-  const newRanges = [];
-  let delta = 0;
-  for (const [index, edit] of footprint.entries()) {
-    const p = edit.start + delta;
-    const deleted = undo.expectedText.slice(edit.start, edit.end);
-    if (edit.text) newRanges.push({ id: `preview-insert-${index}`, op: { p, i: edit.text } });
-    if (deleted) newRanges.push({ id: `preview-delete-${index}`, op: { p: p + edit.text.length, d: deleted } });
-    delta += edit.text.length - deleted.length;
-  }
-  const reconstructed = buildRejectionPlan(snapshot.text, newRanges, newRanges.map((range) => range.id));
-  if (reconstructed.expectedText !== undo.expectedText) {
-    throw new Error("Grouped revisions do not preserve the text beneath the selected suggestions.");
-  }
-  const beforeCount = snapshot.ranges.changes.length;
-  const projectedCount = beforeCount - undo.fragmentCount + reapply.length;
-  const uniqueBlockers = [...new Map(blockers.map((blocker) => [JSON.stringify(blocker), blocker])).values()];
-  return {
-    kind: "overleaf-review-consolidation-plan",
-    schemaVersion: 2,
-    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-    status: uniqueBlockers.length ? "blocked" : projectedCount >= beforeCount ? "no-reduction" : "ready",
-    authorId,
-    selectedIds,
-    beforeCount,
-    selectedFragmentCount: undo.fragmentCount,
-    projectedCount,
-    projectedReduction: beforeCount - projectedCount,
-    blockers: uniqueBlockers,
-    binding: {
-      projectId: snapshot.projectId,
-      docId: snapshot.docId,
-      version: snapshot.version,
-      textHash: sha256(snapshot.text),
-      rangeFingerprint: fingerprintRanges(snapshot.ranges),
-      threadsHash: sha256(stableJson(snapshot.threads))
-    },
-    textProof: {
-      proposedHash: sha256(snapshot.text),
-      selectedRejectedHash: sha256(undo.expectedText),
-      selectedRejectedText: undo.expectedText,
-      forwardVerified: true,
-      reverseVerified: true
-    },
-    candidate: uniqueBlockers.length ? null : { undo: undo.operations, reapply },
-    backup: snapshot,
-    limitations: [
-      "Only review consolidate --apply accepts this artifact; review submit does not.",
-      "Preserves the current pending proposal, not an earlier historical review state.",
-      "Projected count assumes isolated ranges; server transformations need sandbox verification.",
-      "Consolidation would create new change IDs and timestamps for the selected author."
-    ]
-  };
-}
-function validateConsolidationPlan(value) {
-  const plan = value;
-  if (!plan || plan.kind !== "overleaf-review-consolidation-plan" || plan.schemaVersion !== 2 || !Array.isArray(plan.selectedIds) || !plan.selectedIds.every((id) => typeof id === "string") || typeof plan.authorId !== "string" || typeof plan.createdAt !== "string") {
-    throw new Error("Unsupported consolidation plan; create a new plan.");
-  }
-  const expected = planConsolidation(plan.backup, plan.authorId, plan.selectedIds);
-  if (stableJson({ ...plan, createdAt: "" }) !== stableJson({ ...expected, createdAt: "" })) {
-    throw new Error("Consolidation plan was altered or cannot be reproduced from its backup.");
-  }
-  if (plan.status !== "ready" || !plan.candidate || plan.projectedCount > MAX_TRACKED_RANGES) {
-    throw new Error("Consolidation is blocked, does not reduce ranges, or exceeds the range budget.");
-  }
-  rejectedText(plan.backup);
-  return plan;
-}
-function rejectedText(snapshot) {
-  return buildRejectionPlan(
-    snapshot.text,
-    snapshot.ranges.changes,
-    snapshot.ranges.changes.map((range) => range.id)
-  ).expectedText;
-}
-function assertConsolidationBinding(plan, live) {
-  checkedSnapshot(live);
-  if (live.projectId !== plan.backup.projectId || live.docId !== plan.backup.docId || live.docPath !== plan.backup.docPath || live.version !== plan.backup.version || live.text !== plan.backup.text || stableJson(live.ranges) !== stableJson(plan.backup.ranges) || stableJson(live.threads) !== stableJson(plan.backup.threads)) {
-    throw new Error("Document, version, review ranges or threads changed after consolidation planning; re-plan.");
-  }
-}
-function verifyConsolidation(plan, value, seed) {
-  const after = checkedSnapshot(value);
-  const before = plan.backup;
-  if (!/^[0-9a-f]{18}$/.test(seed) || after.projectId !== before.projectId || after.docId !== before.docId || after.docPath !== before.docPath || after.version !== before.version + 1 || after.text !== before.text) {
-    throw new Error("Consolidation text, identity or document version failed verification.");
-  }
-  const selected = new Set(plan.selectedIds);
-  if (after.ranges.changes.some((range) => selected.has(range.id))) throw new Error("Old tracked-change IDs remain after consolidation.");
-  const originalOther = before.ranges.changes.filter((range) => !selected.has(range.id));
-  const otherIds = new Set(originalOther.map((range) => range.id));
-  const actualOther = after.ranges.changes.filter((range) => otherIds.has(range.id));
-  const fresh = after.ranges.changes.filter((range) => !otherIds.has(range.id));
-  const canonical = (ranges) => stableJson(ranges.map((range) => stableJson(range)).sort());
-  if (canonical(originalOther) !== canonical(actualOther) || canonical(before.ranges.comments) !== canonical(after.ranges.comments) || stableJson(before.threads) !== stableJson(after.threads)) {
-    throw new Error("Comments, threads or unselected suggestions changed during consolidation.");
-  }
-  if (fresh.some((range) => !new RegExp(`^${seed}[0-9a-f]{6}$`).test(range.id) || range.metadata?.user_id !== plan.authorId) || after.ranges.changes.length > plan.projectedCount || after.ranges.changes.length >= plan.beforeCount) {
-    throw new Error("Consolidated range count or author attribution failed verification.");
-  }
-  const changeIds = [...new Set(fresh.map((range) => range.id))];
-  if (buildRejectionPlan(after.text, after.ranges.changes, changeIds).expectedText !== plan.textProof.selectedRejectedText || rejectedText(after) !== rejectedText(before)) {
-    throw new Error("Consolidation changed the text beneath pending suggestions.");
-  }
-  return { changeIds, rangeCount: after.ranges.changes.length };
-}
-
-// src/lib/consolidation-submit.ts
-async function submitConsolidation(value, transport) {
-  const plan = validateConsolidationPlan(value);
-  const planHash = sha256(stableJson(plan));
-  const options = { receiptsDir: transport.receiptsDir };
-  const relevant = readReceipts(transport.receiptsDir).filter((handle) => handle.receipt.operation === "consolidate" && handle.receipt.details.projectId === plan.binding.projectId && handle.receipt.details.docId === plan.binding.docId);
-  const uncertain = relevant.find((handle) => handle.receipt.status === "ambiguous" || handle.receipt.status === "in_progress");
-  if (uncertain) {
-    throw new Error(`Earlier consolidation has an uncertain outcome. Inspect and reconcile ${uncertain.path}; no automatic retry was sent.`);
-  }
-  const prior = relevant.find((handle) => handle.receipt.status === "succeeded" && handle.receipt.details.planHash === planHash);
-  if (prior) return { receiptPath: prior.path, alreadyApplied: true };
-  let receipt = beginReceipt("consolidate", {
-    projectId: plan.binding.projectId,
-    docId: plan.binding.docId,
-    docPath: plan.backup.docPath,
-    planHash,
-    plan,
-    phase: "preflight"
-  }, options);
-  let attempted = false;
-  try {
-    if (await transport.accountId() !== plan.authorId) {
-      throw new Error("Consolidation can only reapply suggestions belonging to the authenticated account.");
-    }
-    const before = await transport.snapshot();
-    assertConsolidationBinding(plan, before);
-    const seed = createTrackedChangeSeed();
-    if (before.ranges.changes.some((range) => range.id.startsWith(seed))) {
-      throw new Error("Tracked-change seed collision; create a fresh consolidation attempt.");
-    }
-    const update = {
-      doc: before.docId,
-      v: before.version,
-      op: [...plan.candidate.undo, ...plan.candidate.reapply],
-      meta: { tc: seed },
-      hash: overleafSnapshotHash(before.text)
-    };
-    receipt = updateReceipt(receipt, "in_progress", {
-      phase: "sending",
-      before,
-      seed,
-      update,
-      mutationStartedAt: (/* @__PURE__ */ new Date()).toISOString()
-    });
-    attempted = true;
-    await transport.send(update);
-    const after = await transport.snapshot();
-    receipt = updateReceipt(receipt, "in_progress", { phase: "verifying", after });
-    const result = verifyConsolidation(plan, after, seed);
-    receipt = updateReceipt(receipt, "succeeded", { phase: "complete", result });
-    return { receiptPath: receipt.path, alreadyApplied: false, ...result };
-  } catch (error) {
-    receipt = updateReceipt(receipt, attempted ? "ambiguous" : "failed", {
-      phase: attempted ? "outcome_unknown" : "preflight_failed",
-      error: error instanceof Error ? error.message : String(error)
-    });
-    throw new Error(`${error instanceof Error ? error.message : String(error)}. Receipt: ${receipt.path}. ` + (attempted ? "Do not retry or auto-rollback; inspect live review state and the saved backup first." : "Nothing sent."), { cause: error });
-  }
-}
-
-// src/commands/consolidate.ts
-async function readConsolidationSnapshot(opened, doc) {
-  if (String(opened.project?._id) !== config.projectId) throw new Error("Connected project identity could not be verified.");
-  const before = await joinDoc(opened.socket, doc._id);
-  const threads = await getThreads();
-  const after = await joinDoc(opened.socket, doc._id);
-  const afterThreads = await getThreads();
-  if (before.version !== after.version || before.lines.join("\n") !== after.lines.join("\n") || stableJson(before.ranges) !== stableJson(after.ranges) || stableJson(threads) !== stableJson(afterThreads)) {
-    throw new Error("The document or review state changed during snapshot capture.");
-  }
-  return {
-    projectId: config.projectId,
-    docId: doc._id,
-    docPath: doc.path,
-    version: after.version,
-    text: after.lines.join("\n"),
-    ranges: { changes: after.ranges.changes ?? [], comments: after.ranges.comments ?? [] },
-    threads: afterThreads
-  };
-}
-async function consolidateApply(path) {
-  const plan = validateConsolidationPlan(JSON.parse(readFileSync9(workspaceReadPath(path), "utf8")));
-  if (config.projectId !== plan.binding.projectId) throw new Error("Consolidation plan belongs to a different project.");
-  const lock = acquireMutationLock(config.projectId);
-  let opened;
-  try {
-    opened = await openProject();
-    const project = opened;
-    const doc = project.docs.find((doc2) => doc2._id === plan.binding.docId && doc2.path === plan.backup.docPath);
-    if (!doc) throw new Error("Planned consolidation document is absent or renamed.");
-    const result = await submitConsolidation(plan, {
-      accountId: getAuthenticatedUserId,
-      snapshot: () => readConsolidationSnapshot(project, doc),
-      send: (update) => applyOtUpdateAndWait(project.socket, doc._id, update)
-    });
-    console.log(result.alreadyApplied ? "This consolidation plan was already applied; nothing resent." : `Verified consolidation: ${plan.beforeCount} \u2192 ${result.rangeCount} tracked ranges. Both text views and protected review state preserved.`);
-    console.log(`Audit receipt and backup: ${result.receiptPath}`);
-  } finally {
-    try {
-      opened?.socket.close();
-    } finally {
-      lock.release();
-    }
-  }
-}
-async function consolidatePreview(options) {
-  let snapshot;
-  if (options.snapshot) {
-    snapshot = JSON.parse(readFileSync9(workspaceReadPath(options.snapshot), "utf8"));
-  } else {
-    if (!options.doc) throw new Error("Consolidation requires --doc or --snapshot.");
-    const projectId = config.projectId;
-    const lock = acquireMutationLock(projectId);
-    let opened;
-    try {
-      opened = await openProject();
-      const doc = matchDocument(options.doc, opened.docs);
-      if (!doc) throw new Error(`Document not found: ${options.doc}`);
-      snapshot = await readConsolidationSnapshot(opened, doc);
-    } finally {
-      try {
-        opened?.socket.close();
-      } finally {
-        lock.release();
-      }
-    }
-  }
-  const plan = planConsolidation(snapshot, options.author, options.changeIds);
-  writeJsonAtomic(workspaceWritePath(options.out), plan);
-  console.log(`Consolidation dry run for ${snapshot.docPath}: ${plan.status}`);
-  console.log(`Tracked ranges: ${plan.beforeCount} \u2192 ${plan.projectedCount} projected (${plan.selectedFragmentCount} selected).`);
-  for (const blocker of plan.blockers) {
-    console.log(`  Blocked by ${blocker.kind} ${blocker.id} during ${blocker.phase}.`);
-  }
-  console.log(`Full backup and text proofs saved to ${options.out}.`);
-  console.log("Nothing sent to Overleaf. Inspect the plan before review consolidate --apply --plan <file>.");
-}
-
 // src/commands/comment.ts
-import { createHash as createHash4, randomBytes as randomBytes2 } from "crypto";
+import { createHash, randomBytes } from "crypto";
 var DEFAULT_DUPLICATE_WINDOW_MS = 5 * 60 * 1e3;
 function isRecentAttempt(prior, nowMs, windowMs) {
   const updatedAt = prior.updatedAt ? Date.parse(prior.updatedAt) : Number.NaN;
@@ -3001,7 +381,7 @@ function commentIntentHash(intent) {
     intent.occurrence,
     intent.message
   ];
-  return createHash4("sha256").update(JSON.stringify(canonical)).digest("hex");
+  return createHash("sha256").update(JSON.stringify(canonical)).digest("hex");
 }
 function rangeThreadId(range) {
   const value = range?.op?.t;
@@ -3023,7 +403,7 @@ function threadSnapshot(thread) {
     messageIds: messages.map(threadMessageId).filter((id) => Boolean(id))
   };
 }
-function errorMessage2(error) {
+function errorMessage(error) {
   return error instanceof Error ? error.message : String(error);
 }
 function priorThreadIdForIntent(intentHash, receiptsDir) {
@@ -3154,7 +534,7 @@ async function commentWithResult(opts) {
     const canResume = Boolean(
       priorRange && prior.threadId && threadMessages(threads[prior.threadId]).length === 0
     );
-    const threadId = canResume ? prior.threadId : randomBytes2(12).toString("hex");
+    const threadId = canResume ? prior.threadId : randomBytes(12).toString("hex");
     let anchorCreated = false;
     let beforeThread = threads[threadId];
     receipt = beginReceipt(
@@ -3203,8 +583,8 @@ async function commentWithResult(opts) {
       } catch (readbackError) {
         receipt = updateReceipt(receipt, "ambiguous", {
           phase: "anchor_outcome_unknown",
-          ...anchorError ? { transportError: errorMessage2(anchorError) } : {},
-          verificationError: errorMessage2(readbackError)
+          ...anchorError ? { transportError: errorMessage(anchorError) } : {},
+          verificationError: errorMessage(readbackError)
         });
         throw new Error(
           `Comment anchor outcome is ambiguous; inspect ${receipt.path} before retrying`
@@ -3213,7 +593,7 @@ async function commentWithResult(opts) {
       if (!commentRangeAnchorsText(verifiedRange, afterAnchorText ?? "", opts.anchor)) {
         receipt = updateReceipt(receipt, anchorError ? "ambiguous" : "failed", {
           phase: anchorError ? "anchor_outcome_unknown" : "anchor_unverified",
-          ...anchorError ? { transportError: errorMessage2(anchorError) } : {},
+          ...anchorError ? { transportError: errorMessage(anchorError) } : {},
           anchorRange: rangeSnapshot(verifiedRange)
         });
         throw new Error(
@@ -3225,7 +605,7 @@ async function commentWithResult(opts) {
         phase: "anchor_verified",
         anchorVerifiedAt: (/* @__PURE__ */ new Date()).toISOString(),
         anchorRange: rangeSnapshot(verifiedRange),
-        ...anchorError ? { transportError: errorMessage2(anchorError) } : {}
+        ...anchorError ? { transportError: errorMessage(anchorError) } : {}
       });
     } else {
       receipt = updateReceipt(receipt, "in_progress", {
@@ -3274,7 +654,7 @@ async function commentWithResult(opts) {
       receipt = updateReceipt(receipt, definitelyRejected ? "failed" : "ambiguous", {
         phase: !postAttempted ? "message_preflight_failed" : definitelyRejected ? "message_rejected" : "message_outcome_unknown",
         anchorRange: rangeSnapshot(verifiedRange),
-        ...postError ? { error: errorMessage2(postError) } : {},
+        ...postError ? { error: errorMessage(postError) } : {},
         ...postError instanceof RestRequestError ? { responseStatus: postError.status, responseBody: postError.responseBody } : responseStatus ? { responseStatus } : {},
         verificationAttempts: observed.attempts,
         ...observed.lastError ? { verificationError: observed.lastError } : {},
@@ -3296,7 +676,7 @@ async function commentWithResult(opts) {
         phase: "final_anchor_verification_failed",
         messageId: observedMessageId,
         messageVerifiedAt: (/* @__PURE__ */ new Date()).toISOString(),
-        verificationError: errorMessage2(error)
+        verificationError: errorMessage(error)
       });
       throw new Error(
         `Comment message exists, but its anchor could not be rechecked. Inspect ${receipt.path}`
@@ -3318,7 +698,7 @@ async function commentWithResult(opts) {
       verificationAttempts: observed.attempts,
       finalAnchorRange: rangeSnapshot(finalRange),
       afterThread: threadSnapshot(observed.thread),
-      ...postError ? { transportError: errorMessage2(postError) } : {},
+      ...postError ? { transportError: errorMessage(postError) } : {},
       ...observedMessageId ? { messageId: observedMessageId } : {}
     });
     return {
@@ -3334,7 +714,7 @@ async function commentWithResult(opts) {
     if (receipt && receipt.receipt.status !== "failed" && receipt.receipt.status !== "ambiguous" && receipt.receipt.status !== "skipped" && receipt.receipt.status !== "succeeded") {
       receipt = updateReceipt(receipt, "failed", {
         phase: "command_failed",
-        error: errorMessage2(error)
+        error: errorMessage(error)
       });
     }
     throw error;
@@ -3361,7 +741,7 @@ async function comment(opts) {
 
 // src/commands/reply.ts
 var DEFAULT_DUPLICATE_WINDOW_MS2 = 5 * 60 * 1e3;
-function errorMessage3(error) {
+function errorMessage2(error) {
   return error instanceof Error ? error.message : String(error);
 }
 function threadSnapshot2(thread) {
@@ -3515,7 +895,7 @@ async function replyWithResult(threadId, message, options = {}) {
         receipt = updateReceipt(receipt, "succeeded", {
           phase: "complete",
           outcome: "verified_after_transport_error",
-          transportError: errorMessage3(error),
+          transportError: errorMessage2(error),
           ...responseStatus ? { responseStatus } : {},
           verificationAttempts: observed.attempts,
           verifiedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -3533,7 +913,7 @@ async function replyWithResult(threadId, message, options = {}) {
       const definitelyRejected = error instanceof RestRequestError && error.status < 500;
       receipt = updateReceipt(receipt, definitelyRejected ? "failed" : "ambiguous", {
         phase: definitelyRejected ? "message_rejected" : "message_outcome_unknown",
-        error: errorMessage3(error),
+        error: errorMessage2(error),
         ...error instanceof RestRequestError ? { responseStatus: error.status, responseBody: error.responseBody } : {},
         verificationAttempts: observed.attempts,
         ...observed.lastError ? { verificationError: observed.lastError } : {},
@@ -3541,13 +921,13 @@ async function replyWithResult(threadId, message, options = {}) {
       });
       const qualification = definitelyRejected ? "failed" : "has an ambiguous outcome";
       throw new Error(
-        `Reply to thread ${threadId} ${qualification}: ${errorMessage3(error)}. Receipt: ${receipt.path}`
+        `Reply to thread ${threadId} ${qualification}: ${errorMessage2(error)}. Receipt: ${receipt.path}`
       );
     }
     if (receipt.receipt.status !== "ambiguous" && receipt.receipt.status !== "failed" && receipt.receipt.status !== "skipped" && receipt.receipt.status !== "succeeded") {
       receipt = updateReceipt(receipt, "failed", {
         phase: "preflight_failed",
-        error: errorMessage3(error)
+        error: errorMessage2(error)
       });
     }
     throw error;
@@ -3569,7 +949,7 @@ async function reply(threadId, message, options = {}) {
 }
 
 // src/commands/resolve.ts
-async function resolve2(threadId, reopen = false) {
+async function resolve(threadId, reopen = false) {
   const mutationLock = acquireMutationLock(config.projectId);
   let socket;
   try {
@@ -3671,13 +1051,13 @@ async function verifyAcceptedDocument(socket, docId, changeIds) {
       lastError = error;
     }
     if (attempt + 1 < VERIFY_ATTEMPTS) {
-      await new Promise((resolve3) => setTimeout(resolve3, VERIFY_INTERVAL_MS));
+      await new Promise((resolve2) => setTimeout(resolve2, VERIFY_INTERVAL_MS));
     }
   }
   if (!last) throw lastError ?? new Error(`could not read back document ${docId}`);
   return last;
 }
-function errorMessage4(error) {
+function errorMessage3(error) {
   return error instanceof Error ? error.message : String(error);
 }
 async function accept(changeIds) {
@@ -3732,7 +1112,7 @@ async function accept(changeIds) {
       csrf = await getCsrfToken();
     } catch (error) {
       throw new TrackedChangeMutationError(
-        `Could not obtain a CSRF token before accepting tracked changes: ${errorMessage4(error)}`,
+        `Could not obtain a CSRF token before accepting tracked changes: ${errorMessage3(error)}`,
         result,
         error
       );
@@ -3750,7 +1130,7 @@ async function accept(changeIds) {
           fragmentCount: 0,
           status: "failed",
           remainingIds: ids,
-          error: errorMessage4(error)
+          error: errorMessage3(error)
         };
         result.documents.push(outcome2);
         refreshVerifiedIds();
@@ -3810,14 +1190,14 @@ async function accept(changeIds) {
       }
       if (after && !outcome.remainingIds.length) {
         outcome.status = "verified";
-        if (mutationError) outcome.error = `transport warning: ${errorMessage4(mutationError)}`;
+        if (mutationError) outcome.error = `transport warning: ${errorMessage3(mutationError)}`;
         verifiedDocs.add(doc._id);
         refreshVerifiedIds();
         continue;
       }
       const reasons = [];
-      if (mutationError) reasons.push(errorMessage4(mutationError));
-      if (readbackError) reasons.push(`readback failed: ${errorMessage4(readbackError)}`);
+      if (mutationError) reasons.push(errorMessage3(mutationError));
+      if (readbackError) reasons.push(`readback failed: ${errorMessage3(readbackError)}`);
       if (outcome.remainingIds.length) {
         reasons.push(`change ids still present: ${outcome.remainingIds.join(", ")}`);
       }
@@ -3868,13 +1248,13 @@ async function verifyRejectedDocument(socket, docId, changeIds, expectedText) {
       lastError = error;
     }
     if (attempt + 1 < VERIFY_ATTEMPTS2) {
-      await new Promise((resolve3) => setTimeout(resolve3, VERIFY_INTERVAL_MS2));
+      await new Promise((resolve2) => setTimeout(resolve2, VERIFY_INTERVAL_MS2));
     }
   }
   if (!last) throw lastError ?? new Error(`could not read back document ${docId}`);
   return last;
 }
-function errorMessage5(error) {
+function errorMessage4(error) {
   return error instanceof Error ? error.message : String(error);
 }
 async function reject(changeIds) {
@@ -3937,7 +1317,7 @@ async function reject(changeIds) {
           fragmentCount: 0,
           status: "failed",
           remainingIds: ids,
-          error: errorMessage5(error)
+          error: errorMessage4(error)
         };
         result.documents.push(outcome2);
         refreshVerifiedIds();
@@ -3978,12 +1358,12 @@ async function reject(changeIds) {
           beforeVersion: before.version,
           status: "failed",
           remainingIds: presentIds,
-          error: errorMessage5(error)
+          error: errorMessage4(error)
         };
         result.documents.push(outcome2);
         refreshVerifiedIds();
         throw new TrackedChangeMutationError(
-          `Could not safely plan rejection in ${doc.path}: ${errorMessage5(error)}`,
+          `Could not safely plan rejection in ${doc.path}: ${errorMessage4(error)}`,
           result,
           error
         );
@@ -4026,14 +1406,14 @@ async function reject(changeIds) {
       }
       if (after && !outcome.remainingIds.length && outcome.textVerified) {
         outcome.status = "verified";
-        if (mutationError) outcome.error = `transport warning: ${errorMessage5(mutationError)}`;
+        if (mutationError) outcome.error = `transport warning: ${errorMessage4(mutationError)}`;
         verifiedDocs.add(doc._id);
         refreshVerifiedIds();
         continue;
       }
       const reasons = [];
-      if (mutationError) reasons.push(errorMessage5(mutationError));
-      if (readbackError) reasons.push(`readback failed: ${errorMessage5(readbackError)}`);
+      if (mutationError) reasons.push(errorMessage4(mutationError));
+      if (readbackError) reasons.push(`readback failed: ${errorMessage4(readbackError)}`);
       if (outcome.remainingIds.length) {
         reasons.push(`change ids still present: ${outcome.remainingIds.join(", ")}`);
       }
@@ -4155,6 +1535,7 @@ function usage() {
   console.log("  review start [--file <f>] [--out <dir>]   Fetch text/base, then pull review data");
   console.log("  review plan --out <plan.json> [options]   Save a complete binding push plan");
   console.log("       --file <f> --edits <blocks.json>     Preserve explicit before/after blocks");
+  console.log("       Blocks with supersedes/comments/reason approve specific reviewed overlaps");
   console.log("  review submit --plan <plan.json>          Validate, apply, and verify that plan");
   console.log("       [--acknowledge-ambiguous]             Continue only after manual reconciliation\n");
   console.log("  review consolidate --doc <path> --author <user-id> --out <preview.json>");
@@ -4297,6 +1678,9 @@ async function main() {
         if (!out) fail("review plan requires --out <plan.json>");
         await push({ ...pushOptions(), plan: void 0, planOut: out, dryRun: true });
       } else if (reviewCommand === "submit") {
+        if (process.argv.slice(4).some((arg) => arg.startsWith("--") && !["--plan", "--acknowledge-ambiguous"].includes(arg))) {
+          fail("review submit accepts only --plan (and --acknowledge-ambiguous for ordinary push plans). Use review plan for a dry run.");
+        }
         const plan = getFlag("plan");
         if (!plan) fail("review submit requires --plan <plan.json>");
         await push({
@@ -4355,7 +1739,7 @@ async function main() {
     case "resolve": {
       const thread = getFlag("thread");
       if (!thread) fail("resolve requires --thread <id>");
-      await resolve2(thread, process.argv.includes("--reopen"));
+      await resolve(thread, process.argv.includes("--reopen"));
       break;
     }
     case "delete-comment": {