papilot 0.7.0 → 0.8.1

package/vendor/latex-review/src/core/changes.ts

@@ -1,5 +1,6 @@
 import { Repo, within } from "./git.ts";
 import { groups, opcodes } from "./diff.ts";
+import { entrySpans } from "./bib.ts";
 import type { Scope, Unit, Op } from "../types.ts";
 export const EXCERPT = 6000;
 export function textOf(data: Buffer | null): string | null {
@@ -34,6 +35,8 @@ export function diffUnits(
     const left = binary ? [] : splitLines(a!),
       right = binary ? [] : splitLines(b!);
     let hunks = binary ? [] : groups(opcodes(left, right));
+    if (!binary && file.endsWith(".bib"))
+      hunks = byEntry(hunks, entrySpans(a!), entrySpans(b!));
     const whole =
       binary || status !== "modified" || isFigure(file) || !hunks.length;
     if (whole) hunks = [[["replace", 0, left.length, 0, right.length]]];
@@ -61,6 +64,42 @@ export function diffUnits(
   }
   return units;
 }
+// A bibliography entry is decided whole: hunks that touch the same entry,
+// before or after, or the same key on either side, become one change, so
+// accepting part of an entry cannot mix its old and new fields.
+export function byEntry(
+  hunks: Op[][],
+  before: { key: string; span: [number, number] }[],
+  after: { key: string; span: [number, number] }[],
+) {
+  // An empty range touches an entry it falls strictly inside.
+  const touches = ([a, b]: [number, number], [s, e]: [number, number]) =>
+    a === b ? s < a && a < e : a < e && s < b;
+  const root = hunks.map((_, i) => i),
+    find = (i: number): number => (root[i] === i ? i : (root[i] = find(root[i]))),
+    owner = new Map<string, number>();
+  hunks.forEach((hunk, i) => {
+    const old: [number, number] = [hunk[0][1], hunk.at(-1)![2]],
+      next: [number, number] = [hunk[0][3], hunk.at(-1)![4]],
+      keys = [
+        ...before.filter((e) => touches(old, e.span)).map((e) => e.key),
+        ...after.filter((e) => touches(next, e.span)).map((e) => e.key),
+      ];
+    for (const key of keys) {
+      const j = owner.get(key);
+      if (j === undefined) owner.set(key, i);
+      else root[find(i)] = find(j);
+    }
+  });
+  const merged = new Map<number, Op[]>();
+  hunks.forEach((hunk, i) => {
+    const r = find(i);
+    merged.set(r, [...(merged.get(r) ?? []), ...hunk]);
+  });
+  return [...merged.values()].map((ops) =>
+    ops.sort((p, q) => p[1] - q[1] || p[3] - q[3]),
+  );
+}
 function edits(units: Unit[], index: 1 | 3): Op[] {
   return units.flatMap((u) => u.ops).sort((a, b) => b[index] - a[index]);
 }

package/vendor/latex-review/src/core/current-commit.ts

@@ -0,0 +1,104 @@
+import fs from "node:fs";
+import { createHash } from "node:crypto";
+import os from "node:os";
+import path from "node:path";
+import type { Repo } from "./git.ts";
+import { merge3 } from "./git.ts";
+import type { Delivery } from "../types.ts";
+
+export interface CombinedCommitReview { token: string; files: string[]; diff: string }
+export class CommitNeedsReview extends Error {
+  constructor(public review: CombinedCommitReview) { super("Earlier edits to the same passages need to be included. Review the combined commit or apply without committing."); }
+}
+
+// Project only the task delta onto HEAD. The worktree and staging area are
+// separate destinations: neither is used as the content of the commit.
+export function planCurrentCommit(repo: Repo, data: Delivery, before: string, files: string[], message: string, confirmation?: string) {
+  const ref = repo.text(["symbolic-ref", "-q", "HEAD"], { check: false });
+  if (!ref.startsWith("refs/heads/")) throw new Error("Open a branch to commit this task, or apply it without committing.");
+  const parent = repo.rev("HEAD"), index = repo.text(["write-tree"]);
+  const base = repo.blobs(before, files), accepted = repo.blobs(data.accepted, files), head = repo.blobs(parent, files), staged = repo.blobs(index, files);
+  const committed: Record<string, Buffer | null> = {}, nextIndex: Record<string, Buffer | null> = {};
+  const dependencies: string[] = [];
+  for (const file of files) {
+    let [content, conflict] = merge3(head[file], base[file], accepted[file]);
+    if (conflict) {
+      // Include only the overlapping earlier passages, never the whole dirty
+      // file. This is a proposal until the author confirms its exact diff.
+      [content, conflict] = merge3(accepted[file], base[file], head[file], true);
+      if (conflict) throw new Error(`The earlier changes in ${file} cannot be included automatically. Apply to workspace to save your reviewed result without a commit.`);
+      dependencies.push(file);
+    }
+    let [combined, indexConflict] = merge3(staged[file], head[file], content);
+    if (indexConflict && dependencies.includes(file) && !merge3(staged[file], base[file], accepted[file])[1])
+      [combined, indexConflict] = merge3(content, head[file], staged[file], true);
+    if (indexConflict) throw new Error(`A different version of ${file} is already selected for another commit. Apply to workspace to save this result without changing that selection.`);
+    committed[file] = content;
+    nextIndex[file] = combined;
+  }
+  const tree = repo.treeWith(parent, committed);
+  if (tree === repo.treeId(parent)) throw new Error("These changes are already in the current commit. Apply without committing to finish this task.");
+  if (dependencies.length || confirmation) {
+    const token = createHash("sha256").update(JSON.stringify([ref, parent, index, before, data.accepted, tree, data.writes])).digest("hex");
+    if (confirmation !== token) {
+      const diff = repo.text(["diff", "--no-ext-diff", "--no-textconv", parent, tree, "--"]);
+      if (diff.length > 500000) throw new Error("The combined changes are too large to preview here. Apply to workspace and review them in Git before committing.");
+      throw new CommitNeedsReview({ token, files: dependencies, diff });
+    }
+  }
+  data.branch = ref.slice("refs/heads/".length);
+  data.parent = parent;
+  data.indexBefore = index;
+  data.indexAfter = repo.treeWith(index, nextIndex);
+  data.commit = repo.text(["commit-tree", tree, "-p", parent, "-m", message.trim()]);
+}
+
+// Hold Git's index lock while checking and installing the recorded result.
+// CAS on the branch prevents updating the wrong or concurrently moved HEAD.
+// A retry recognizes our commit and completes its files/index without a
+// duplicate commit. Unrelated staged entries (including their flags) survive.
+export function finishCurrentCommit(repo: Repo, data: Delivery, validateFiles: () => void, writeFiles: () => void) {
+  const index = path.resolve(repo.root, repo.text(["rev-parse", "--git-path", "index"]));
+  const lock = index + ".lock";
+  let fd: number;
+  try { fd = fs.openSync(lock, "wx", fs.existsSync(index) ? fs.statSync(index).mode & 0o777 : 0o644); }
+  catch (error) {
+    if ((error as NodeJS.ErrnoException).code === "EEXIST") throw new Error("Another Git operation is using the staging area. Wait for it to finish, then retry.");
+    throw error;
+  }
+  let temp: string | undefined;
+  try {
+    temp = fs.mkdtempSync(path.join(os.tmpdir(), "papilot-task-index-"));
+    const ref = `refs/heads/${data.branch}`;
+    if (repo.text(["symbolic-ref", "-q", "HEAD"], { check: false }) !== ref)
+      throw new Error("The current branch changed. Return to the original branch before retrying this task commit.");
+    const head = repo.rev("HEAD");
+    if (head !== data.parent && head !== data.commit)
+      throw new Error("The current branch moved during this task commit. Nothing else was changed; inspect the Git history before retrying.");
+    const target = path.join(temp, "index");
+    fs.copyFileSync(index, target);
+    const env = { ...process.env, GIT_INDEX_FILE: target };
+    const currentIndex = repo.text(["write-tree"], { env });
+    if (currentIndex !== data.indexBefore && currentIndex !== data.indexAfter)
+      throw new Error("The staged changes changed during this task commit. Nothing else was changed; restore the previous staging selection before retrying.");
+    validateFiles();
+    if (currentIndex !== data.indexAfter) {
+      const changed = repo.changedFiles(data.indexBefore!, data.indexAfter!);
+      for (const file of changed) {
+        const blob = repo.blob(data.indexAfter!, file);
+        if (blob === null) repo.run(["update-index", "--force-remove", "--", file], { env });
+        else repo.run(["update-index", "--add", "--cacheinfo", `${repo.mode(data.indexAfter!, file)},${repo.hashObject(blob)},${file}`], { env });
+      }
+    }
+    if (repo.text(["write-tree"], { env }) !== data.indexAfter) throw new Error("Could not prepare the task's staging result.");
+    fs.writeFileSync(fd, fs.readFileSync(target));
+    fs.fsyncSync(fd);
+    if (head !== data.commit) repo.run(["update-ref", "-m", "Papilot: commit reviewed task", ref, data.commit!, data.parent!]);
+    writeFiles();
+    fs.renameSync(lock, index);
+  } finally {
+    fs.closeSync(fd);
+    fs.rmSync(lock, { force: true });
+    if (temp) fs.rmSync(temp, { recursive: true, force: true });
+  }
+}

package/vendor/latex-review/src/core/delivery.ts

@@ -4,8 +4,11 @@ import type { App } from "../server.ts";
 import type { Delivery } from "../types.ts";
 import { merge3 } from "./git.ts";
 import { readBytes, same, writeOrDelete } from "./files.ts";
+import { planCurrentCommit, finishCurrentCommit, CommitNeedsReview } from "./current-commit.ts";
 import { safePath } from "./review.ts";
 
+class DeliveryConflict extends Error {}
+
 const encode = (data: Buffer | null) => data?.toString("base64") ?? null;
 const decode = (data: string | null) => data === null ? null : Buffer.from(data, "base64");
 
@@ -24,16 +27,50 @@ export class Deliveries {
     const last = this.get(name);
     if (last && !last.done) throw new Error("Finish the pending delivery before changing this review. Retry the same destination.");
   }
-  deliver(name: string, mode: Delivery["mode"], message = "") {
+  apply(name: string, keepCurrent = false, mode?: "workspace" | "commit", message?: string, confirmation?: string) {
+    const active = this.app.reconciliation.get(name);
+    mode ??= active?.intent?.mode ?? "workspace";
+    message ??= active?.intent?.message ?? "";
+    if (mode !== "workspace" && mode !== "commit") throw new Error("Choose a task commit or apply without committing.");
+    if (mode === "commit" && (!message.trim() || message.length > 5000)) throw new Error("Write a commit message (at most 5,000 characters).");
+    const last = this.get(name);
+    if (last && !last.done) {
+      const delivery = this.finish(name, last);
+      if (last.mode !== "branch") return { delivery };
+    }
+    if (keepCurrent) {
+      const task = this.app.tasks.get(name);
+      if (!active?.ready || task.accepted !== active.reviewBase || this.app.repo.changedFiles(task.accepted, this.app.tasks.snapshot(task)).length)
+        throw new Error("Review the merge suggestion before applying it, or ask the agent to keep the latest wording.");
+    }
+    if (active) this.app.reconciliation.intent(name, { mode, message });
+    if (!keepCurrent && active && (!active.ready || (this.app.review.latestRound(name)?.number ?? 0) <= active.round))
+      return { reconciliation: this.app.reconciliation.prepare(name, this.app.reconciliation.get(name)!) };
+    try { return { delivery: this.deliver(name, mode, message, keepCurrent, confirmation) }; }
+    catch (error) {
+      if (error instanceof CommitNeedsReview) return { commitReview: error.review };
+      if (!(error instanceof DeliveryConflict)) throw error;
+      const reconciliation = this.app.reconciliation.start(name, keepCurrent, { mode, message });
+      if (reconciliation) return { reconciliation };
+      return { delivery: this.deliver(name, mode, message, keepCurrent, confirmation) };
+    }
+  }
+  deliver(name: string, mode: Delivery["mode"], message = "", keepCurrent = false, confirmation?: string) {
     const app = this.app, task = app.tasks.get(name), last = this.get(name);
     if (!task.deferred) throw new Error("This task already applies accepted changes to the manuscript.");
-    if (mode !== "workspace" && mode !== "branch") throw new Error("Choose a working directory or task branch.");
-    if (last && last.mode !== mode) throw new Error("Continue using this task's original destination, or start a new task.");
-    if (last && (!last.done || last.accepted === task.accepted)) return this.finish(name, last);
+    if (mode !== "workspace" && mode !== "commit" && mode !== "branch") throw new Error("Choose a working directory or task branch.");
+    const reconciliation = app.reconciliation.get(name);
+    if (reconciliation && (!reconciliation.ready || mode === "branch" || (!keepCurrent && (app.review.latestRound(name)?.number ?? 0) <= reconciliation.round)))
+      throw new Error("Review the merge suggestion before applying it to the manuscript.");
+    // Older task-branch commits remain available, but can now be applied
+    // through the same manuscript action. Never move or merge those branches.
+    if (last && last.mode !== mode && (!last.done || mode === "branch"))
+      throw new Error("Finish the pending delivery before applying to the manuscript.");
+    if (last && last.mode === mode && (!last.done || (!reconciliation && last.accepted === task.accepted))) return this.finish(name, last);
     if (app.publisher.busy(name) || app.review.counts(name).pending) throw new Error("Finish reviewing every change before choosing a destination.");
-    const before = last?.accepted ?? task.base;
+    const before = reconciliation?.base ?? (last && last.mode !== "branch" ? last.accepted : task.base);
     const files = app.repo.changedFiles(before, task.accepted);
-    if (!files.length) throw new Error("This task has no accepted changes left to deliver.");
+    if (!files.length && !reconciliation) throw new Error("This task has no accepted changes left to deliver.");
     const base = app.repo.blobs(before, files), accepted = app.repo.blobs(task.accepted, files);
     const data: Delivery = { mode, accepted: task.accepted, seq: app.store.one<{ seq: number }>("SELECT MAX(seq) AS seq FROM actions WHERE task=?", name)!.seq, done: false, writes: [] };
     const contents: Record<string, Buffer | null> = {};
@@ -55,14 +92,16 @@ export class Deliveries {
     }
     for (const file of files) {
       const [merged, conflict] = merge3(current[file], base[file], accepted[file]);
-      if (conflict) throw new Error(`Cannot deliver ${file}: it conflicts with the destination. Nothing was written. Revise the task and try again.`);
+      if (conflict) throw new DeliveryConflict(`Cannot deliver ${file}: it conflicts with the destination. Nothing was written. Revise the task and try again.`);
       contents[file] = merged;
-      if (mode === "workspace" && !same(current[file], merged)) data.writes.push({ file, before: encode(current[file]), after: encode(merged) });
+      if (mode !== "branch" && !same(current[file], merged)) data.writes.push({ file, before: encode(current[file]), after: encode(merged) });
     }
     if (mode === "branch") {
       const tree = app.repo.treeWith(data.parent!, contents);
       data.commit = app.repo.text(["commit-tree", tree, "-p", data.parent!, "-m", message.trim()]);
     }
+    if (mode === "commit" && (!message.trim() || message.length > 5000)) throw new Error("Write a commit message (at most 5,000 characters).");
+    if (mode === "commit") planCurrentCommit(app.repo, data, before, files, message, confirmation);
     this.save(name, data);
     return this.finish(name, data);
   }
@@ -75,7 +114,7 @@ export class Deliveries {
       throw new Error("Finish or abort the merge before applying changes.");
   }
   finish(name: string, data: Delivery) {
-    if (data.done) return this.result(data);
+    if (data.done) { if (data.mode !== "branch") this.app.reconciliation.clear(name); return this.result(data); }
     const app = this.app;
     if (data.mode === "branch") {
       const ref = `refs/heads/${data.branch}`;
@@ -87,14 +126,19 @@ export class Deliveries {
     } else {
       this.assertNoMerge();
       const writes = data.writes.map(write => ({ ...write, target: safePath(app.root, write.file) }));
-      for (const write of writes) {
-        const current = readBytes(write.target);
-        if (!same(current, decode(write.before)) && !same(current, decode(write.after)))
-          throw new Error(`Cannot finish delivery: ${write.file} changed. Restore it to its state before delivery and retry.`);
-      }
-      for (const write of writes) writeOrDelete(write.target, decode(write.after));
+      const validate = () => {
+        for (const write of writes) {
+          const current = readBytes(write.target);
+          if (!same(current, decode(write.before)) && !same(current, decode(write.after)))
+            throw new Error(`Cannot finish delivery: ${write.file} changed. Restore it to its state before delivery and retry.`);
+        }
+      };
+      const applyFiles = () => { for (const write of writes) writeOrDelete(write.target, decode(write.after)); };
+      if (data.mode === "commit") finishCurrentCommit(app.repo, data, validate, applyFiles);
+      else { validate(); applyFiles(); }
     }
     this.save(name, { ...data, done: true, writes: [] });
+    if (data.mode !== "branch") this.app.reconciliation.clear(name);
     return this.result(data);
   }
   result(data: Delivery) {
@@ -103,7 +147,9 @@ export class Deliveries {
   }
   recover() {
     for (const row of this.app.store.all<{ task: string; data: Delivery }>("SELECT * FROM deliveries")) {
-      if (!row.data.done) try { this.finish(row.task, row.data); } catch { /* Retain the journal for an explicit retry. */ }
+      if (row.data.done && row.data.mode !== "branch" && this.app.reconciliation.get(row.task) && this.app.tasks.get(row.task).accepted === row.data.accepted)
+        this.app.reconciliation.clear(row.task);
+      else if (!row.data.done) try { this.finish(row.task, row.data); } catch { /* Retain the journal for an explicit retry. */ }
     }
   }
 }

package/vendor/latex-review/src/core/git.ts

@@ -297,6 +297,7 @@ export function merge3(
   ours: Buffer | null,
   base: Buffer | null,
   theirs: Buffer | null,
+  favorCurrent = false,
 ): [Buffer | null, boolean] {
   if (same(ours, base) || same(ours, theirs)) return [theirs, false];
   if (same(theirs, base)) return [ours, false];
@@ -312,7 +313,7 @@ export function merge3(
       path.join(folder, name),
     );
     [ours, base, theirs].forEach((data, i) => fs.writeFileSync(files[i], data));
-    const result = run(gitBinary(), ["merge-file", "-p", ...files], {
+    const result = run(gitBinary(), ["merge-file", "-p", ...(favorCurrent ? ["--ours"] : []), ...files], {
       check: false,
     });
     return [result.stdout, result.status !== 0];

package/vendor/latex-review/src/core/publish.ts

@@ -321,6 +321,7 @@ export class Publisher {
     const app = this.app,
       name = job.task,
       project = app.project;
+    if (app.reconciliation.get(name)?.ready === false) throw new Error("Retry applying to finish preparing the merge review.");
     let task = app.tasks.get(name);
     if (!fs.existsSync(task.worktree))
       throw new PublishError(
@@ -335,13 +336,18 @@ export class Publisher {
       latest = app.review.latestRound(name),
       decided = app.review.lastChange(name),
       violations = scopeViolations(app.repo, task.base, after, task.scope);
+    const reconciliation = app.reconciliation.get(name);
+    if (reconciliation) {
+      for (const file of app.repo.changedFiles(task.base, after))
+        if (!reconciliation.files.includes(file) && !violations.includes(file)) violations.push(file);
+    }
     if (violations.length)
       throw new PublishError(
         "Some edits are outside the task scope: " +
           violations.slice(0, 10).join(", "),
         [
           "Allowed: " +
-            (task.scope.sections.length
+            (reconciliation ? reconciliation.files : task.scope.sections.length
               ? task.scope.sections.map((s) => `${s.number} ${s.title}`)
               : task.scope.paths
             ).join(", "),

package/vendor/latex-review/src/core/reconcile.ts

@@ -0,0 +1,101 @@
+import { randomUUID } from "node:crypto";
+import type { App } from "../server.ts";
+import { merge3 } from "./git.ts";
+import { readBytes, same, writeOrDelete } from "./files.ts";
+import { safePath } from "./review.ts";
+import { GENERATED, revisionReader } from "./tasks.ts";
+import { buildOutline, resolveSections, selectedRanges } from "./outline.ts";
+
+export interface Reconciliation {
+  id: string;
+  round: number;
+  files: string[];
+  sourceBase: string;
+  sourceAccepted: string;
+  base: string;
+  reviewBase: string;
+  worktreeBefore: string;
+  ready: boolean;
+  intent?: { mode: "workspace" | "commit"; message: string };
+}
+
+// A conflict is another proposal in the same task. The manuscript and its
+// index stay untouched; only the private proposal is rebased for PDF review.
+export class Reconciliations {
+  constructor(public app: App) {}
+  get(name: string) {
+    return this.app.store.one<{ data: Reconciliation }>("SELECT data FROM reconciliations WHERE task=?", name)?.data;
+  }
+  intent(name: string, intent: NonNullable<Reconciliation["intent"]>) {
+    const data = { ...this.get(name)!, intent };
+    this.app.store.execute("UPDATE reconciliations SET data=? WHERE task=?", JSON.stringify(data), name);
+    return data;
+  }
+  clear(name: string) {
+    this.app.store.execute("DELETE FROM reconciliations WHERE task=?", name);
+  }
+  start(name: string, force = false, intent?: Reconciliation["intent"]) {
+    const app = this.app, task = app.tasks.get(name), previous = this.get(name);
+    if (previous && (!previous.ready || (!force && (app.review.latestRound(name)?.number ?? 0) <= previous.round)))
+      return this.prepare(name, previous);
+    const worktreeBefore = app.tasks.snapshot(task);
+    if (app.repo.changedFiles(task.accepted, worktreeBefore).length)
+      throw new Error("Review the latest task edits before applying the manuscript changes.");
+    const delivered = app.delivery.get(name);
+    const sourceBase = previous?.base ?? (delivered && delivered.mode !== "branch" ? delivered.accepted : task.base);
+    const base = app.repo.snapshot([app.project.source_dir, ...task.scope.paths], GENERATED);
+    const changed = app.repo.changedFiles(sourceBase, task.accepted);
+    const old = app.repo.blobs(sourceBase, changed), accepted = app.repo.blobs(task.accepted, changed), current = app.repo.blobs(base, changed);
+    const files: string[] = [], contents: Record<string, Buffer | null> = {};
+    for (const file of changed) {
+      const [merged, conflict] = merge3(current[file], old[file], accepted[file]);
+      if (!conflict) contents[file] = merged;
+      else {
+        files.push(file);
+        // Keep clean hunks even in a file with conflicts. At overlapping
+        // hunks keep the latest manuscript as the baseline for human review.
+        const [kept, failed] = merge3(current[file], old[file], accepted[file], true);
+        contents[file] = failed ? current[file] : kept;
+      }
+    }
+    if (!files.length) return null; // The author may have resolved it meanwhile.
+    const reviewBase = app.repo.commitWith(base, contents, "latex-review: prepare merge review");
+    const data: Reconciliation = { id: randomUUID(), round: app.review.latestRound(name)?.number ?? 0, files, sourceBase, sourceAccepted: task.accepted, base, reviewBase, worktreeBefore, ready: false, ...(intent ? { intent } : {}) };
+    for (const file of app.repo.changedFiles(worktreeBefore, reviewBase)) safePath(task.worktree, file);
+    // Keep the three versions available to the agent and across Git GC.
+    for (const [kind, rev] of Object.entries({ original: sourceBase, proposed: task.accepted, current: base, before: worktreeBefore, review: reviewBase }))
+      app.repo.updateRef(`refs/latex-review/${name}/merge/${data.id}/${kind}`, rev);
+    app.store.execute("INSERT OR REPLACE INTO reconciliations(task,data) VALUES(?,?)", name, JSON.stringify(data));
+    return this.prepare(name, data);
+  }
+  prepare(name: string, data: Reconciliation) {
+    if (data.ready) return data;
+    const app = this.app, task = app.tasks.get(name);
+    const files = app.repo.changedFiles(data.worktreeBefore, data.reviewBase);
+    const before = app.repo.blobs(data.worktreeBefore, files), after = app.repo.blobs(data.reviewBase, files);
+    const writes = files.map(file => ({ file, path: safePath(task.worktree, file) }));
+    for (const write of writes) {
+      const current = readBytes(write.path);
+      if (!same(current, before[write.file]) && !same(current, after[write.file]))
+        throw new Error("The task changed while preparing its merge review. Keep those edits and retry after reviewing them.");
+    }
+    let scope = task.scope;
+    if (scope.sections.length) {
+      const outline = buildOutline(revisionReader(app.repo, data.reviewBase, app.project.doc_dir), app.project.main);
+      const [ranges, sections] = selectedRanges(outline.nodes, resolveSections(outline.nodes, scope.sections.map(section => section.id.replace(/^label:/, ""))));
+      scope = { ranges, sections, paths: Object.keys(ranges).sort() };
+    }
+    for (const write of writes) writeOrDelete(write.path, after[write.file]);
+    app.repo.updateRef(`refs/latex-review/${name}/base`, data.reviewBase);
+    app.repo.updateRef(`refs/latex-review/${name}/accepted`, data.reviewBase);
+    app.store.transaction(() => {
+      app.store.execute("UPDATE tasks SET base=?,accepted=?,scope=? WHERE name=?", data.reviewBase, data.reviewBase, JSON.stringify(scope), name);
+      app.store.execute("UPDATE reconciliations SET data=? WHERE task=?", JSON.stringify({ ...data, ready: true }), name);
+    });
+    return { ...data, ready: true };
+  }
+  recover() {
+    for (const row of this.app.store.all<{ task: string; data: Reconciliation }>("SELECT * FROM reconciliations"))
+      if (!row.data.ready) try { this.prepare(row.task, row.data); } catch { /* Retry without overwriting intervening edits. */ }
+  }
+}

package/vendor/latex-review/src/core/review.ts

@@ -121,8 +121,8 @@ export class Review {
         "SELECT * FROM actions WHERE task=? AND status='applied' ORDER BY seq DESC LIMIT 1",
         name,
       );
-    const delivered = this.app.delivery.get(name);
-    return action && latest && action.round === latest.number && (!delivered || action.seq > delivered.seq) ? action : null;
+    const delivered = this.app.delivery.get(name), reconciliation = this.app.reconciliation.get(name);
+    return action && latest && (!reconciliation || action.round > reconciliation.round) && action.round === latest.number && (!delivered || action.seq > delivered.seq) ? action : null;
   }
   summary(name: string): Summary {
     const task = this.app.tasks.get(name),
@@ -261,6 +261,7 @@ export class Review {
       loose: render.loose,
       warnings: round.summary.warnings ?? [],
       files: `/files/${name}/${number}/`,
+      ...(render.references ? { references: render.references } : {}),
     };
   }
   history(name: string, round: Round): Record<string, History[]> {
@@ -366,6 +367,9 @@ export class Review {
     const task = this.app.tasks.get(name),
       kind = data.action;
     this.app.delivery.assertReady(name);
+    const reconciliation = this.app.reconciliation.get(name);
+    if (reconciliation && (!reconciliation.ready || data.round <= reconciliation.round))
+      throw new Error("Review the new merge suggestion before changing decisions.");
     if (!Object.hasOwn(DECIDED, kind))
       throw new Error("The action must be accept, reject or comment.");
     const identity = data.id || randomUUID();

package/vendor/latex-review/src/core/store.ts

@@ -3,6 +3,7 @@ import fs from "node:fs";
 import path from "node:path";
 const SCHEMA = `
 CREATE TABLE IF NOT EXISTS tasks(name TEXT PRIMARY KEY,title TEXT NOT NULL,worktree TEXT NOT NULL,base TEXT NOT NULL,accepted TEXT NOT NULL,scope TEXT NOT NULL,created REAL NOT NULL,closed REAL);
+CREATE TABLE IF NOT EXISTS reconciliations(task TEXT PRIMARY KEY,data TEXT NOT NULL);
 CREATE TABLE IF NOT EXISTS deliveries(task TEXT PRIMARY KEY,data TEXT NOT NULL);
 CREATE TABLE IF NOT EXISTS rounds(task TEXT NOT NULL,number INTEGER NOT NULL,before TEXT NOT NULL,after TEXT NOT NULL,units TEXT NOT NULL,summary TEXT NOT NULL,created REAL NOT NULL,PRIMARY KEY(task,number));
 CREATE TABLE IF NOT EXISTS actions(seq INTEGER PRIMARY KEY AUTOINCREMENT,id TEXT NOT NULL UNIQUE,task TEXT NOT NULL,round INTEGER NOT NULL,kind TEXT NOT NULL,changes TEXT NOT NULL,body TEXT NOT NULL DEFAULT '',status TEXT NOT NULL,detail TEXT NOT NULL DEFAULT '{}',created REAL NOT NULL);

package/vendor/latex-review/src/core/tasks.ts

@@ -155,7 +155,7 @@ export class Tasks {
           name,
         );
         app.store.execute("DELETE FROM tasks WHERE name=?", name);
-        for (const table of ["rounds", "actions", "messages", "jobs", "deliveries"])
+        for (const table of ["rounds", "actions", "messages", "jobs", "deliveries", "reconciliations"])
           app.store.execute(`DELETE FROM ${table} WHERE task=?`, name);
         app.store.execute(
           "INSERT INTO tasks(name,title,worktree,base,accepted,scope,created,deferred) VALUES(?,?,?,?,?,?,?,?)",