overleaf-review 0.6.1 → 0.7.0

package/README.md

@@ -136,6 +136,9 @@ first safe push. If an upgraded repository already has unpushed edits, copy or s
 | `push [--file <f>] [--doc <name>] [--direct] [--dry-run] [--plan-out <path>] [--plan <path>] [--allow-overlap] [--unsafe-no-base] [--acknowledge-ambiguous]` | Safely merge and send local edits (all changed `.tex` if no `--file`) |
 | `comment --anchor <text> --message <text> [--doc <name>] [--nth <n>] [--force]` | Add an anchored comment; recent identical retries are skipped unless forced |
 | `reply --thread <id> --message <text> [--force]` | Reply to a thread; recent identical retries are skipped unless forced |
+| `edit-message --thread <id> --message-id <id> --before <text> --message <text> --out <plan.json>` | Plan an in-place edit of your own existing message; sends nothing |
+| `edit-message --manifest <edits.json> --out <plan.json>` | Preview a batch of exact before/after message edits |
+| `edit-message --plan <plan.json>` | Apply the saved message-edit plan with readback and per-message receipts |
 | `resolve --thread <id> [--reopen]` | Resolve (or reopen) a comment thread |
 | `delete-comment --thread <id>` | Delete a whole comment thread |
 | `delete-message --message-id <id> [--thread <id>]` | Delete a single message within a thread |
@@ -144,6 +147,70 @@ first safe push. If an upgraded repository already has unpushed edits, copy or s
 
 Thread and change ids are listed by `pull` (in `.overleaf/reviews.md`).
 
+### Editing existing replies in place (v0.7.0)
+
+Use `edit-message` for correcting your own existing comments or replies without deleting and
+reposting them. This uses Overleaf's native edit endpoint: message IDs, authorship and original
+posting times stay intact; Overleaf may add/update `edited_at`. It sends no manuscript operations,
+does not move comment anchors, and does not resolve/reopen threads. Other authors' messages cannot
+be edited. A material change to an answer someone has already responded to may be clearer as a
+new follow-up message instead.
+
+For one message, supply its exact current text and proposed replacement:
+
+```sh
+overleaf-review edit-message --thread <thread-id> --message-id <message-id> \
+  --before 'Original reply.' --message 'Corrected reply.' --out message-plan.json
+overleaf-review edit-message --plan message-plan.json
+```
+
+For longer replies or batches, prepare `message-edits.json` using exact IDs from `reviews.json`:
+
+```json
+{
+  "edits": [
+    {
+      "threadId": "0123456789abcdef01234567",
+      "messageId": "0123456789abcdef01234568",
+      "before": "Original reply.",
+      "after": "Corrected reply.\nA second paragraph, if needed."
+    }
+  ]
+}
+```
+
+```sh
+overleaf-review edit-message --manifest message-edits.json --out message-plan.json
+# Inspect all before/after edits before applying:
+overleaf-review edit-message --plan message-plan.json
+```
+
+Planning is read-only on Overleaf. It binds the server, project, authenticated author, exact
+message IDs/text and full targeted threads. All targets are checked before the first write and
+again before each subsequent write. Changes to a targeted thread—including new replies, edits,
+or resolution changes—stop the batch; activity in unrelated threads does not block it. Apply
+accepts only the saved plan, without content overrides or a force flag.
+
+Every edit is verified by reading back the same message ID and replacement content, with unchanged
+authorship, posting time, other messages and thread metadata. A receipt in `.overleaf/receipts/`
+retains the plan's complete original threads, before/after text, and per-message progress.
+
+Batches are sequential, **not atomic**. If a later request is definitively rejected, resubmitting
+the same plan rechecks all targets and resumes without repeating verified edits. A lost response
+is recovered only when exact readback proves the intended result. If the outcome stays uncertain,
+there is no blind resend, rollback, or delete-and-repost fallback; even a different plan targeting
+that thread is blocked until the original attempt is reconciled. Keep the original plan/receipts.
+
+Use a quiet editing window: the native endpoint has no expected-content/version condition, so the
+preflight cannot prevent an edit racing between the last read and the POST. Verification detects
+observable discrepancies but cannot undo an already-sent overwrite or prove that no transient
+concurrent edit was overwritten. No server-side compare-and-swap or atomic batch is claimed.
+
+`npm run probe:message-edit-live -- --project <test-id> --confirm-test-project` is an opt-in live
+check using the built CLI. It creates a new scratch document, posts and edits two test replies,
+verifies retry behavior, and checks that existing documents and threads were unchanged. Never
+run this probe against a manuscript project.
+
 ### Safe pushes
 
 A normal push compares three versions of each document:
@@ -339,6 +406,17 @@ project, verifies consolidation and protected review state, and checks that exis
 were unchanged. It does not require or spoof another account. Foreign-author preservation is also
 covered by the upstream model check. Never run this probe against a manuscript project.
 
+From v0.6.2, rejection and underlying-text reconstruction account for insertions and deletions
+at the same position, including multiple co-located deletions. The undo first restores selected
+deletions, then removes insertions at their adjusted positions; exact-text and range verification
+remain mandatory. Recreate unsubmitted plans from a fresh snapshot after upgrading, since the
+operation ordering has changed. Do not re-plan to bypass an uncertain earlier submission.
+
+`npm run probe:rejection-model` checks this ordering against pinned upstream range logic in both
+tracking modes, including consolidation and reviewed paragraph rewrites. Add `-- --backup <file>`
+to check a saved full snapshot (or a plan containing `backup`) offline. The backup stays local;
+the probe fetches only public upstream code and never connects to an Overleaf project.
+
 ### Push overrides and submission
 
 Use `--allow-overlap` only after inspecting those tracked changes. `--unsafe-no-base` is a deliberate

package/dist/{chunk-JRXROCS6.js → chunk-3VDCWUZ7.js}

@@ -509,6 +509,25 @@ async function uploadFile(folderId, name, bytes, csrf) {
   if (!res.ok) throw new Error(`upload ${res.status}: ${(await res.text()).slice(0, 200)}`);
   return res.json();
 }
+async function editThreadMessage(threadId, messageId, content, csrf) {
+  if (![threadId, messageId].every((id) => /^[0-9a-f]{24}$/i.test(id)) || typeof content !== "string" || !content.trim()) {
+    throw new Error("Message editing requires valid thread/message IDs and nonempty content.");
+  }
+  const res = await fetch(
+    `${config.baseUrl}/project/${config.projectId}/thread/${threadId}/messages/${messageId}/edit`,
+    {
+      method: "POST",
+      headers: headers({ "Content-Type": "application/json", "X-CSRF-Token": csrf }),
+      body: JSON.stringify({ content }),
+      redirect: "error",
+      signal: AbortSignal.timeout(15e3)
+    }
+  );
+  if (!res.ok) {
+    const body = await res.text();
+    throw new RestRequestError(`editThreadMessage ${res.status}: ${body.slice(0, 300)}`, res.status, body.slice(0, 1e3));
+  }
+}
 async function deleteMessage(threadId, messageId, csrf) {
   const res = await fetch(
     `${config.baseUrl}/project/${config.projectId}/thread/${threadId}/messages/${messageId}`,
@@ -1285,17 +1304,26 @@ function applyUndo(text, op, changeId) {
 }
 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 fragments = ranges.map((range, index) => ({ range, index })).filter(({ range }) => requested.has(range.id)).map((fragment) => ({ ...fragment, inverse: inverseOf(fragment.range) }));
+  fragments.sort((a, b) => Number(b.range.op.d !== void 0) - Number(a.range.op.d !== void 0) || b.range.op.p - a.range.op.p || a.index - b.index);
+  const restorations = fragments.filter((fragment) => "i" in fragment.inverse);
   const operations = [];
   let expectedText = currentText;
-  for (const range of fragments) {
-    const inverse = inverseOf(range);
+  let restorePosition = -1;
+  let restoredAtPosition = 0;
+  for (const { range, inverse: originalInverse } of fragments) {
+    if ("i" in originalInverse && originalInverse.p !== restorePosition) {
+      restorePosition = originalInverse.p;
+      restoredAtPosition = 0;
+    }
+    const shift = "d" in originalInverse ? restorations.reduce((sum, restored) => sum + (restored.range.op.p <= range.op.p ? restored.range.op.d.length : 0), 0) : restoredAtPosition;
+    const inverse = { ...originalInverse, p: originalInverse.p + shift };
     expectedText = applyUndo(expectedText, inverse, range.id);
     operations.push(inverse);
+    if ("i" in inverse) restoredAtPosition += inverse.i.length;
   }
   return {
-    changeIds: changeIdsInRanges(fragments),
+    changeIds: changeIdsInRanges(fragments.map((fragment) => fragment.range)),
     fragmentCount: fragments.length,
     operations,
     expectedText
@@ -2299,7 +2327,7 @@ ${doc.localPath} \u2192 ${doc.docPath} (v${doc.liveVersion}): ${doc.ops.length}
 }
 async function push(opts) {
   validatePushOptions(opts);
-  const { isReviewedManifest, createReviewedFilePlan, applyReviewedFilePlan, REVIEWED_FILE_KIND } = await import("./reviewed-replace-4PCULETF.js");
+  const { isReviewedManifest, createReviewedFilePlan, applyReviewedFilePlan, REVIEWED_FILE_KIND } = await import("./reviewed-replace-QOIDOJGV.js");
   if (opts.edits && isReviewedManifest(JSON.parse(readFileSync6(workspaceReadPath(opts.edits), "utf8")))) {
     await createReviewedFilePlan(opts);
     return;
@@ -2688,6 +2716,7 @@ export {
   setThreadResolved,
   acceptChanges,
   uploadFile,
+  editThreadMessage,
   deleteMessage,
   deleteThread,
   validateSession,

package/dist/cli.js

@@ -13,8 +13,10 @@ import {
   consolidatePreview,
   deleteMessage,
   deleteThread,
+  editThreadMessage,
   findRecentIdenticalMessage,
   fingerprintRanges,
+  getAuthenticatedUserId,
   getCsrfToken,
   getThreads,
   joinDoc,
@@ -32,14 +34,17 @@ import {
   sha256,
   snapshotRelativePath,
   snapshotTimestamp,
+  stableJson,
   threadMessageId,
   threadMessages,
   uniqueChangeIds,
   updateReceipt,
   uploadFile,
   validateSession,
-  workspaceWritePath
-} from "./chunk-JRXROCS6.js";
+  workspaceReadPath,
+  workspaceWritePath,
+  writeJsonAtomic
+} from "./chunk-3VDCWUZ7.js";
 
 // src/commands/pull.ts
 import { writeFileSync, mkdirSync } from "fs";
@@ -948,6 +953,248 @@ async function reply(threadId, message, options = {}) {
   }
 }
 
+// src/commands/edit-message.ts
+import { readFileSync as readFileSync3 } from "fs";
+
+// src/lib/message-edit.ts
+var MESSAGE_EDIT_KIND = "overleaf-review-message-edit-plan";
+var idPattern = /^[0-9a-f]{24}$/i;
+function messageAuthor(message) {
+  const user = message.user;
+  const ids = [message.user_id, user?.id, user?._id].filter((id) => id !== void 0);
+  if (new Set(ids).size > 1) throw new Error("Conflicting message author IDs.");
+  return ids[0];
+}
+function parseMessageEdits(value) {
+  const manifest = value;
+  if (!manifest || Object.keys(manifest).some((key) => key !== "edits") || !Array.isArray(manifest.edits) || !manifest.edits.length) {
+    throw new Error("Message edit manifest requires only a nonempty edits array.");
+  }
+  const seen = /* @__PURE__ */ new Set();
+  return manifest.edits.map((edit) => {
+    if (!edit || Object.keys(edit).some((key) => !["threadId", "messageId", "before", "after"].includes(key)) || !idPattern.test(edit.threadId) || !idPattern.test(edit.messageId) || typeof edit.before !== "string" || typeof edit.after !== "string" || !edit.after.trim() || edit.before === edit.after || seen.has(edit.messageId)) throw new Error("Each edit needs unique exact IDs, before text, and different nonempty after text.");
+    seen.add(edit.messageId);
+    return { threadId: edit.threadId, messageId: edit.messageId, before: edit.before, after: edit.after };
+  });
+}
+function checkedThread(value, threadId) {
+  const thread = value;
+  if (!thread || typeof thread !== "object" || Array.isArray(thread) || !Array.isArray(thread.messages)) throw new Error(`Thread ${threadId} is absent or invalid.`);
+  const ids = /* @__PURE__ */ new Set();
+  for (const message of thread.messages) {
+    const id = threadMessageId(message);
+    if (!message || !id || !idPattern.test(id) || typeof message.content !== "string" || ids.has(id) || message.id !== void 0 && message._id !== void 0 && message.id !== message._id) throw new Error(`Thread ${threadId} contains invalid or duplicate message IDs.`);
+    ids.add(id);
+  }
+  return structuredClone(thread);
+}
+function createMessageEditPlan(baseUrl, projectId, authorId, allThreads, input) {
+  if (!idPattern.test(projectId) || !idPattern.test(authorId) || !/^https?:\/\//.test(baseUrl) || new URL(baseUrl).origin !== baseUrl) throw new Error("Message edit plan requires exact server origin, project and authenticated author IDs.");
+  const edits = parseMessageEdits(input);
+  const threads = {};
+  for (const edit of edits) {
+    const thread = threads[edit.threadId] ??= checkedThread(allThreads[edit.threadId], edit.threadId);
+    const message = thread.messages.find((message2) => threadMessageId(message2) === edit.messageId);
+    if (!message) throw new Error(`Message ${edit.messageId} is absent from thread ${edit.threadId}.`);
+    if (messageAuthor(message) !== authorId) throw new Error(`Message ${edit.messageId} is not owned by the authenticated account.`);
+    if (message.content !== edit.before) throw new Error(`Message ${edit.messageId} differs from the expected before text; refresh and re-plan.`);
+  }
+  return { kind: MESSAGE_EDIT_KIND, schemaVersion: 1, baseUrl, projectId, authorId, edits, threads };
+}
+function validateMessageEditPlan(value) {
+  const plan = value;
+  if (!plan || plan.kind !== MESSAGE_EDIT_KIND || plan.schemaVersion !== 1 || !plan.threads) throw new Error("Invalid message-edit plan.");
+  const expected = createMessageEditPlan(plan.baseUrl, plan.projectId, plan.authorId, plan.threads, { edits: plan.edits });
+  if (stableJson(plan) !== stableJson(expected)) throw new Error("Message-edit plan is malformed or inconsistent.");
+  return plan;
+}
+function expectedThreads(plan, progress) {
+  const threads = structuredClone(plan.threads);
+  progress.forEach((item, index) => {
+    if (item.status === "verified") {
+      if (!item.observed) throw new Error("Verified edit has no saved readback; inspect receipt.");
+      const edit = plan.edits[index];
+      const messages = threads[edit.threadId].messages;
+      const target = messages.findIndex((message) => threadMessageId(message) === edit.messageId);
+      assertEditedMessage(messages[target], item.observed, edit);
+      messages[target] = structuredClone(item.observed);
+    }
+  });
+  return threads;
+}
+function assertEditedMessage(original, observed, edit) {
+  if (observed.edited_at !== void 0 && !(typeof observed.edited_at === "number" && Number.isFinite(observed.edited_at) && observed.edited_at > 0) && !(typeof observed.edited_at === "string" && Number.isFinite(Date.parse(observed.edited_at)))) throw new Error("Invalid edited_at on message readback.");
+  const allowed = { ...original, content: edit.after };
+  if (observed.edited_at === void 0) delete allowed.edited_at;
+  else allowed.edited_at = observed.edited_at;
+  if (stableJson(allowed) !== stableJson(observed)) throw new Error(`Edited message ${edit.messageId} identity, author, timestamp or content failed verification.`);
+}
+function assertThreads(expected, live) {
+  for (const [id, thread] of Object.entries(expected)) {
+    if (stableJson(checkedThread(live[id], id)) !== stableJson(thread)) {
+      throw new Error(`Thread ${id} or one of its messages changed; no further edits sent.`);
+    }
+  }
+}
+function editedReadback(expected, live, edit) {
+  const thread = checkedThread(live[edit.threadId], edit.threadId);
+  const message = thread.messages.find((message2) => threadMessageId(message2) === edit.messageId);
+  if (!message || message.content !== edit.after) throw new Error(`Edited message ${edit.messageId} not visible on readback.`);
+  const allowed = structuredClone(expected);
+  const index = allowed[edit.threadId].messages.findIndex((candidate) => threadMessageId(candidate) === edit.messageId);
+  assertEditedMessage(allowed[edit.threadId].messages[index], message, edit);
+  allowed[edit.threadId].messages[index] = message;
+  assertThreads(allowed, live);
+  return message;
+}
+async function submitMessageEditPlan(value, transport) {
+  const plan = validateMessageEditPlan(value);
+  if (transport.baseUrl !== plan.baseUrl || transport.projectId !== plan.projectId || await transport.accountId() !== plan.authorId) {
+    throw new Error("Message-edit server, project or authenticated account differs from the plan.");
+  }
+  const planHash = sha256(stableJson(plan));
+  const history = readReceipts(transport.receiptsDir).filter((handle) => handle.receipt.operation === "edit-message" && handle.receipt.details.baseUrl === plan.baseUrl && handle.receipt.details.projectId === plan.projectId);
+  const conflict = history.find((handle) => handle.receipt.details.planHash !== planHash && handle.receipt.details.progress?.some((item, index) => item.status === "sending" && plan.edits.some((edit) => edit.threadId === handle.receipt.details.plan?.edits[index]?.threadId)));
+  if (conflict) throw new Error(`An earlier edit has an uncertain outcome: ${conflict.path}. Reconcile that plan first.`);
+  const prior = history.find((handle) => handle.receipt.details.planHash === planHash);
+  if (prior && stableJson(prior.receipt.details.plan) !== stableJson(plan)) throw new Error(`Receipt plan mismatch; inspect ${prior.path}.`);
+  let receipt = prior ?? beginReceipt("edit-message", {
+    baseUrl: plan.baseUrl,
+    projectId: plan.projectId,
+    authorId: plan.authorId,
+    planHash,
+    plan,
+    progress: plan.edits.map(() => ({ status: "pending" }))
+  }, { receiptsDir: transport.receiptsDir });
+  const progress = structuredClone(receipt.receipt.details.progress);
+  if (!Array.isArray(progress) || progress.length !== plan.edits.length || progress.some((item) => !item || !["pending", "sending", "verified", "failed"].includes(item.status))) throw new Error(`Invalid edit progress; inspect ${receipt.path}.`);
+  const alreadyApplied = receipt.receipt.status === "succeeded";
+  let expected = expectedThreads(plan, progress);
+  const verify = async (edit) => {
+    let error;
+    const attempts = Math.max(1, Math.min(20, transport.verificationAttempts ?? 3));
+    for (let i = 0; i < attempts; i++) {
+      try {
+        return editedReadback(expected, await transport.threads(), edit);
+      } catch (e) {
+        error = e;
+      }
+      if (i + 1 < attempts) await new Promise((resolve2) => setTimeout(resolve2, transport.verificationIntervalMs ?? 200));
+    }
+    throw error;
+  };
+  try {
+    for (const [index, item] of progress.entries()) {
+      if (item.status !== "sending") continue;
+      item.observed = await verify(plan.edits[index]);
+      item.status = "verified";
+      receipt = updateReceipt(receipt, "in_progress", { progress });
+      expected = expectedThreads(plan, progress);
+    }
+    assertThreads(expected, await transport.threads());
+    for (const [index, edit] of plan.edits.entries()) {
+      const item = progress[index];
+      if (item.status === "verified") continue;
+      assertThreads(expected, await transport.threads());
+      item.status = "sending";
+      receipt = updateReceipt(receipt, "in_progress", { progress, phase: "editing", currentMessageId: edit.messageId });
+      let sendError;
+      try {
+        await transport.edit(edit);
+      } catch (error) {
+        sendError = error;
+      }
+      try {
+        item.observed = await verify(edit);
+      } catch (error) {
+        if (sendError instanceof RestRequestError && sendError.status >= 400 && sendError.status < 500 && sendError.status !== 408) {
+          item.status = "failed";
+        }
+        throw sendError ?? error;
+      }
+      item.status = "verified";
+      receipt = updateReceipt(receipt, "in_progress", { progress, ...sendError ? { recoveredTransportError: String(sendError) } : {} });
+      expected = expectedThreads(plan, progress);
+    }
+    assertThreads(expected, await transport.threads());
+    receipt = updateReceipt(receipt, "succeeded", { progress, phase: "complete", verifiedAt: (/* @__PURE__ */ new Date()).toISOString() });
+    return { receiptPath: receipt.path, alreadyApplied, verifiedCount: progress.filter((item) => item.status === "verified").length };
+  } catch (error) {
+    receipt = updateReceipt(receipt, progress.some((item) => item.status === "sending") ? "ambiguous" : "failed", {
+      progress,
+      phase: "stopped",
+      error: error instanceof Error ? error.message : String(error)
+    });
+    throw new Error(`${error instanceof Error ? error.message : String(error)} Inspect receipt: ${receipt.path}. No automatic rollback or blind retry.`, { cause: error });
+  }
+}
+
+// src/commands/edit-message.ts
+function parseEditMessageArgs(args) {
+  const allowed = ["--thread", "--message-id", "--before", "--message", "--manifest", "--out", "--plan"];
+  const flags = {};
+  for (let i = 0; i < args.length; i += 2) {
+    const key = args[i];
+    const value = args[i + 1];
+    if (!allowed.includes(key) || Object.hasOwn(flags, key) || value === void 0 || value.startsWith("--")) {
+      throw new Error("Invalid edit-message arguments: only explicit planning flags or --plan <file> are supported; no force/delete fallback.");
+    }
+    flags[key] = value;
+  }
+  if (Object.hasOwn(flags, "--plan")) {
+    if (Object.keys(flags).length !== 1 || !flags["--plan"]) throw new Error("Apply accepts only --plan <file>; no overrides.");
+    return { plan: flags["--plan"] };
+  }
+  if (!flags["--out"]) throw new Error("Plan first: edit-message requires --out <plan.json>; apply separately with --plan.");
+  if (Object.hasOwn(flags, "--manifest")) {
+    if (Object.keys(flags).length !== 2 || !flags["--manifest"]) throw new Error("Batch planning accepts only --manifest <file> --out <plan.json>.");
+    return { manifest: flags["--manifest"], out: flags["--out"] };
+  }
+  if (Object.keys(flags).length !== 5 || !["--thread", "--message-id", "--before", "--message"].every((key) => Object.hasOwn(flags, key))) {
+    throw new Error("Single-message planning requires --thread, --message-id, --before, --message and --out.");
+  }
+  return { out: flags["--out"], edits: { edits: [{ threadId: flags["--thread"], messageId: flags["--message-id"], before: flags["--before"], after: flags["--message"] }] } };
+}
+async function editMessageCommand(args) {
+  const options = parseEditMessageArgs(args);
+  const lock = acquireMutationLock(config.projectId);
+  try {
+    if ("plan" in options) {
+      const plan = validateMessageEditPlan(JSON.parse(readFileSync3(workspaceReadPath(options.plan), "utf8")));
+      if (plan.baseUrl !== config.baseUrl || plan.projectId !== config.projectId) throw new Error("Message edit plan belongs to another server or project.");
+      const csrf = await getCsrfToken();
+      const result = await submitMessageEditPlan(plan, {
+        baseUrl: config.baseUrl,
+        projectId: config.projectId,
+        accountId: getAuthenticatedUserId,
+        threads: getThreads,
+        edit: (edit) => editThreadMessage(edit.threadId, edit.messageId, edit.after, csrf)
+      });
+      console.log(`${result.alreadyApplied ? "Already completed; nothing resent." : "Verified in-place edits."} ${result.verifiedCount} message(s).`);
+      console.log(`Before/after audit receipt: ${result.receiptPath}`);
+    } else {
+      const inputPath = options.manifest ? workspaceReadPath(options.manifest) : void 0;
+      const outputPath = workspaceWritePath(options.out);
+      if (inputPath === outputPath) throw new Error("Plan output must not overwrite its input manifest.");
+      const edits = parseMessageEdits(inputPath ? JSON.parse(readFileSync3(inputPath, "utf8")) : options.edits);
+      const authorId = await getAuthenticatedUserId();
+      const plan = createMessageEditPlan(config.baseUrl, config.projectId, authorId, await getThreads(), { edits });
+      writeJsonAtomic(outputPath, plan);
+      console.log(`Message-edit plan saved to ${options.out}; nothing sent.`);
+      for (const edit of plan.edits) {
+        console.log(`
+Thread ${edit.threadId}, message ${edit.messageId}
+  Before: ${JSON.stringify(edit.before)}
+  After:  ${JSON.stringify(edit.after)}`);
+      }
+      console.log("Native in-place edits only. No manuscript, anchors, thread resolution, deletion or reposting.");
+      console.log("Apply during a quiet editing window; a batch is sequential, not atomic.");
+    }
+  } finally {
+    lock.release();
+  }
+}
+
 // src/commands/resolve.ts
 async function resolve(threadId, reopen = false) {
   const mutationLock = acquireMutationLock(config.projectId);
@@ -1547,6 +1794,9 @@ function usage() {
   console.log("Comments:");
   console.log("  comment --anchor <text> --message <text> [--doc <name>] [--nth <n>] [--force]");
   console.log("  reply --thread <id> --message <text> [--force]");
+  console.log("  edit-message --thread <id> --message-id <id> --before <text> --message <text> --out <plan.json>");
+  console.log("       --manifest <edits.json> --out <plan.json>  Plan a batch instead");
+  console.log("  edit-message --plan <plan.json>           Apply verified in-place edits");
   console.log("  resolve --thread <id> [--reopen]          Resolve/reopen a thread");
   console.log("  delete-comment --thread <id>              Delete a whole thread");
   console.log("  delete-message --message-id <id>          Delete a single message\n");
@@ -1736,6 +1986,9 @@ async function main() {
       await reply(thread, message, { force: process.argv.includes("--force") });
       break;
     }
+    case "edit-message":
+      await editMessageCommand(process.argv.slice(3));
+      break;
     case "resolve": {
       const thread = getFlag("thread");
       if (!thread) fail("resolve requires --thread <id>");

package/dist/{reviewed-replace-4PCULETF.js → reviewed-replace-QOIDOJGV.js}

@@ -34,7 +34,7 @@ import {
   workspaceRelativePath,
   workspaceWritePath,
   writeJsonAtomic
-} from "./chunk-JRXROCS6.js";
+} from "./chunk-3VDCWUZ7.js";
 
 // src/commands/reviewed-replace.ts
 import { readFileSync } from "fs";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "overleaf-review",
-  "version": "0.6.1",
+  "version": "0.7.0",
   "description": "The missing review layer for Overleaf's Git bridge — sync comments and tracked changes between Overleaf and your local repo.",
   "type": "module",
   "license": "MIT",
@@ -44,6 +44,8 @@
     "probe:review-live": "tsx src/probes/05-review-live.ts",
     "probe:reviewed-model": "tsx src/probes/06-reviewed-model.ts",
     "probe:reviewed-live": "tsx src/probes/07-reviewed-live.ts",
+    "probe:rejection-model": "tsx src/probes/08-rejection-model.ts",
+    "probe:message-edit-live": "tsx src/probes/09-message-edit-live.ts",
     "typecheck": "tsc --noEmit",
     "test": "tsx --test test/*.test.ts",
     "check": "npm run typecheck && npm test && npm run build"