papilot 0.1.1 → 0.3.0

package/dist/index.html

@@ -1,4 +1,13 @@
 <!doctype html>
-<html lang="en"><head><meta charset="UTF-8"/><meta name="viewport" content="width=device-width, initial-scale=1.0, viewport-fit=cover, interactive-widget=resizes-content"/><meta name="theme-color" content="#ffffff"/><meta name="description" content="Revise LaTeX papers with an agent and review the PDF changes."/><link rel="icon" type="image/png" href="/favicon.png"/><link rel="apple-touch-icon" href="/apple-touch-icon.png"/><title>Papilot</title>  <script type="module" crossorigin src="/assets/index-BhQFCMTx.js"></script>
-  <link rel="stylesheet" crossorigin href="/assets/index-CAV3-87U.css">
+<html lang="en"><head><meta charset="UTF-8"/><meta name="viewport" content="width=device-width, initial-scale=1.0, viewport-fit=cover, interactive-widget=resizes-content"/><meta name="theme-color" content="#ffffff"/><meta name="description" content="Revise LaTeX papers with an agent and review the PDF changes."/><link rel="icon" type="image/png" href="/favicon.png"/><link rel="apple-touch-icon" href="/apple-touch-icon.png"/><title>Papilot</title><script>
+// Resolve before the first paint, even while the application bundle is loading.
+(() => {
+  let theme;
+  try { theme = localStorage.getItem('papilot:theme'); } catch {}
+  const dark = theme === 'dark' || (theme !== 'light' && matchMedia('(prefers-color-scheme: dark)').matches);
+  document.documentElement.dataset.theme = dark ? 'dark' : 'light';
+  document.querySelector('meta[name="theme-color"]').content = dark ? '#26272b' : '#ffffff';
+})();
+</script><style>html{--lightningcss-light:initial;--lightningcss-dark: ;color-scheme:light;background:#fff}html[data-theme=dark]{--lightningcss-light: ;--lightningcss-dark:initial;color-scheme:dark;background:#26272b}</style>  <script type="module" crossorigin src="/assets/index-BkowXmKr.js"></script>
+  <link rel="stylesheet" crossorigin href="/assets/index-Dq3s-vhH.css">
 </head><body><div id="root"></div></body></html>

package/examples/papilot-paper/preamble.tex

@@ -18,17 +18,23 @@
 \usepackage[colorlinks=true,linkcolor=blue!50!black,citecolor=blue!50!black,urlcolor=blue!50!black]{hyperref}
 \usepackage[nameinlink]{cleveref}
 
-% thmtools lets cleveref name each kind of statement correctly although they
-% share one counter.
-\usepackage{thmtools}
-\declaretheorem[style=plain, numberwithin=section]{theorem}
-\declaretheorem[style=plain, sibling=theorem]{proposition}
-\declaretheorem[style=plain, sibling=theorem]{lemma}
-\declaretheorem[style=plain, sibling=theorem]{corollary}
-\declaretheorem[style=definition, sibling=theorem]{definition}
-\declaretheorem[style=definition, sibling=theorem]{example}
-\declaretheorem[style=definition, sibling=theorem]{assumption}
-\declaretheorem[style=remark, sibling=theorem]{remark}
+% Every kind of statement shares the theorem counter, and cleveref still names
+% each kind correctly. LaTeX from June 2026 does this itself and clashes with
+% thmtools, which older LaTeX needs for it.
+\IfFormatAtLeastTF{2026-06-01}
+  {\newtheorem{theorem}{Theorem}[section]
+   \NewDocumentCommand\statement{mmm}{\theoremstyle{#1}\newtheorem{#2}[theorem]{#3}}}
+  {\usepackage{thmtools}
+   \declaretheorem[style=plain, numberwithin=section]{theorem}
+   \NewDocumentCommand\statement{mmm}{\declaretheorem[style=#1, sibling=theorem, name=#3]{#2}}}
+\statement{plain}{proposition}{Proposition}
+\statement{plain}{lemma}{Lemma}
+\statement{plain}{corollary}{Corollary}
+\statement{definition}{definition}{Definition}
+\statement{definition}{example}{Example}
+\statement{definition}{assumption}{Assumption}
+\statement{remark}{remark}{Remark}
+\crefname{assumption}{assumption}{assumptions}
 \numberwithin{equation}{section}
 
 \newcommand{\R}{\mathbb{R}}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "papilot",
-  "version": "0.1.1",
+  "version": "0.3.0",
   "description": "A Cursor-like workspace for your papers: annotate and review PDFs directly without ever touching LaTeX.",
   "keywords": [
     "latex",
@@ -35,6 +35,9 @@
     "src/server",
     "src/shared.ts",
     "src/notes.ts",
+    "src/conversation.ts",
+    "src/commit.ts",
+    "skills",
     "dist",
     "scripts/demo.ts",
     "scripts/service.ts",
@@ -56,9 +59,12 @@
     "test": "tsx --test tests/*.test.ts",
     "setup:review": "npm --prefix vendor/latex-review ci && npm --prefix vendor/latex-review run build",
     "demo": "tsx scripts/demo.ts",
+    "doctor": "node bin/papilot.mjs doctor",
     "service:install": "tsx scripts/service.ts install",
     "service:stop": "tsx scripts/service.ts stop",
-    "test:ui": "npm run build && node scripts/check-ui.mjs",
+    "test:ui": "npm run build && node scripts/check-ui.mjs && node scripts/check-review-notes.mjs && node --import tsx scripts/check-review-flow.mjs && node scripts/check-skills.mjs",
+    "site": "node scripts/build-site.mjs",
+    "site:video": "node scripts/build-site.mjs --video",
     "prepack": "npm run build && npm run setup:review"
   },
   "dependencies": {
@@ -78,9 +84,14 @@
     "@types/react": "^19.3.0",
     "@types/react-dom": "^19.3.0",
     "@vitejs/plugin-react": "^6.1.2",
+    "katex": "^0.16.47",
     "pdfjs-dist": "^6.4.299",
     "react": "^19.3.1",
     "react-dom": "^19.3.1",
+    "react-markdown": "^10.1.0",
+    "rehype-katex": "^7.0.1",
+    "remark-gfm": "^4.0.1",
+    "remark-math": "^6.0.0",
     "typescript": "^7.0.2",
     "vite": "^8.3.5"
   }

package/scripts/service.ts

@@ -3,6 +3,7 @@ import path from 'node:path';
 import os from 'node:os';
 import { execFileSync } from 'node:child_process';
 import { ROOT, DATA } from '../src/server/paths.ts';
+import { serviceEnvironment } from '../src/server/service-environment.ts';
 
 if (process.platform !== 'darwin') throw new Error('This service installer is for macOS. On other systems run npm start with your process manager.');
 const label = 'local.papilot';
@@ -14,8 +15,13 @@ if (process.argv[2] === 'stop') {
   const xml = (s: string) => s.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
   fs.mkdirSync(DATA, { recursive: true, mode: 0o700 });
   fs.mkdirSync(path.dirname(file), { recursive: true });
-  const env: Record<string, string> = { PATH: [path.join(ROOT, 'node_modules/.bin'), '/Library/TeX/texbin', '/opt/homebrew/bin', '/usr/local/bin', '/usr/bin', '/bin', '/usr/sbin', '/sbin'].join(':'), HOME: os.homedir(), NODE_ENV: 'production' };
-  for (const [key, value] of Object.entries(process.env)) if (key.startsWith('PAPILOT_') && value) env[key] = value;
+  let previous: NodeJS.ProcessEnv = {};
+  if (fs.existsSync(file)) {
+    try {
+      previous = JSON.parse(execFileSync('/usr/bin/plutil', ['-extract', 'EnvironmentVariables', 'json', '-o', '-', file], { encoding: 'utf8' }));
+    } catch { /* An older or incomplete plist may not contain environment settings. */ }
+  }
+  const env = serviceEnvironment(ROOT, os.homedir(), process.execPath, process.env, previous);
   const args = ['/usr/bin/caffeinate', '-i', process.execPath, '--import', 'tsx', path.join(ROOT, 'src/server/main.ts')];
   const plist = `<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd"><plist version="1.0"><dict>
 <key>Label</key><string>${label}</string><key>ProgramArguments</key><array>${args.map(a => `<string>${xml(a)}</string>`).join('')}</array>

package/skills/check-math.md

@@ -0,0 +1,12 @@
+---
+name: Check math
+description: Find errors in notation, equations and proofs
+hint: Which part? e.g. "Section 3 and Appendix A". Leave empty for the whole paper
+order: 4
+---
+Check the mathematics for errors and inconsistencies.
+
+- Every symbol is defined before it is used and means one thing throughout. Indices, signs, dimensions and quantifiers agree. Theorem statements match their proofs and the places that cite them. References to equations, theorems and figures point to the right ones.
+- Fix clear slips directly: a typo in a formula, an inconsistent symbol, a wrong reference.
+- Do not change what a result says. If you suspect a substantive error, leave the text and explain the problem in your summary, with its location and your reasoning.
+- Follow the paper's own macros and environments.

package/skills/consistency.md

@@ -0,0 +1,11 @@
+---
+name: Consistency
+description: Unify terms, notation, spelling and references
+hint: Which part? Leave empty for the whole paper
+order: 5
+---
+Make the paper consistent with itself.
+
+- Terminology, capitalization and hyphenation; American or British spelling; acronyms defined once at first use and used after that; notation and macros; reference style (for example `\cref` or `Section~\ref`); numbers, units, list and caption punctuation.
+- For each difference, use the variant the paper uses most, and name your choices in the summary.
+- Do not change meaning, and leave quoted material and bibliography entries as they are.

package/skills/latex-warnings.md

@@ -0,0 +1,12 @@
+---
+name: Fix LaTeX warnings
+description: Resolve undefined references, overfull boxes and other build warnings
+hint: Anything to leave alone? Leave empty to fix every warning you can
+order: 6
+---
+Fix the problems LaTeX reports when it builds the paper.
+
+- Compile in your worktree (for example with `latexmk`) and read the log. If you cannot run commands, look for the same problems in the source instead.
+- Fix undefined or duplicate labels, references and citations; overfull boxes, by rewording slightly or allowing a break where the line overflows; and package warnings that point to real mistakes.
+- Do not silence warnings globally: no document-wide `\sloppy`, badness or tolerance changes, and no new packages, unless the request asks for them.
+- In your summary, list the warnings you fixed and any you left, with the reason.

package/skills/polish.md

@@ -0,0 +1,13 @@
+---
+name: Polish
+description: Improve clarity and flow, keeping the meaning
+hint: Which part? e.g. "the introduction". Leave empty for the whole paper
+order: 1
+---
+Improve the clarity, concision and flow of the prose, sentence by sentence and paragraph by paragraph.
+
+- Keep every claim, number, citation, label, definition and technical term. Do not add claims, results or citations.
+- Prefer concrete subjects and active verbs. Cut filler such as "it is worth noting that" or "in order to".
+- Keep the author's voice and the paper's terminology; never replace a defined term with a synonym.
+- Make the smallest edit that fixes a real problem, and leave sentences that already read well.
+- Do not touch mathematics, code, labels or the document's structure unless the request asks for it.

package/skills/proofread.md

@@ -0,0 +1,12 @@
+---
+name: Proofread
+description: Fix typos, grammar and punctuation without rewording
+hint: Which part? Leave empty for the whole paper
+order: 2
+---
+Proofread the prose for typos, spelling, grammar, punctuation, agreement, articles and repeated words.
+
+- Change only what is wrong. Do not rephrase correct sentences, reorder content, or change terminology, notation, citations or labels.
+- Keep the paper's spelling convention (American or British) as the majority of the text uses it.
+- Leave mathematics, code, citation keys, labels and URLs as they are.
+- In your summary, list anything you noticed but left because it needs the author's judgment.

package/skills/reviewer-response.md

@@ -0,0 +1,11 @@
+---
+name: Address reviewers
+description: Revise for reviewer comments and draft a point-by-point reply
+hint: Paste the reviewer comments
+order: 7
+---
+Revise the paper in response to the reviewer comments in the request.
+
+- For each comment, make a targeted change where one is warranted. Keep the rest of the text as it is.
+- Do not invent experiments, results or citations. When a comment needs new work, say so in the reply instead of editing.
+- End with a point-by-point reply in your summary: quote each comment briefly, then say what changed and where (section, and the new wording if it is short), or explain politely why nothing changed.

package/skills/shorten.md

@@ -0,0 +1,12 @@
+---
+name: Shorten
+description: Cut length without losing content
+hint: What and by how much? e.g. "Section 4 by a third" or "fit in 8 pages"
+order: 3
+---
+Make the text shorter while keeping its content.
+
+- Cut redundancy, repeated motivation, hedging and wordy phrasing first; merge sentences that say the same thing.
+- Keep every result, definition, theorem, figure, table and citation unless the request says otherwise.
+- With a page target, compile in your worktree to check the page count if you can run commands.
+- In your summary, say roughly how much you cut, what kind of text went, and what you considered cutting but kept.

package/src/commit.ts

@@ -0,0 +1,23 @@
+// What the Git panel leaves out of a commit unless chosen, and offers to add
+// to .gitignore: LaTeX's build output, minted's cache and macOS folder files.
+// Each file maps to the pattern that ignores every file of its kind.
+const BUILD = /\.(aux|log|out|toc|lof|lot|lol|fls|fdb_latexmk|synctex(?:\.gz)?|bbl|blg|bcf|run\.xml|nav|snm|vrb|xdv|dvi|idx|ilg|ind|glo|gls|glg|ist|thm|loa)$/;
+export function ignorePattern(file: string): string | null {
+  const name = file.slice(file.lastIndexOf('/') + 1);
+  if (name === '.DS_Store') return '.DS_Store';
+  if (/(?:^|\/)_minted[^/]*\//.test(file)) return '_minted*/';
+  const build = BUILD.exec(name);
+  return build ? `*.${build[1]}` : null;
+}
+
+// An agent's reply as a commit message: without a code fence, a label or
+// quotes, a subject without a final period, and any body after a blank line.
+export function commitMessageFrom(reply: string) {
+  const text = reply.trim().replace(/^```[\w-]*\n([\s\S]*?)\n```$/, '$1').trim()
+    .replace(/^(?:\*\*)?commit message(?:\*\*)?\s*:\s*(?:\*\*)?[ \t]*/i, '');
+  const lines = text.split('\n'), first = lines.findIndex(line => line.trim());
+  if (first < 0) return '';
+  const subject = lines[first].trim().replace(/^#+\s+/, '').replace(/^\*\*(.+)\*\*$/, '$1').replace(/^(["'`])(.+)\1$/, '$2').replace(/\.$/, '').trim();
+  const body = lines.slice(first + 1).join('\n').trim();
+  return body ? `${subject}\n\n${body}` : subject;
+}

package/src/conversation.ts

@@ -0,0 +1,48 @@
+import type { BuildFailure, FeedbackSummary } from './shared.ts';
+
+// What the agent receives when the author sends review feedback without a
+// message of their own. The chat shows the feedback, never this prompt.
+export const reviewInstructions = 'Continue this task using the decisions and comments from this review round. Preserve accepted changes and do not reintroduce rejected edits. Address any remaining revision requests; if no revision is needed, summarize the result.';
+// Earlier versions stored the prompt itself as the author's message.
+export const isFeedbackPrompt = (text: string) => text === reviewInstructions || text === 'Address the comments from this review round. Preserve accepted changes and do not reintroduce rejected edits.';
+
+// What the agent receives when its own edits stop the review build. The chat
+// shows the error, never this prompt.
+export function buildFixPrompt(failure: BuildFailure) {
+  return [
+    'Papilot could not build the PDF review after your last turn:',
+    [failure.error, ...failure.details].join('\n'),
+    failure.log ? `The compiler log is at ${failure.log}.` : '',
+    'Fix this in the task worktree, then end your turn; Papilot builds the review again. Restore any file outside the review\'s scope to how it was when the task started, and mention in your summary any update that file still needs.',
+  ].filter(Boolean).join('\n\n');
+}
+
+// A skill is a named set of instructions; the author's own words, if any, say where and how.
+export function skillPrompt(skill: { name: string; body: string; folder?: string }, request: string) {
+  return [
+    `Use the "${skill.name}" skill below for this request.${skill.folder ? ` Files the skill mentions are in ${skill.folder}.` : ''}`,
+    `<skill name="${skill.name}">\n${skill.body.trim()}\n</skill>`,
+    request.trim() ? `Request: ${request.trim()}` : 'No further details were given: apply the skill to the whole paper.',
+  ].join('\n\n');
+}
+
+interface FeedbackItem { kind?: string; round?: number | null; text?: string; changes?: (string | { file?: string; lines?: [number, number] })[] }
+// The review engine's feedback (see vendor/latex-review FeedbackItem) as the chat shows it.
+export function summarizeFeedback(feedback: { feedback?: FeedbackItem[]; build_error?: unknown }): FeedbackSummary | undefined {
+  const items = feedback.feedback || [];
+  if (!items.length && !feedback.build_error) return undefined;
+  const summary: FeedbackSummary = { round: null, accepted: 0, rejected: 0, undone: 0, comments: [], ...(feedback.build_error ? { buildError: true } : {}) };
+  for (const item of items) {
+    if (item.round) summary.round = Math.max(summary.round || 0, item.round);
+    const changes = item.changes || [];
+    if (item.kind === 'accept') summary.accepted += changes.length || 1;
+    else if (item.kind === 'reject') summary.rejected += changes.length || 1;
+    else if (item.kind === 'undo') summary.undone++;
+    else if ((item.kind === 'comment' || item.kind === 'note') && item.text?.trim()) {
+      const first = changes.find(change => typeof change === 'object' && change.file) as { file: string; lines?: [number, number] } | undefined;
+      const where = first ? `${first.file}${first.lines ? `:${first.lines[0]}` : ''}${changes.length > 1 ? ` +${changes.length - 1}` : ''}` : item.kind === 'note' ? 'Note on the review' : `Round ${item.round ?? ''}`.trim();
+      summary.comments.push({ where, text: item.text.trim().slice(0, 2000) });
+    }
+  }
+  return summary;
+}

package/src/notes.ts

@@ -7,6 +7,11 @@ const QUOTE = '   PDF text: "', REGION = '   Marked region: a figure, equation o
 
 export interface NoteSummary { where: string; quote: string; comment: string }
 
+export function reviewNotesInstructions(notes: NoteSummary[]) {
+  const items = notes.map((note, index) => `${index + 1}. ${note.where}\n${note.quote ? `${QUOTE}${note.quote}"` : REGION}${NOTE}${note.comment.trim().replace(/\n/g, '\n   ')}`);
+  return `${PREAMBLE} These notes refer to the displayed review round and its Before, After or Unchanged text. Region coordinates are percentages of the displayed PDF strip (left, top, right, bottom); any quoted text for a region is nearby context. Read the current source before editing. Preserve accepted changes and do not reintroduce rejected edits unless a note explicitly asks for it.\n\n${items.join('\n\n')}`;
+}
+
 export function notesInstructions(notes: Annotation[]) {
   const items = notes.map((note, index) => {
     const where = [`Page ${note.page + 1}`, note.source ? `${note.source.file} ${note.source.lines[0] === note.source.lines[1] ? `line ${note.source.lines[0]}` : `lines ${note.source.lines[0]}–${note.source.lines[1]}`}` : ''].filter(Boolean).join(' · ');

package/src/server/agents.ts

@@ -139,10 +139,11 @@ export class ClaudeAgent extends Adapter {
       this.ready = true;
     } finally { finish(); probe.close(); }
   }
-  // Claude tasks need an API key (or a cloud provider's own credentials):
-  // Anthropic does not accept a Claude subscription login through the SDK.
+  // Claude tasks need an API key, an ANTHROPIC_AUTH_TOKEN (for a gateway or an
+  // Anthropic-compatible ANTHROPIC_BASE_URL), or a cloud provider's own
+  // credentials: Anthropic does not accept a Claude subscription login through the SDK.
   protected account() {
-    const account = this.info.account, keyed = Boolean(account?.apiKeySource && !['none', 'oauth'].includes(account.apiKeySource));
+    const account = this.info.account, keyed = Boolean(account?.apiKeySource && !['none', 'oauth'].includes(account.apiKeySource)) || account?.tokenSource === 'ANTHROPIC_AUTH_TOKEN';
     const external = Boolean(account?.apiProvider && account.apiProvider !== 'firstParty');
     if (keyed || external) return { account: { email: account?.email, type: external ? account!.apiProvider : 'API key' }, requiresOpenaiAuth: false };
     return { account: null, requiresOpenaiAuth: true, reason: CLAUDE_KEY };

package/src/server/main.ts

@@ -10,7 +10,8 @@ import { ROOT, DATA, PORT, PUBLIC_ORIGIN, OWNER, VERSION } from './paths.ts';
 import { reviewClient, allowedReviewRoute, rewriteReviewHtml, rewriteReviewJson, confirmedReviewResponse, annotateReviewState } from './review.ts';
 import { authorize } from './security.ts';
 import { fullPaperPdf } from './pdf.ts';
-import { Manuscripts, annotationTask, gitCommit, gitDiff, gitRemote, gitStatus } from './manuscript.ts';
+import { Manuscripts, annotationTask, gitAbortMerge, gitCommit, gitDiff, gitFinishMerge, gitIgnore, gitRemote, gitStatus } from './manuscript.ts';
+import { findSkill, listedSkill, loadSkills } from './skills.ts';
 import type { AgentId } from '../shared.ts';
 
 const store = new Store(path.join(DATA, 'papilot.sqlite'));
@@ -46,9 +47,14 @@ const effort = (value: unknown) => typeof value === 'string' && /^[a-z]{1,16}$/.
 const string = (value: unknown, name: string, max = 20000) => { if (typeof value !== 'string' || !value.trim() || value.length > max) throw new Error(`${name} is required and must be no longer than ${max} characters.`); return value.trim(); };
 app.post('/api/projects', async request => { const b = request.body as any; return workspace.addProject(string(b.path, 'Repository path', 4000), b.name ? string(b.name, 'Paper name', 120) : undefined); });
 app.post<{ Params: { id: string } }>('/api/projects/:id/rename', request => workspace.renameProject(request.params.id, string((request.body as any).name, 'Paper name', 120)));
+// A skill's name: what the author typed after "/".
+const skillName = (value: unknown) => typeof value === 'string' && /^[a-z0-9][a-z0-9-]{0,47}$/.test(value) ? value : undefined;
+// Text the author may leave empty when a skill or review feedback says enough.
+const optional = (value: unknown, name: string) => value === undefined || value === '' ? '' : string(value, name);
+app.get<{ Params: { id: string } }>('/api/projects/:id/skills', request => ({ skills: loadSkills(store.project(request.params.id).path).map(listedSkill) }));
 app.post('/api/tasks', async request => {
-  const b = request.body as any;
-  return workspace.createTask({ id: string(b.id, 'Task ID', 64), projectId: string(b.projectId, 'Paper ID', 64), title: string(b.title, 'Task title', 120), instructions: string(b.instructions, 'Instructions'), agent: agent(b.agent), model: typeof b.model === 'string' ? b.model : undefined, effort: effort(b.effort) });
+  const b = request.body as any, skill = skillName(b.skill);
+  return workspace.createTask({ id: string(b.id, 'Task ID', 64), projectId: string(b.projectId, 'Paper ID', 64), title: string(b.title, 'Task title', 120), instructions: skill ? optional(b.instructions, 'Instructions') : string(b.instructions, 'Instructions'), skill, agent: agent(b.agent), model: typeof b.model === 'string' ? b.model : undefined, effort: effort(b.effort) });
 });
 app.get<{ Params: { id: string } }>('/api/tasks/:id/items', request => { store.task(request.params.id); return { items: store.items(request.params.id) }; });
 app.get<{ Params: { id: string }; Querystring: { round?: string; version?: string; download?: string } }>('/api/tasks/:id/pdf', async (request, reply) => {
@@ -61,8 +67,15 @@ app.get<{ Params: { id: string }; Querystring: { round?: string; version?: strin
   return reply.type('application/pdf').header('Content-Disposition', `${request.query.download === '1' ? 'attachment' : 'inline'}; filename="${filename}"`).sendFile(path.basename(pdf), path.dirname(pdf), { cacheControl: false });
 });
 app.post<{ Params: { id: string } }>('/api/tasks/:id/messages', async request => {
-  const b = request.body as any;
-  return workspace.enqueue(request.params.id, string(b.text, 'Revision instructions'), string(b.requestKey, 'Request ID', 100), true);
+  const b = request.body as any, task = store.task(request.params.id), feedback = b.feedback === true, name = skillName(b.skill);
+  const skill = name ? findSkill(store.project(task.projectId).path, name) : undefined;
+  const text = feedback || skill ? optional(b.text, 'Revision instructions') : string(b.text, 'Revision instructions');
+  return workspace.enqueue(task.id, text, string(b.requestKey, 'Request ID', 100), true, { skill, feedback });
+});
+// Commits what the author accepted from this task, with the message they confirmed.
+app.post<{ Params: { id: string } }>('/api/tasks/:id/commit', request => {
+  const task = store.task(request.params.id), b = request.body as any;
+  return serialGit(task.projectId, () => workspace.commitTask(task.id, string(b.message, 'Commit message', 5000), b.push === true));
 });
 app.post<{ Params: { id: string } }>('/api/tasks/:id/rename', request => workspace.renameTask(request.params.id, string((request.body as any).title, 'Task title', 120)));
 app.post<{ Params: { id: string } }>('/api/tasks/:id/interrupt', request => workspace.interrupt(request.params.id).then(() => ({ ok: true })));
@@ -89,11 +102,35 @@ app.get<{ Params: { id: string }; Querystring: { path?: string } }>('/api/projec
 app.post<{ Params: { id: string } }>('/api/projects/:id/git/commit', request => {
   const project = store.project(request.params.id), b = request.body as any;
   const message = string(b.message, 'Commit message', 5000), paths = Array.isArray(b.paths) ? b.paths.filter((p: unknown) => typeof p === 'string').slice(0, 5000) : [];
-  return serialGit(project.id, async () => ({ commit: await gitCommit(project.path, message, paths), git: await gitStatus(project.path) }));
+  return serialGit(project.id, () => workspace.exclusiveCommit(project.id, async () => ({ commit: await gitCommit(project.path, message, paths), git: await gitStatus(project.path) })));
+});
+const paths = (value: unknown): string[] => Array.isArray(value) ? value.filter((p: unknown): p is string => typeof p === 'string').slice(0, 5000) : [];
+// An agent writes a commit message for the chosen files; nothing is written.
+app.post<{ Params: { id: string } }>('/api/projects/:id/git/message', request => {
+  const b = request.body as any;
+  return workspace.commitMessage(store.project(request.params.id).id, paths(b.paths), { agent: b.agent === undefined ? undefined : agent(b.agent), model: typeof b.model === 'string' ? b.model : undefined });
+});
+// A merge in progress is resolved by an agent, committed, or abandoned.
+app.post<{ Params: { id: string } }>('/api/projects/:id/git/resolve', request => {
+  const project = store.project(request.params.id), b = request.body as any;
+  return serialGit(project.id, () => workspace.resolveConflicts(project.id, { agent: b.agent === undefined ? undefined : agent(b.agent), model: typeof b.model === 'string' ? b.model : undefined }));
+});
+app.post<{ Params: { id: string } }>('/api/projects/:id/git/finish', request => {
+  const project = store.project(request.params.id);
+  return serialGit(project.id, () => workspace.exclusiveCommit(project.id, async () => ({ commit: await gitFinishMerge(project.path), git: await gitStatus(project.path) })));
+});
+app.post<{ Params: { id: string } }>('/api/projects/:id/git/abort', request => {
+  const project = store.project(request.params.id);
+  return serialGit(project.id, async () => { await gitAbortMerge(project.path); return { git: await gitStatus(project.path) }; });
+});
+// Chosen untracked build files go into .gitignore by kind.
+app.post<{ Params: { id: string } }>('/api/projects/:id/git/ignore', request => {
+  const project = store.project(request.params.id);
+  return serialGit(project.id, async () => ({ git: await gitIgnore(project.path, paths((request.body as any).paths)) }));
 });
 app.post<{ Params: { id: string; action: string } }>('/api/projects/:id/git/:action', request => {
   const project = store.project(request.params.id), action = request.params.action;
-  if (action !== 'fetch' && action !== 'pull' && action !== 'push') throw Object.assign(new Error('Unknown Git action.'), { statusCode: 404 });
+  if (action !== 'fetch' && action !== 'pull' && action !== 'merge' && action !== 'push') throw Object.assign(new Error('Unknown Git action.'), { statusCode: 404 });
   return serialGit(project.id, async () => { await gitRemote(project.path, action); return { git: await gitStatus(project.path) }; });
 });
 app.post<{ Params: { id: string } }>('/api/projects/:id/manuscript', async request => ({ ...(await manuscripts.state(request.params.id, store.project(request.params.id).path, true)), annotations: store.annotations(request.params.id).filter(note => !note.taskId) }));
@@ -193,7 +230,13 @@ await app.listen({ host: '127.0.0.1', port: PORT });
 store.recover();
 console.log(`Papilot is running at http://127.0.0.1:${PORT}${PUBLIC_ORIGIN ? `\nRemote: ${PUBLIC_ORIGIN}` : ''}`);
 void workspace.connect();
-for (const task of store.tasks().filter(t => t.status === 'building')) { store.updateTask(task.id, { status: 'interrupted', error: 'The server restarted during the PDF build. Check the review and rebuild it if needed.' }); void workspace.refresh(task.id); }
+// Recompute cached feedback counts, including decisions from before this restart.
+for (const task of store.tasks()) {
+  if (task.status === 'building') {
+    store.updateTask(task.id, { status: 'interrupted', error: 'The server restarted during the PDF build. Check the review and rebuild it if needed.' });
+    void workspace.refresh(task.id);
+  } else if (task.review?.round && task.status !== 'deleting') void workspace.refresh(task.id);
+}
 let shuttingDown = false;
 for (const signal of ['SIGINT', 'SIGTERM']) process.on(signal, () => {
   if (shuttingDown) return; shuttingDown = true; workspace.close();

package/src/server/manuscript.ts

@@ -7,8 +7,9 @@ import path from 'node:path';
 import { promisify } from 'node:util';
 import { pathToFileURL } from 'node:url';
 import { ENGINE } from './paths.ts';
-import type { Annotation, GitStatus, ManuscriptBuild } from '../shared.ts';
+import type { Annotation, GitFile, GitStatus, ManuscriptBuild } from '../shared.ts';
 import { notesInstructions } from '../notes.ts';
+import { ignorePattern } from '../commit.ts';
 
 type Rect = [number, number, number, number];
 
@@ -57,8 +58,26 @@ export async function gitStatus(root: string): Promise<GitStatus> {
     git(root, ['remote']).catch(() => ''),
   ]);
   const [hash, subject, time] = head.trim().split('\0');
-  return { ...parseStatus(status, numstat), head: hash ? { hash, subject, date: Number(time) * 1000 } : null, remote: Boolean(remotes.trim()) };
+  const parsed = parseStatus(status, numstat), dir = gitDir(root);
+  // A merge in progress names the files whose conflict markers remain.
+  const merging = dir && fs.existsSync(path.join(dir, 'MERGE_HEAD'))
+    ? { message: readText(path.join(dir, 'MERGE_MSG')).split('\n')[0] || 'Merge', conflicts: parsed.files.filter(file => file.status === 'U' && conflictMarkers(root, file.path)).map(file => file.path) }
+    : null;
+  return { ...parsed, head: hash ? { hash, subject, date: Number(time) * 1000 } : null, remote: Boolean(remotes.trim()), merging };
 }
+const readText = (file: string) => { try { return fs.readFileSync(file, 'utf8'); } catch { return ''; } };
+// The repository's Git directory: .git, or where a .git file points.
+function gitDir(root: string) {
+  try {
+    const dot = path.join(root, '.git');
+    return fs.statSync(dot).isFile() ? path.resolve(root, readText(dot).replace(/^gitdir:\s*/, '').trim()) : dot;
+  } catch { return null; }
+}
+export function mergeInProgress(root: string) {
+  const dir = gitDir(root);
+  return Boolean(dir && fs.existsSync(path.join(dir, 'MERGE_HEAD')));
+}
+export const conflictMarkers = (root: string, file: string) => /^(?:<{7}|>{7})(?: |$)/m.test(readText(path.join(root, file)));
 
 // Paths from the browser are matched against the changed files, and Git reads
 // them literally, so a name cannot act as a pathspec pattern.
@@ -69,17 +88,51 @@ const DIFF_LIMIT = 400_000;
 export async function gitDiff(root: string, file: string) {
   const entry = (await gitStatus(root)).files.find(item => item.path === file);
   if (!entry) throw Object.assign(new Error('That file has no uncommitted changes.'), { statusCode: 404 });
-  const diff = entry.status === '?'
-    // `git diff --no-index` exits with 1 when the files differ.
-    ? await exec('git', ['diff', '--no-index', '--no-color', '--', '/dev/null', file], { cwd: root, maxBuffer: 64 * 1024 * 1024 }).then(r => r.stdout, (e: { stdout?: string }) => e.stdout || '')
-    : await git(root, ['diff', '--no-color', '--find-renames', 'HEAD', '--', ...(entry.from ? [entry.from] : []), file], literal);
+  const diff = await fileDiff(root, entry);
   return { path: file, diff: diff.slice(0, DIFF_LIMIT), truncated: diff.length > DIFF_LIMIT };
 }
+function fileDiff(root: string, entry: GitFile) {
+  return entry.status === '?'
+    // `git diff --no-index` exits with 1 when the files differ.
+    ? exec('git', ['diff', '--no-index', '--no-color', '--', '/dev/null', entry.path], { cwd: root, maxBuffer: 64 * 1024 * 1024 }).then(r => r.stdout, (e: { stdout?: string }) => e.stdout || '')
+    : git(root, ['diff', '--no-color', '--find-renames', 'HEAD', '--', ...(entry.from ? [entry.from] : []), entry.path], literal);
+}
+
+// What a commit message is written from: the chosen files' diffs, each
+// shortened so that a large change still fits, and the repository's recent
+// commit subjects, whose style and language the message follows.
+export async function commitChanges(root: string, paths: string[]) {
+  const files = (await gitStatus(root)).files.filter(item => paths.includes(item.path));
+  if (!files.length) throw new Error('Select at least one changed file.');
+  let patch = '';
+  for (const [index, file] of files.entries()) {
+    if (patch.length > 40_000) { patch += `\n[${files.length - index} more changed files are not shown.]\n`; break; }
+    const diff = await fileDiff(root, file);
+    patch += diff.length > 8_000 ? `${diff.slice(0, 8_000)}\n[The rest of this file's diff is not shown.]\n` : diff;
+  }
+  const recent = (await git(root, ['log', '-8', '--format=%s']).catch(() => '')).split('\n').filter(Boolean);
+  return { files, patch, recent };
+}
+
+// Adds the patterns for the chosen untracked build files to the repository's
+// .gitignore, one per kind of file and each only once, so they leave the list
+// of changes. The .gitignore is then a change to commit like any other.
+export async function gitIgnore(root: string, paths: string[]) {
+  const patterns = [...new Set((await gitStatus(root)).files.filter(item => item.status === '?' && paths.includes(item.path)).map(item => ignorePattern(item.path)).filter((pattern): pattern is string => Boolean(pattern)))];
+  if (!patterns.length) throw new Error('None of the chosen files is build output that can be ignored.');
+  const file = path.join(root, '.gitignore');
+  const current = fs.existsSync(file) ? fs.readFileSync(file, 'utf8') : '';
+  const present = new Set(current.split(/\r?\n/).map(line => line.trim()));
+  const missing = patterns.filter(pattern => !present.has(pattern) && !present.has('/' + pattern));
+  if (missing.length) fs.writeFileSync(file, `${current}${current && !current.endsWith('\n') ? '\n' : ''}${current.trim() ? '\n' : ''}# Build output\n${missing.join('\n')}\n`);
+  return gitStatus(root);
+}
 
 // Commit exactly the chosen files as they are on disk. Changes staged
 // elsewhere for other files stay staged and out of this commit.
 export async function gitCommit(root: string, message: string, paths: string[]) {
-  const files = (await gitStatus(root)).files.filter(item => paths.includes(item.path));
+  const status = await gitStatus(root), files = status.files.filter(item => paths.includes(item.path));
+  if (status.merging) throw new Error('Finish or abort the merge before committing other changes.');
   if (!files.length) throw new Error('Select at least one changed file to commit.');
   if (files.some(item => item.status === 'U')) throw new Error('Resolve the merge conflicts in the selected files before committing.');
   // A rename is already staged, so only its new path is added; the commit
@@ -91,13 +144,17 @@ export async function gitCommit(root: string, message: string, paths: string[])
 
 // Fetch, fast-forward pull and push use the host's Git credentials. Nothing
 // may prompt, so a missing credential fails instead of hanging.
-export async function gitRemote(root: string, action: 'fetch' | 'pull' | 'push') {
+export async function gitRemote(root: string, action: 'fetch' | 'pull' | 'merge' | 'push') {
   const status = await gitStatus(root);
   if (!status.remote) throw new Error('This repository has no remote.');
+  if (status.merging && action !== 'fetch') throw new Error('Finish or abort the merge first.');
   if (action === 'fetch') await gitAction(root, ['fetch', '--prune'], 120_000);
-  else if (action === 'pull') {
+  else if (action === 'pull' || action === 'merge') {
     if (!status.upstream) throw new Error('This branch does not track a remote branch yet.');
-    await gitAction(root, ['pull', '--ff-only'], 120_000);
+    // Pull only fast-forwards. Merge also joins a branch that has diverged
+    // from its upstream; conflicts leave the merge in progress to resolve.
+    if (action === 'pull') await gitAction(root, ['pull', '--ff-only'], 120_000);
+    else await gitAction(root, ['pull', '--no-rebase', '--ff', '--no-edit'], 120_000).catch(error => { if (!mergeInProgress(root)) throw error; });
   } else if (status.upstream) await gitAction(root, ['push'], 120_000);
   else {
     if (!status.branch) throw new Error('Check out a branch before pushing.');
@@ -106,6 +163,30 @@ export async function gitRemote(root: string, action: 'fetch' | 'pull' | 'push')
   }
 }
 
+// A merge in progress ends with its commit once no conflict markers remain,
+// or is abandoned, restoring the files as they were before it.
+export async function gitFinishMerge(root: string) {
+  const status = await gitStatus(root);
+  if (!status.merging) throw new Error('No merge is in progress.');
+  if (status.merging.conflicts.length) throw new Error(`Resolve the conflicts in ${status.merging.conflicts.join(', ')} first.`);
+  const resolved = status.files.filter(item => item.status === 'U').map(item => item.path);
+  if (resolved.length) await gitAction(root, ['add', '-A', '--', ...resolved]);
+  await gitAction(root, ['commit', '--no-edit']);
+  return (await git(root, ['rev-parse', '--short', 'HEAD'])).trim();
+}
+export async function gitAbortMerge(root: string) {
+  if (!mergeInProgress(root)) throw new Error('No merge is in progress.');
+  await gitAction(root, ['merge', '--abort']);
+}
+// What an agent needs to resolve a merge's conflicts: the files with markers
+// and the commits on each side.
+export async function mergeConflicts(root: string) {
+  const status = await gitStatus(root);
+  if (!status.merging) throw new Error('No merge is in progress.');
+  const subjects = async (range: string) => (await git(root, ['log', '-12', '--format=%s', range]).catch(() => '')).split('\n').filter(Boolean);
+  return { files: status.merging.conflicts, branch: status.branch || 'HEAD', upstream: status.upstream || 'the remote branch', ours: await subjects('MERGE_HEAD..HEAD'), theirs: await subjects('HEAD..MERGE_HEAD') };
+}
+
 // Git's own message, without the usage noise, becomes the error the user sees.
 async function gitAction(root: string, args: string[], timeout = 60_000) {
   try { return (await exec('git', args, { cwd: root, timeout, env: { ...process.env, ...literal, GIT_TERMINAL_PROMPT: '0' }, maxBuffer: 64 * 1024 * 1024 })).stdout; }

package/src/server/review.ts

@@ -34,7 +34,8 @@ export function annotateReviewState(value: unknown, tasks: readonly Task[]): unk
   else if (task.status === 'building') decisionLock = 'Wait for the PDF build before accepting, rejecting, or undoing changes. You can still add comments.';
   else if (['running', 'waiting_input', 'queued'].includes(task.status)) decisionLock = 'Pause this task in Papilot before accepting, rejecting, or undoing changes. You can still add comments.';
   else if (task.pendingReview) decisionLock = 'Wait for the current review action before accepting, rejecting, or undoing changes. You can still add comments.';
-  return { ...state, decisionLock, commentLock };
+  // Changes the task has committed are in the manuscript too.
+  return { ...state, decisionLock, commentLock, ...(task ? { workspace: { status: task.status, unsent: task.review?.unsent ?? 0, comments: task.review?.comments ?? 0, accepted: task.review?.files?.length || (task.committed ? 1 : 0) } } : {}) };
 }
 
 export function allowedReviewRoute(route: string, method: string): boolean {

package/src/server/service-environment.ts

@@ -0,0 +1,22 @@
+import path from 'node:path';
+
+/** launchd has no login shell. Keep the tool choices made by the installer. */
+export function serviceEnvironment(
+  root: string, home: string, executable: string,
+  inherited: NodeJS.ProcessEnv, previous: NodeJS.ProcessEnv = {},
+): Record<string, string> {
+  // An explicit empty value clears a previously saved override.
+  const toolPath = inherited.PAPILOT_SERVICE_PATH ?? previous.PAPILOT_SERVICE_PATH ?? '';
+  const directories = [
+    ...toolPath.split(path.delimiter),
+    path.dirname(executable), path.join(root, 'node_modules/.bin'),
+    ...(inherited.PATH || '').split(path.delimiter),
+    '/Library/TeX/texbin', '/opt/homebrew/bin', '/usr/local/bin', '/usr/bin', '/bin', '/usr/sbin', '/sbin',
+  ].filter(directory => path.isAbsolute(directory));
+  const env: Record<string, string> = {
+    PATH: [...new Set(directories)].join(path.delimiter), HOME: home, NODE_ENV: 'production',
+  };
+  for (const [key, value] of Object.entries(inherited)) if (key.startsWith('PAPILOT_') && value) env[key] = value;
+  if (toolPath) env.PAPILOT_SERVICE_PATH = toolPath;
+  return env;
+}