papilot 0.8.7 → 0.8.9

package/engine/dist/web/index.html

@@ -9,8 +9,8 @@
       rel="icon"
       href="data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 16 16'%3E%3Crect width='16' height='16' rx='3' fill='%232b6e5c'/%3E%3Cpath d='M4 8.5l2.5 2.5L12 5' stroke='white' stroke-width='2' fill='none'/%3E%3C/svg%3E"
     />
-    <script type="module" crossorigin src="/assets/index-DBYJK8Uy.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-DGkq8xQx.css">
+    <script type="module" crossorigin src="/assets/index-e1oe-qOQ.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-CkL-mf_b.css">
   </head>
   <body>
     <div id="root"></div>

package/engine/src/web/FullPaper.tsx

@@ -14,12 +14,21 @@ import worker from "pdfjs-dist/build/pdf.worker.min.mjs?url";
 import type { ChangeBlock, Strip } from "../types.ts";
 import { t } from "./i18n.ts";
 import type { PlacedChange } from "./paper.ts";
+import { cMapData } from "./pdf-cmaps.ts";
 
 // Built assets share one folder, and a host such as Papilot serves the viewer
-// under its own prefix: find the worker next to this chunk, not at /assets.
-pdfjs.GlobalWorkerOptions.workerSrc = import.meta.env.DEV
-  ? worker
-  : new URL(worker.split("/").pop()!, import.meta.url).href;
+// under its own prefix: find the worker and CMaps next to this chunk, not at /assets.
+const besideChunk = (url: string) =>
+  import.meta.env.DEV ? url : new URL(url.split("/").pop()!, import.meta.url).href;
+pdfjs.GlobalWorkerOptions.workerSrc = besideChunk(worker);
+const CMapData = cMapData(
+  import.meta.glob<string>("../../node_modules/pdfjs-dist/cmaps/*.bcmap", {
+    eager: true,
+    import: "default",
+    query: "?url&no-inline",
+  }),
+  besideChunk,
+);
 
 // The whole paper with its changes in place: the new PDF's pages, opened up
 // where a change's new lines are, and that change shown there as in the
@@ -134,7 +143,7 @@ export function FullPaper({
     setStarted(Date.now());
     announced.current = false;
     const open = async (source: string, partial: boolean) => {
-      const task = pdfjs.getDocument({ url: source, enableXfa: false });
+      const task = pdfjs.getDocument({ url: source, enableXfa: false, BinaryDataFactory: CMapData });
       tasks.push(task);
       const pdf = await task.promise,
         first = (await pdf.getPage(1)).getViewport({ scale: 1 }),

package/engine/src/web/pdf-cmaps.ts

@@ -0,0 +1,20 @@
+// pdf.js draws CJK text from fonts without a ToUnicode map, such as xeCJK's
+// default Fandol fonts, through Adobe's predefined CMaps; without them those
+// characters stay blank. Each bundle ships pdf.js's packed CMaps as assets and
+// passes their URLs here. pdf.js then asks for one file at a time by name.
+export function cMapData(urls: Record<string, string>, resolve = (url: string) => url) {
+  const files = new Map(
+    Object.entries(urls).map(([path, url]) => [path.slice(path.lastIndexOf("/") + 1), url]),
+  );
+  return class CMapData {
+    async fetch({ kind, filename }: { kind: string; filename: string }) {
+      // Standard fonts and wasm keep pdf.js's behaviour without their URLs.
+      if (kind !== "cMapUrl") throw new Error(`Ensure that the \`${kind}\` API parameter is provided.`);
+      const url = files.get(filename);
+      if (!url) throw new Error(`Unknown CMap: ${filename}`);
+      const response = await fetch(resolve(url));
+      if (!response.ok) throw new Error(`Unable to load CMap data at: ${resolve(url)}`);
+      return new Uint8Array(await response.arrayBuffer());
+    }
+  };
+}

package/engine/src/web/review.tsx

@@ -101,6 +101,12 @@ function store(key: string, value: unknown) {
     /* Storage is optional. */
   }
 }
+// The comment box grows with its text up to the height its style allows.
+function fitComposer(element: HTMLTextAreaElement | null) {
+  if (!element) return;
+  element.style.height = "0";
+  element.style.height = `${element.scrollHeight}px`;
+}
 function jobText(job: PageState["job"]) {
   return job?.status === "queued"
     ? job.ahead
@@ -1671,33 +1677,49 @@ export function ReviewApp({
             void submitComposer();
           }}
         >
-          <label htmlFor="composer-text">
-            {t("Comment on change {n}", { n: composer.stop + 1 })}
-          </label>
+          <div className="composer-head">
+            <label htmlFor="composer-text">
+              {t("Comment on change {n}", { n: composer.stop + 1 })}
+            </label>
+            <button
+              type="button"
+              className="composer-close"
+              aria-label={t("Cancel")}
+              title={t("Cancel")}
+              onClick={() => closeComposer()}
+            >
+              <svg viewBox="0 0 24 24" aria-hidden="true">
+                <path d="M18 6 6 18M6 6l12 12" />
+              </svg>
+            </button>
+          </div>
           <textarea
             id="composer-text"
+            ref={fitComposer}
             autoFocus
-            rows={4}
+            rows={3}
             maxLength={20000}
             value={draft}
             onChange={(e) => {
               setDraft(e.target.value);
               store(composer.key, e.target.value);
+              fitComposer(e.target);
             }}
             placeholder={t("What should the agent change here?")}
           />
           <div className="composer-row">
             <span className="muted">{t("⌘↵ send · Esc cancel")}</span>
-            <button type="button" onClick={() => closeComposer()}>
-              {t("Cancel")}
-            </button>
             <button
               type="submit"
-              title={state?.commentLock ? t(state.commentLock) : undefined}
+              className="composer-send"
+              aria-label={t("Send")}
+              title={state?.commentLock ? t(state.commentLock) : t("Send")}
               aria-describedby={state?.commentLock ? "review-lock" : undefined}
               disabled={busy || !draft.trim() || Boolean(state?.commentLock)}
             >
-              {t("Send")}
+              <svg viewBox="0 0 24 24" aria-hidden="true">
+                <path d="M12 19V5m-7 7 7-7 7 7" />
+              </svg>
             </button>
           </div>
         </form>

package/engine/src/web/style.css

@@ -1274,57 +1274,129 @@ kbd {
   width: min(380px, calc(100vw - 24px));
 }
 
+/* The comment box: a title with a close button, a borderless field that
+   grows with its text, and a round send button, like Papilot's own composer. */
 .composer {
   position: fixed;
   left: 50%;
   bottom: 84px;
   transform: translateX(-50%);
   z-index: 5;
-  width: min(540px, calc(100vw - 24px));
-  padding: 12px;
+  width: min(560px, calc(100vw - 24px));
   background: var(--bar);
   border: 1px solid var(--line);
-  border-radius: 12px;
-  box-shadow: 0 6px 24px rgb(0 0 0 / 0.08);
+  border-radius: 14px;
+  box-shadow:
+    0 2px 4px rgb(0 0 0 / 0.04),
+    0 14px 36px rgb(0 0 0 / 0.13);
 }
-.composer label {
-  display: block;
-  font-size: 17px;
-  font-weight: 400;
-  color: var(--ink);
-  margin-bottom: 6px;
+.composer-head {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  padding: 8px 8px 0 16px;
+}
+.composer-head label {
+  flex: 1;
+  min-width: 0;
+  overflow: hidden;
+  font-size: 13px;
+  font-weight: 600;
+  color: var(--muted);
+  text-overflow: ellipsis;
+  white-space: nowrap;
 }
 .composer textarea {
+  display: block;
   width: 100%;
-  resize: vertical;
-  min-height: 84px;
-  padding: 8px 10px;
-  border: 1px solid var(--line);
-  border-radius: 7px;
-  background: var(--paper);
-  color: #1f2328;
+  min-height: 70px;
+  max-height: min(280px, 40dvh);
+  margin: 0;
+  padding: 4px 16px;
+  border: 0;
+  outline: none;
+  resize: none;
+  overflow-y: auto;
+  background: transparent;
+  color: var(--ink);
+  font-size: 15px;
+  line-height: 1.55;
 }
-.composer textarea:focus {
-  outline: 2px solid color-mix(in srgb, var(--comment) 45%, transparent);
-  border-color: transparent;
+.composer textarea::placeholder {
+  color: var(--muted);
 }
 .composer-row {
   display: flex;
   align-items: center;
   justify-content: space-between;
-  margin-top: 8px;
+  gap: 8px;
+  padding: 6px 8px 8px 16px;
   font-size: 12px;
 }
-.composer-row kbd {
-  margin-left: 0;
+.composer-row .muted {
+  min-width: 0;
 }
-.composer button {
-  border: 1px solid var(--line);
-  border-radius: 7px;
-  padding: 6px 16px;
-  background: var(--paper);
+.composer-close,
+.composer-send {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  flex: none;
+  padding: 0;
+  border: 0;
+}
+.composer svg {
+  width: 16px;
+  height: 16px;
+  fill: none;
+  stroke: currentColor;
+  stroke-width: 2;
+  stroke-linecap: round;
+  stroke-linejoin: round;
+}
+.composer-close {
+  width: 28px;
+  height: 28px;
+  border-radius: 8px;
+  background: transparent;
+  color: var(--muted);
+  transition:
+    background-color 0.15s,
+    color 0.15s;
+}
+.composer-close svg {
+  width: 14px;
+  height: 14px;
+}
+.composer-close:hover {
+  background: color-mix(in srgb, var(--ink) 7%, transparent);
   color: var(--ink);
 }
+.composer-send {
+  width: 32px;
+  height: 32px;
+  border-radius: 50%;
+  background: var(--accent);
+  color: #fff;
+  transition:
+    background-color 0.15s,
+    transform 0.1s;
+}
+.composer-send svg {
+  width: 18px;
+  height: 18px;
+}
+.composer-send:hover:not(:disabled) {
+  background: color-mix(in srgb, var(--accent) 85%, #000);
+}
+.composer-send:active:not(:disabled) {
+  transform: scale(0.94);
+}
+.composer-send:disabled {
+  opacity: 1;
+  background: color-mix(in srgb, var(--ink) 9%, transparent);
+  color: var(--muted);
+}
 
 .toast {
   position: fixed;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "papilot",
-  "version": "0.8.7",
+  "version": "0.8.9",
   "description": "A Cursor-like workspace for your papers: annotate and review PDFs directly without ever touching LaTeX.",
   "keywords": [
     "latex",

package/src/server/app.ts

@@ -245,15 +245,11 @@ export async function buildApp(options: AppOptions) {
     // A skill submission uses the same task endpoint and retry identity as editing.
     const existing = store.tasks().find(task => task.id === id);
     if (existing) { if (existing.projectId !== projectId) throw new Error('Invalid task ID.'); return existing; }
-    let reviewInput;
-    if (skill && findSkill(store.project(projectId).path, skill).output === 'annotations') {
-      const state = await manuscripts.state(projectId, store.project(projectId).path);
-      if (!state.build.current || !state.build.key) throw new Error('Wait for the current PDF to finish compiling, then run the AI review skill.');
-      reviewInput = await manuscripts.reviewSnapshot(projectId, state.build.key);
-    }
-    return workspace.createTask({ id, projectId, reviewInput, ...(reviewInput ? { prepareReview: (worktree: string) => manuscripts.captureReview(store.project(projectId).path, worktree, id) } : {}), title: string(b.title, 'Task title', 120), instructions: skill || annotations?.length || attachments.length ? optional(b.instructions, 'Instructions') : string(b.instructions, 'Instructions'), skill, annotations, groupInstructions, attachments, agent: agent(b.agent), model: typeof b.model === 'string' ? b.model : undefined, effort: effort(b.effort), serviceTier: b.serviceTier === undefined ? undefined : string(b.serviceTier, 'Service tier', 64), author: author(request.viewer) });
+    // AI review compiles the task's own copy of the manuscript, so it does not wait for the preview.
+    const reviewing = Boolean(skill && findSkill(store.project(projectId).path, skill).output === 'annotations');
+    return workspace.createTask({ id, projectId, ...(reviewing ? { prepareReview: (worktree: string) => manuscripts.captureReview(store.project(projectId).path, worktree, id) } : {}), title: string(b.title, 'Task title', 120), instructions: skill || annotations?.length || attachments.length ? optional(b.instructions, 'Instructions') : string(b.instructions, 'Instructions'), skill, annotations, groupInstructions, attachments, agent: agent(b.agent), model: typeof b.model === 'string' ? b.model : undefined, effort: effort(b.effort), serviceTier: b.serviceTier === undefined ? undefined : string(b.serviceTier, 'Service tier', 64), author: author(request.viewer) });
   });
-  app.get<{ Params: { id: string } }>('/api/tasks/:id/items', task, request => { store.task(request.params.id); return { items: store.items(request.params.id) }; });
+  app.get<{ Params: { id: string }; Querystring: { since?: string } }>('/api/tasks/:id/items', task, request => { store.task(request.params.id); return store.itemsSince(request.params.id, typeof request.query.since === 'string' ? request.query.since : undefined); });
   app.get<{ Params: { id: string } }>('/api/tasks/:id/note-results', task, async request => {
     const task = store.task(request.params.id), client = await connectReview(store.project(task.projectId).path);
     return { notes: await taskNoteResults(task, store.items(task.id), store.runs().filter(run => run.taskId === task.id), client) };

package/src/server/manuscript.ts

@@ -79,6 +79,19 @@ function gitDir(root: string) {
     return fs.statSync(dot).isFile() ? path.resolve(root, readText(dot).replace(/^gitdir:\s*/, '').trim()) : dot;
   } catch { return null; }
 }
+// Cheap evidence that Git's own state moved: the index, HEAD, the current
+// branch, a fetch or a merge. Each changes when a commit, stage, checkout,
+// fetch or merge happens, from Papilot or from a terminal.
+export function gitStamp(root: string) {
+  const dir = gitDir(root);
+  if (!dir) return '';
+  const common = path.resolve(dir, readText(path.join(dir, 'commondir')).trim() || '.');
+  const branch = readText(path.join(dir, 'HEAD')).match(/^ref: (refs\/\S+)/)?.[1];
+  // FETCH_HEAD belongs to the worktree that fetched, so a linked worktree checks
+  // its own and the main one's.
+  return [path.join(dir, 'index'), path.join(dir, 'HEAD'), path.join(dir, 'MERGE_HEAD'), path.join(dir, 'FETCH_HEAD'), common !== dir && path.join(common, 'FETCH_HEAD'), path.join(common, 'packed-refs'), branch && path.join(common, branch)]
+    .map(file => { try { const stat = file && fs.statSync(file); return stat ? `${stat.mtimeMs}:${stat.size}` : '-'; } catch { return '-'; } }).join('|');
+}
 export function mergeInProgress(root: string) {
   const dir = gitDir(root);
   return Boolean(dir && fs.existsSync(path.join(dir, 'MERGE_HEAD')));
@@ -298,13 +311,13 @@ async function pageSizes(mupdf: any, pdf: string) {
 }
 
 async function engine() {
-  const [{ Builder }, { Repo, gitBinary }, { loadProject }, { mupdf, PdfDocument, containsCenter, walkText }] = await Promise.all([
+  const [{ Builder, BuildError }, { Repo, gitBinary }, { loadProject }, { mupdf, PdfDocument, containsCenter, walkText }] = await Promise.all([
     import(pathToFileURL(path.join(ENGINE, 'src/core/build.ts')).href),
     import(pathToFileURL(path.join(ENGINE, 'src/core/git.ts')).href),
     import(pathToFileURL(path.join(ENGINE, 'src/core/config.ts')).href),
     import(pathToFileURL(path.join(ENGINE, 'src/render/pdf.ts')).href),
   ]);
-  return { Builder, Repo, gitBinary, loadProject, mupdf, PdfDocument, containsCenter, walkText };
+  return { Builder, BuildError, Repo, gitBinary, loadProject, mupdf, PdfDocument, containsCenter, walkText };
 }
 
 // `synctex edit` maps a PDF position (big points from the top-left corner) to
@@ -483,12 +496,16 @@ export class Manuscripts extends EventEmitter {
   // The view polls every second and a half while a build runs; Git's status
   // costs a walk of the working tree, which competes with TeX, so it is
   // read again at most every few seconds then, and after Papilot's own writes.
-  private statuses = new Map<string, { at: number; value: Promise<GitStatus> }>();
-  private gitStatus(root: string, building: boolean) {
-    const cached = this.statuses.get(root);
-    if (building && cached && Date.now() - cached.at < 5000) return cached.value;
+  // Between builds the view polls every five seconds to notice other editors:
+  // the status is read again when the working tree or Git's own state moved,
+  // and at least every half minute for what neither shows, such as a push
+  // from a terminal changing how far the branch is ahead.
+  private statuses = new Map<string, { at: number; value: Promise<GitStatus>; tree?: string; stamp?: string }>();
+  private gitStatus(root: string, building: boolean, tree?: string) {
+    const cached = this.statuses.get(root), age = cached ? Date.now() - cached.at : Infinity, stamp = building ? undefined : gitStamp(root);
+    if (cached && (building ? age < 5000 : tree !== undefined && cached.tree === tree && cached.stamp === stamp && age < 30000)) return cached.value;
     const value = gitStatus(root);
-    this.statuses.set(root, { at: Date.now(), value });
+    this.statuses.set(root, { at: Date.now(), value, tree, stamp });
     value.catch(() => { if (this.statuses.get(root)?.value === value) this.statuses.delete(root); });
     return value;
   }
@@ -497,7 +514,8 @@ export class Manuscripts extends EventEmitter {
     const current = this.builds.get(projectId), building = current?.status === 'building';
     // Polling an in-flight build needs its status, not another source snapshot.
     // Once it finishes, the next read checks for edits made during compilation.
-    const [status, tree] = await Promise.all([this.gitStatus(root, building), building ? current.tree : this.snapshot(root)]);
+    // The snapshot comes first so an unchanged tree can reuse the last status.
+    const tree = building ? current.tree : await this.snapshot(root), status = await this.gitStatus(root, building, building ? undefined : tree);
     let build = this.builds.get(projectId);
     if (!build || (build.status !== 'building' && (build.tree !== tree || rebuild))) build = this.start(projectId, root, tree, build, rebuild);
     const { status: state, key, pages, builtAt, error } = build;
@@ -701,13 +719,17 @@ export class Manuscripts extends EventEmitter {
   }
 
   // Compile the task's frozen source tree, then retain its PDF outside the build cache.
+  // A preview build of the same tree is shared, not repeated.
   async captureReview(root: string, worktree: string, taskId: string): Promise<ReviewSnapshot> {
-    const { Builder, Repo, loadProject } = await engine();
+    const { Builder, BuildError, Repo, loadProject } = await engine();
     const tree = await workingTree(worktree);
-    const result = await new Builder(loadProject(root), new Repo(root)).build(tree, ['full']);
-    const pdf = await this.preserveReviewPdf(root, taskId, result.pdf);
-    const key = createHash('sha256').update(fs.readFileSync(pdf)).digest('hex').slice(0, 16);
-    return { ...await this.snapshotPdf(pdf, key), pdf };
+    let result;
+    try { result = await new Builder(loadProject(root), new Repo(root)).build(tree, ['full']); }
+    catch (error) { throw error instanceof BuildError ? new Error('The manuscript could not be compiled for AI review. Fix the errors shown in the manuscript preview, then try again.') : error; }
+    const key = createHash('sha256').update(fs.readFileSync(result.pdf)).digest('hex').slice(0, 16);
+    const snapshot = await this.snapshotPdf(result.pdf, key);
+    // The task does not exist yet, so a PDF kept by an earlier failed attempt is replaced.
+    return { ...snapshot, pdf: await this.preserveReviewPdf(root, taskId, result.pdf, true) };
   }
 
   private async reviewPdfPath(root: string, taskId: string) {
@@ -720,11 +742,11 @@ export class Manuscripts extends EventEmitter {
     return fs.existsSync(pdf) ? pdf : null;
   }
 
-  async preserveReviewPdf(root: string, taskId: string, source: string) {
+  async preserveReviewPdf(root: string, taskId: string, source: string, replace = false) {
     const pdf = await this.reviewPdfPath(root, taskId), folder = path.dirname(pdf);
     fs.mkdirSync(folder, { recursive: true });
     // A retry always uses the original task copy, even after its build cache is pruned.
-    if (!fs.existsSync(pdf)) { const temporary = path.join(folder, 'review.tmp'); fs.copyFileSync(source, temporary); fs.renameSync(temporary, pdf); }
+    if (replace || !fs.existsSync(pdf)) { const temporary = path.join(folder, 'review.tmp'); fs.copyFileSync(source, temporary); fs.renameSync(temporary, pdf); }
     return pdf;
   }
 
@@ -762,11 +784,7 @@ export class Manuscripts extends EventEmitter {
     } finally { original.close(); current.close(); }
   }
 
-  async reviewSnapshot(projectId: string, key: string): Promise<ReviewSnapshot> {
-    return this.snapshotPdf(this.pdf(projectId, key), key);
-  }
-
-  private async snapshotPdf(pdf: string, key: string): Promise<ReviewSnapshot> {
+  async snapshotPdf(pdf: string, key: string): Promise<ReviewSnapshot> {
     const { PdfDocument } = await engine();
     const document = new PdfDocument(pdf), lines: ReviewSnapshot['lines'] = [];
     let length = 0;

package/src/server/store.ts

@@ -1,6 +1,7 @@
 import type { ReviewSnapshot } from './ai-review.ts';
 import { DatabaseSync } from 'node:sqlite';
 import { EventEmitter } from 'node:events';
+import { randomUUID } from 'node:crypto';
 import fs from 'node:fs';
 import path from 'node:path';
 import type { Annotation, Project, Task, Run, TimelineItem } from '../shared.ts';
@@ -39,6 +40,7 @@ export class Store extends EventEmitter {
   saveProject(p: Project) { this.db.prepare('INSERT INTO projects VALUES(?,?,?) ON CONFLICT(id) DO UPDATE SET path=excluded.path,data=excluded.data').run(p.id, p.path, JSON.stringify(p)); this.emit('change'); }
   removeProject(id: string) {
     this.project(id);
+    const tasks = (this.db.prepare('SELECT id FROM tasks WHERE project_id=?').all(id) as { id: string }[]).map(row => row.id);
     this.transaction(() => {
       // Only Papilot records are removed. Never finish review tasks or touch their files.
       this.db.prepare('INSERT OR IGNORE INTO deleted_tasks SELECT id, ? FROM tasks WHERE project_id=?').run(Date.now(), id);
@@ -46,6 +48,7 @@ export class Store extends EventEmitter {
       for (const table of ['tasks', 'annotations', 'members']) this.db.prepare(`DELETE FROM ${table} WHERE project_id=?`).run(id);
       this.db.prepare('DELETE FROM projects WHERE id=?').run(id);
     });
+    for (const task of tasks) this.itemRevisions.delete(task);
     this.emit('change');
   }
   saveTask(t: Task) { t.updatedAt = Date.now(); this.db.prepare('INSERT INTO tasks VALUES(?,?,?) ON CONFLICT(id) DO UPDATE SET data=excluded.data').run(t.id, t.projectId, JSON.stringify(t)); this.emit('change'); return t; }
@@ -53,7 +56,28 @@ export class Store extends EventEmitter {
   saveRun(r: Run) { this.db.prepare('INSERT INTO runs VALUES(?,?,?,?,?) ON CONFLICT(id) DO UPDATE SET status=excluded.status,data=excluded.data').run(r.id, r.taskId, r.requestKey, r.status, JSON.stringify(r)); this.emit('change'); }
   runByKey(key: string) { const row = this.db.prepare('SELECT data FROM runs WHERE request_key=?').get(key) as { data: string } | undefined; return row ? JSON.parse(row.data) as Run : undefined; }
   items(taskId: string) { return (this.db.prepare('SELECT data FROM items WHERE task_id=? ORDER BY created,rowid').all(taskId) as { data: string }[]).map(r => JSON.parse(r.data) as TimelineItem); }
-  saveItem(item: TimelineItem) { this.db.prepare('INSERT INTO items VALUES(?,?,?,?) ON CONFLICT(id) DO UPDATE SET data=excluded.data').run(item.id, item.taskId, item.createdAt, JSON.stringify(item)); this.emit('change'); }
+  // A running task's view reads its timeline every second, and a command's
+  // output alone can be 40 KB, so a view that has the timeline asks only for
+  // the items written since its revision. Revisions start over with the
+  // process; one from an earlier run gets the whole timeline.
+  private readonly boot = randomUUID().slice(0, 8);
+  private revision = 0;
+  private itemRevisions = new Map<string, Map<string, number>>();
+  itemsSince(taskId: string, since?: string): { items: TimelineItem[]; revision: string; partial?: true } {
+    const revision = `${this.boot}:${this.revision}`, match = /^([0-9a-f]{8}):(\d{1,15})$/.exec(since || ''), after = match ? Number(match[2]) : NaN;
+    if (!match || match[1] !== this.boot || after > this.revision) return { items: this.items(taskId), revision };
+    const changed = [...this.itemRevisions.get(taskId) || []].filter(([, at]) => at > after).map(([id]) => id);
+    if (changed.length > 500) return { items: this.items(taskId), revision };
+    const items = changed.length ? (this.db.prepare(`SELECT data FROM items WHERE task_id=? AND id IN (${changed.map(() => '?').join()}) ORDER BY created,rowid`).all(taskId, ...changed) as { data: string }[]).map(r => JSON.parse(r.data) as TimelineItem) : [];
+    return { items, revision, partial: true };
+  }
+  saveItem(item: TimelineItem) {
+    this.db.prepare('INSERT INTO items VALUES(?,?,?,?) ON CONFLICT(id) DO UPDATE SET data=excluded.data').run(item.id, item.taskId, item.createdAt, JSON.stringify(item));
+    let revisions = this.itemRevisions.get(item.taskId);
+    if (!revisions) this.itemRevisions.set(item.taskId, revisions = new Map());
+    revisions.set(item.id, ++this.revision);
+    this.emit('change');
+  }
   saveReviewInput(taskId: string, snapshot: ReviewSnapshot) { this.db.prepare('INSERT INTO ai_review_inputs VALUES(?,?) ON CONFLICT(task_id) DO UPDATE SET data=excluded.data').run(taskId, JSON.stringify(snapshot)); }
   reviewInput(taskId: string): ReviewSnapshot {
     const row = this.db.prepare('SELECT data FROM ai_review_inputs WHERE task_id=?').get(taskId) as { data: string } | undefined;
@@ -81,6 +105,7 @@ export class Store extends EventEmitter {
       this.db.prepare('DELETE FROM ai_review_inputs WHERE task_id=?').run(id);
       this.db.prepare('DELETE FROM tasks WHERE id=?').run(id);
     });
+    this.itemRevisions.delete(id);
     this.emit('change');
   }
   transaction<T>(fn: () => T): T { this.db.exec('BEGIN IMMEDIATE'); try { const result = fn(); this.db.exec('COMMIT'); return result; } catch (e) { this.db.exec('ROLLBACK'); throw e; } }

package/src/server/workspace.ts

@@ -130,7 +130,7 @@ export class Workspace extends EventEmitter {
       || this.store.tasks().some(task => ['queued', 'running', 'waiting_input', 'building', 'uncertain', 'deleting'].includes(task.status) || task.pendingReview));
   }
   readonly attachments: Attachments;
-  constructor(public store: Store, public codex: AgentRuntime = new Codex(), private concurrency = 2, private connectReview = reviewClient, others: Partial<Record<AgentId, AgentRuntime>> = {}) {
+  constructor(public store: Store, public codex: AgentRuntime = new Codex(), private connectReview = reviewClient, others: Partial<Record<AgentId, AgentRuntime>> = {}) {
     super();
     this.attachments = new Attachments(store);
     this.agents = { codex, claude: others.claude || new ClaudeAgent(), cursor: others.cursor || new CursorAgent(), copilot: others.copilot || new AcpAgent(ACP_PROFILES.copilot), grok: others.grok || new AcpAgent(ACP_PROFILES.grok), antigravity: others.antigravity || new AntigravityAgent(),
@@ -281,14 +281,15 @@ export class Workspace extends EventEmitter {
   }
   // A task combines the author's words, an optional skill and selected PDF notes.
   annotationSending(id: string) { return this.preparingNotes.has(id); }
-  async createTask(input: { reviewInput?: ReviewSnapshot; prepareReview?: (worktree: string) => Promise<ReviewSnapshot>; projectId: string; title: string; instructions: string; skill?: string; annotations?: string[]; groupInstructions?: GroupInstructions; attachments?: string[]; agent?: AgentId; model?: string; effort?: string; serviceTier?: string; id: string; author?: Author }) {
+  // An AI review passes prepareReview, which reads the PDF of the new task's manuscript copy.
+  async createTask(input: { prepareReview?: (worktree: string) => Promise<ReviewSnapshot>; projectId: string; title: string; instructions: string; skill?: string; annotations?: string[]; groupInstructions?: GroupInstructions; attachments?: string[]; agent?: AgentId; model?: string; effort?: string; serviceTier?: string; id: string; author?: Author }) {
     if (!/^[\w-]{16,64}$/.test(input.id)) throw new Error('Invalid task ID.');
     if (this.store.taskDeleted(input.id)) throw new Error('This task was deleted. Create a new task instead.');
     // A retried request returns its task; an ID from another paper is refused.
     const existing = this.store.tasks().find(t => t.id === input.id);
-    if (existing) { if (existing.projectId !== input.projectId || (existing.mode === 'review') !== Boolean(input.reviewInput)) throw new Error('Invalid task ID.'); return existing; }
-    if (input.reviewInput && !REVIEW_AGENTS.includes(input.agent || 'codex')) throw new Error('Choose Codex, Claude or GLM for AI review.');
-    if (input.reviewInput && (input.annotations?.length || input.attachments?.length)) throw new Error('AI review uses the manuscript PDF. Start a separate editing task to send notes or attachments.');
+    if (existing) { if (existing.projectId !== input.projectId || (existing.mode === 'review') !== Boolean(input.prepareReview)) throw new Error('Invalid task ID.'); return existing; }
+    if (input.prepareReview && !REVIEW_AGENTS.includes(input.agent || 'codex')) throw new Error('Choose Codex, Claude or GLM for AI review.');
+    if (input.prepareReview && (input.annotations?.length || input.attachments?.length)) throw new Error('AI review uses the manuscript PDF. Start a separate editing task to send notes or attachments.');
     if (input.serviceTier !== undefined) {
       if (input.agent && input.agent !== 'codex') throw new Error('Service tiers are only available for Codex.');
       const models = this.runtimes.codex.models;
@@ -301,7 +302,7 @@ export class Workspace extends EventEmitter {
     let releaseAttachments = () => {};
     try {
       const project = this.store.project(input.projectId), skill = input.skill ? findSkill(project.path, input.skill) : undefined;
-      if (skill?.output === 'annotations' && !input.reviewInput) throw new Error('Start a new task to run the AI review skill on the current PDF.');
+      if (skill?.output === 'annotations' && !input.prepareReview) throw new Error('Start a new task to run the AI review skill on the current PDF.');
       const files = this.attachments.resolve(project.id, input.attachments || [], input.author?.id || 'owner', input.id);
       releaseAttachments = this.attachments.reserve(project.id, input.attachments || [], input.author?.id || 'owner', input.id);
       const available = new Map(this.store.annotations(project.id).filter(note => !note.taskId && !isTaskReviewNote(note)).map(note => [note.id, note]));
@@ -316,12 +317,17 @@ export class Workspace extends EventEmitter {
       if (Object.keys(groupInstructions).some(group => !selectedGroups.has(group as keyof GroupInstructions))) throw new Error('Group instructions must refer to selected PDF notes.');
       if (groupsWithoutInstructions(notes, groupInstructions).length && !input.instructions.trim() && !skill) throw new Error('Describe what to do with each selected color group.');
       claimed = notes.map(note => note.id); claimed.forEach(id => this.preparingNotes.add(id));
-      if (!input.reviewInput && !skill && !notes.length && !files.length && !input.instructions.trim()) throw new Error('Describe the revision, choose a skill, or add a PDF note.');
+      if (!input.prepareReview && !skill && !notes.length && !files.length && !input.instructions.trim()) throw new Error('Describe the revision, choose a skill, or add a PDF note.');
       const instructions = notes.length ? notesInstructions(notes, input.instructions, groupInstructions) : input.instructions;
       const client = await this.connectReview(project.path);
       const name = 'p-' + input.id.toLowerCase().replace(/[^a-z0-9-]/g, '').slice(0, 48);
       const info = await client.post('/api/tasks', { name, title: input.title, deferred: true });
-      const reviewInput = input.reviewInput && (input.prepareReview ? await input.prepareReview(info.worktree) : input.reviewInput);
+      let reviewInput: ReviewSnapshot | undefined;
+      if (input.prepareReview) try { reviewInput = await input.prepareReview(info.worktree); } catch (error) {
+        // Discard the copy, so a retry copies the manuscript again with the author's fixes.
+        await client.post(`${taskRoute(name)}/finish`, { force: true }).catch(() => undefined);
+        throw error;
+      }
       const task: Task = { ...(reviewInput ? { mode: 'review' as const, aiReview: { key: reviewInput.key } } : {}), id: input.id, projectId: project.id, name, title: input.title, titleSource: 'prompt', instructions: skill ? skillPrompt(skill, instructions) : instructions,
         worktree: info.worktree, deferred: info.deferred === true, threadId: null, turnId: null, agent: input.agent || 'codex', model: input.model || null, effort: input.effort || null, ...(input.serviceTier ? { serviceTier: input.serviceTier } : {}), status: 'idle',
         createdAt: Date.now(), updatedAt: Date.now(), feedbackCursor: 0, error: null, review: null };
@@ -329,7 +335,7 @@ export class Workspace extends EventEmitter {
         this.store.saveTask(task);
         if (reviewInput) this.store.saveReviewInput(task.id, reviewInput);
       });
-      await this.enqueue(task.id, input.instructions || (input.reviewInput && !skill ? 'Review this manuscript and suggest improvements.' : ''), 'initial-' + task.id, false, { skill, notes, groupInstructions, attachments: files.map(file => file.id), author: input.author });
+      await this.enqueue(task.id, input.instructions || (input.prepareReview && !skill ? 'Review this manuscript and suggest improvements.' : ''), 'initial-' + task.id, false, { skill, notes, groupInstructions, attachments: files.map(file => file.id), author: input.author });
       // Naming is independent of the editing turn. An unavailable helper must
       // not fail creation or prevent the queued task from running.
       try { this.requestTaskTitle(task.id); } catch { /* Keep the prompt-derived title. */ }
@@ -407,7 +413,6 @@ export class Workspace extends EventEmitter {
   private async drain() {
     if (this.closing) return;
     for (const run of this.store.runs().filter(r => r.status === 'queued')) {
-      if (this.active.size >= this.concurrency) break;
       const agent = this.agentOf(this.store.task(run.taskId));
       if (!this.agents[agent].ready || !this.runtimes[agent].authenticated) continue;
       if (this.active.has(run.taskId) || this.reviewWrites.has(run.taskId) || this.publishing.has(run.taskId) || this.store.task(run.taskId).delivery?.pending || BUSY.has(this.store.task(run.taskId).status)) continue;