papilot 0.2.0 → 0.4.0

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; }
@@ -129,13 +210,13 @@ export async function workingTree(root: string) {
 }
 
 async function engine() {
-  const [{ Builder }, { Repo }, { loadProject }, { mupdf, PdfDocument, containsCenter }] = await Promise.all([
+  const [{ Builder }, { Repo }, { 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, loadProject, mupdf, PdfDocument, containsCenter };
+  return { Builder, Repo, loadProject, mupdf, PdfDocument, containsCenter, walkText };
 }
 
 // `synctex edit` maps a PDF position (big points from the top-left corner) to
@@ -212,7 +293,7 @@ export function sourceExcerpt(file: string, [start, end]: [number, number], limi
 // the page's top left. pdf.js lays a whole line out in a stand-in font and
 // drifts from the printed words mid-line; per-word runs cannot drift.
 export async function pdfWords(pdf: string, page: number) {
-  const { PdfDocument } = await engine();
+  const { PdfDocument, walkText } = await engine();
   const document = new PdfDocument(pdf);
   try {
     if (!Number.isInteger(page) || page < 0 || page >= document.length) throw Object.assign(new Error('That page is not part of the manuscript.'), { statusCode: 400 });
@@ -220,7 +301,7 @@ export async function pdfWords(pdf: string, page: number) {
     const words: { text: string; left: number; right: number; baseline: number; size: number; eol: boolean }[] = [];
     let word: (typeof words)[number] | null = null;
     const text = raw.toStructuredText('preserve-whitespace');
-    text.walk({
+    walkText(text, {
       beginLine: () => { word = null; },
       onChar: (c: string, origin: [number, number], _font: unknown, size: number, quad: number[]) => {
         if (/\s/u.test(c)) { word = null; return; }

package/src/server/paths.ts

@@ -8,4 +8,8 @@ export const VERSION: string = JSON.parse(fs.readFileSync(path.join(ROOT, 'packa
 export const PORT = Number(process.env.PAPILOT_PORT || 7274);
 export const PUBLIC_ORIGIN = process.env.PAPILOT_PUBLIC_ORIGIN || '';
 export const OWNER = process.env.PAPILOT_TAILSCALE_LOGIN || '';
+// The public URL where invited people sign in with passkeys, and the local
+// port its proxy (such as Tailscale Funnel) forwards to.
+export const ACCOUNT_ORIGIN = (process.env.PAPILOT_ACCOUNT_ORIGIN || '').replace(/\/+$/, '');
+export const ACCOUNT_PORT = Number(process.env.PAPILOT_ACCOUNT_PORT || 7275);
 export const CODEX = process.env.PAPILOT_CODEX_BIN || (fs.existsSync(path.join(ROOT, 'node_modules/.bin/codex')) ? path.join(ROOT, 'node_modules/.bin/codex') : 'codex');

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, ...(task ? { workspace: { status: task.status, unsent: task.review?.unsent ?? 0, comments: task.review?.comments ?? 0, accepted: task.review?.files?.length ?? 0 } } : {}) };
+  // 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/security.ts

@@ -13,3 +13,23 @@ export function authorize(headers: IncomingHttpHeaders, remoteAddress: string |
   if (headers.origin && headers.origin !== publicOrigin) return 'The request origin does not match.';
   return null;
 }
+
+// The public sign-in URL needs its own port, an exact HTTPS origin (plain HTTP
+// only on localhost, for testing), and must not be the tailnet endpoint, whose
+// requests are trusted as the owner.
+export function accountProblem(accountOrigin: string, accountPort: number, port: number, publicOrigin: string): string | null {
+  if (!accountOrigin) return null;
+  let url: URL;
+  try { url = new URL(accountOrigin); } catch { return `PAPILOT_ACCOUNT_ORIGIN is not a URL: ${accountOrigin}`; }
+  if (url.origin !== accountOrigin) return `PAPILOT_ACCOUNT_ORIGIN must be an origin without a path, such as ${url.origin}.`;
+  if (url.protocol !== 'https:' && !(url.protocol === 'http:' && url.hostname === 'localhost')) return 'PAPILOT_ACCOUNT_ORIGIN must use https://.';
+  if (!Number.isInteger(accountPort) || accountPort < 1 || accountPort > 65535 || accountPort === port) return `PAPILOT_ACCOUNT_PORT must be a free port other than ${port}.`;
+  if (publicOrigin && new URL(publicOrigin).host === url.host) return 'PAPILOT_ACCOUNT_ORIGIN must differ from PAPILOT_PUBLIC_ORIGIN, the tailnet address; use another port, such as :10000.';
+  return null;
+}
+// HSTS on the public address covers every port of its host name, so it is
+// left off when the tailnet endpoint on that host uses plain HTTP.
+export function accountHsts(accountOrigin: string, publicOrigin: string) {
+  const account = new URL(accountOrigin);
+  return account.protocol === 'https:' && !(publicOrigin.startsWith('http:') && new URL(publicOrigin).hostname === account.hostname);
+}

package/src/server/store.ts

@@ -17,6 +17,11 @@ export class Store extends EventEmitter {
       CREATE TABLE IF NOT EXISTS items(id TEXT PRIMARY KEY, task_id TEXT NOT NULL, created INTEGER NOT NULL, data TEXT NOT NULL);
       CREATE TABLE IF NOT EXISTS deleted_tasks(id TEXT PRIMARY KEY, deleted INTEGER NOT NULL);
       CREATE TABLE IF NOT EXISTS annotations(id TEXT PRIMARY KEY, project_id TEXT NOT NULL, data TEXT NOT NULL);
+      CREATE TABLE IF NOT EXISTS users(id TEXT PRIMARY KEY, data TEXT NOT NULL);
+      CREATE TABLE IF NOT EXISTS credentials(id TEXT PRIMARY KEY, user_id TEXT NOT NULL, data TEXT NOT NULL);
+      CREATE TABLE IF NOT EXISTS invites(token_hash TEXT PRIMARY KEY, user_id TEXT NOT NULL, expires INTEGER NOT NULL, data TEXT NOT NULL);
+      CREATE TABLE IF NOT EXISTS sessions(token_hash TEXT PRIMARY KEY, id TEXT UNIQUE NOT NULL, user_id TEXT NOT NULL, expires INTEGER NOT NULL, data TEXT NOT NULL);
+      CREATE TABLE IF NOT EXISTS members(project_id TEXT NOT NULL, user_id TEXT NOT NULL, PRIMARY KEY(project_id, user_id));
       CREATE INDEX IF NOT EXISTS task_items ON items(task_id,created);
       CREATE INDEX IF NOT EXISTS task_runs ON runs(task_id,status);`);
   }

package/src/server/workspace.ts

@@ -1,4 +1,4 @@
-import { randomUUID } from 'node:crypto';
+import { createHash, randomUUID } from 'node:crypto';
 import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
 import fs from 'node:fs';
@@ -10,8 +10,10 @@ import { AGENT_NAMES, AntigravityAgent, ClaudeAgent, type AgentRuntime } from '.
 import { reviewClient, taskRoute, confirmedReviewResponse, type ReviewClient } from './review.ts';
 import { VERSION } from './paths.ts';
 import { findSkill, type SkillFile } from './skills.ts';
-import { reviewInstructions, skillPrompt, summarizeFeedback } from '../conversation.ts';
-import type { Task, Run, TimelineItem, PendingRequest, RuntimeStatus, Snapshot, PendingReview, AgentModel, Usage, AgentId, MessageMeta, FeedbackSummary } from '../shared.ts';
+import { buildFixPrompt, reviewInstructions, skillPrompt, summarizeFeedback } from '../conversation.ts';
+import { commitMessageFrom } from '../commit.ts';
+import { commitChanges, conflictMarkers, gitCommit, gitRemote, gitStatus, mergeConflicts, mergeInProgress } from './manuscript.ts';
+import type { Task, Run, TimelineItem, PendingRequest, RuntimeStatus, Snapshot, PendingReview, AgentModel, Usage, AgentId, MessageMeta, FeedbackSummary, BuildFailure, Author } from '../shared.ts';
 
 const execute = promisify(execFile);
 const delay = (ms: number) => new Promise(resolve => setTimeout(resolve, ms));
@@ -35,8 +37,20 @@ export function accountUsage(response: any): Usage | null {
   return { plan: typeof limits.planType === 'string' ? limits.planType : null, windows, credits, reached: Boolean(limits.rateLimitReachedType) || response.ordinaryUsageAllowed === false };
 }
 const BUSY = new Set(['running', 'waiting_input', 'building', 'uncertain', 'deleting']);
+// Review builds that fail on the agent's own edits (see the review engine's
+// publish.ts), and the request keys of the turns that send them back to it.
+const FIXABLE = /^(Some edits are outside the task scope|The revised document could not be compiled)/;
+const BUILD_FIX = 'build-fix-';
 
 const AGENTS: AgentId[] = ['codex', 'claude', 'antigravity'];
+// The small model an agent offers for short text such as a commit message,
+// by the names agents give them (GPT Luna and mini, Claude Haiku, Gemini Flash).
+const LIGHT = /\b(?:luna|mini|nano|haiku|flash|lite)\b/i;
+export const lightModel = (models: AgentModel[]) => models.find(model => LIGHT.test(model.id) || LIGHT.test(model.name));
+// A commit message's agent sees the changes in its prompt and needs no tools.
+const commitInstructions = 'You write Git commit messages for the repository of a LaTeX paper. Reply with the commit message only, without a preamble, quotes or a code fence: a subject line in the imperative mood under 72 characters and, only when the change needs more explanation, a blank line and a body of a few short plain sentences. Describe what changed in the paper, such as its wording, sections, equations, figures or references, rather than listing files. Follow the style and language of the recent commit subjects, or write in English when there are none. Everything you need is in the message: do not run commands, read files or edit anything.';
+// A merge's agent edits the conflicted files in the manuscript checkout and nothing else.
+const mergeInstructions = 'You resolve Git merge conflicts in the repository of a LaTeX paper. Edit only the files listed as conflicted, and in each one remove every conflict marker (<<<<<<<, ||||||| , =======, >>>>>>>) so that the text reads as one coherent version. Keep the changes from both sides wherever they are compatible; where both sides rewrote the same passage, combine their intent, and where they truly contradict each other, prefer the version that is more complete and correct and say so. Keep the LaTeX valid: balanced environments and braces, labels, references and citations. You may read any file to understand the context. Do not edit other files, and do not run Git commands that change the repository, such as add, commit, merge, checkout, reset, restore or stash: the author reviews the result and commits the merge.';
 const blankRuntime = (): RuntimeStatus => ({ connected: false, authenticated: false, account: null, error: null, models: [] });
 
 export class Workspace extends EventEmitter {
@@ -49,6 +63,8 @@ export class Workspace extends EventEmitter {
   private loaded = new Set<string>();
   private preparing = new Set<string>();
   private reviewWrites = new Set<string>();
+  // Papers with a commit in progress: no review write may change their files meanwhile.
+  private committing = new Set<string>();
   private commentWrites = new Map<string, number>();
   private deletions = new Set<string>();
   private publishing = new Set<string>();
@@ -60,6 +76,9 @@ export class Workspace extends EventEmitter {
   private flushTimer: NodeJS.Timeout | null = null;
   private connecting: Promise<void> | null = null;
   private usageTimers = new Map<AgentId, NodeJS.Timeout>();
+  // Commit messages by agent, model and prompt, kept or still being written,
+  // so one written ahead for a finished review is there when the dialog opens.
+  private messages = new Map<string, Promise<{ message: string; agent: AgentId }>>();
   constructor(public store: Store, public codex: AgentRuntime = new Codex(), private concurrency = 2, private connectReview = reviewClient, others: Partial<Record<AgentId, AgentRuntime>> = {}) {
     super();
     this.agents = { codex, claude: others.claude || new ClaudeAgent(), antigravity: others.antigravity || new AntigravityAgent() };
@@ -125,10 +144,12 @@ export class Workspace extends EventEmitter {
     this.store.saveProject(project); return project;
   }
   // A task can start from a skill; its instructions are then the author's own words, possibly none.
-  async createTask(input: { projectId: string; title: string; instructions: string; skill?: string; agent?: AgentId; model?: string; effort?: string; id: string }) {
+  async createTask(input: { projectId: string; title: string; instructions: string; skill?: string; agent?: AgentId; model?: string; effort?: 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.');
-    const existing = this.store.tasks().find(t => t.id === input.id); if (existing) return existing;
+    // 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) throw new Error('Invalid task ID.'); return existing; }
     if (this.preparing.has(input.id)) throw new Error('This task is being created. Refresh in a moment.');
     this.preparing.add(input.id);
     try {
@@ -141,13 +162,14 @@ export class Workspace extends EventEmitter {
         worktree: info.worktree, threadId: null, turnId: null, agent: input.agent || 'codex', model: input.model || null, effort: input.effort || null, status: 'idle',
         createdAt: Date.now(), updatedAt: Date.now(), feedbackCursor: 0, error: null, review: null };
       this.store.saveTask(task);
-      await this.enqueue(task.id, input.instructions, 'initial-' + task.id, false, { skill });
+      await this.enqueue(task.id, input.instructions, 'initial-' + task.id, false, { skill, author: input.author });
       return this.store.task(task.id);
     } finally { this.preparing.delete(input.id); }
   }
-  // The author's message, a skill run with or without one, or the review
-  // feedback alone. The chat keeps what the author did; the agent gets the prompt.
-  async enqueue(taskId: string, text: string, requestKey: string, includeFeedback = true, options: { skill?: SkillFile; feedback?: boolean } = {}) {
+  // The author's message, a skill run with or without one, the review
+  // feedback alone, or a build the agent broke. The chat keeps what happened;
+  // the agent gets the prompt.
+  async enqueue(taskId: string, text: string, requestKey: string, includeFeedback = true, options: { skill?: SkillFile; feedback?: boolean; build?: BuildFailure; author?: Author } = {}) {
     const task = this.store.task(taskId);
     if (task.status === 'deleting') throw new Error('This task is being deleted.');
     const existing = this.store.runByKey(requestKey);
@@ -155,7 +177,7 @@ export class Workspace extends EventEmitter {
     if (task.status === 'uncertain') throw new Error('Check the task status before sending more instructions.');
     const pauseVersion = task.pauseVersion || 0;
     if (this.store.runs().some(r => r.taskId === taskId && r.status === 'queued')) throw new Error('This task already has queued instructions. Wait or pause it first.');
-    let prompt = options.feedback ? reviewInstructions : options.skill ? skillPrompt(options.skill, text) : text.trim(), cursor = task.feedbackCursor;
+    let prompt = options.build ? buildFixPrompt(options.build) : options.feedback ? reviewInstructions : options.skill ? skillPrompt(options.skill, text) : text.trim(), cursor = task.feedbackCursor;
     let summary: FeedbackSummary | undefined;
     if (includeFeedback) {
       const client = await this.connectReview(this.store.project(task.projectId).path);
@@ -166,7 +188,7 @@ export class Workspace extends EventEmitter {
       if (task.error) prompt += '\n\nLatest task/review error:\n' + task.error + '\nThe latest accepted manuscript is at ' + this.store.project(task.projectId).path + '. You may read it to understand accepted changes, but must only edit your isolated task worktree. Prepare a revised proposal for another review; never write to or accept changes in the manuscript checkout.';
     }
     const run: Run = { id: randomUUID(), taskId, requestKey, prompt, feedbackCursor: cursor, status: 'queued', createdAt: Date.now(), finishedAt: null };
-    const meta: MessageMeta = { ...(options.skill ? { skill: { id: options.skill.id, name: options.skill.name } } : {}), ...(summary ? { feedback: summary } : {}), ...(options.feedback ? { sendsFeedback: true } : {}) };
+    const meta: MessageMeta = { ...(options.skill ? { skill: { id: options.skill.id, name: options.skill.name } } : {}), ...(summary ? { feedback: summary } : {}), ...(options.feedback ? { sendsFeedback: true } : {}), ...(options.build ? { build: options.build } : {}), ...(options.author ? { author: options.author } : {}) };
     const saved = this.store.transaction(() => {
       // Feedback loading yields to other requests. Recheck identity, queue, and
       // task status together before committing; none of the earlier reads own a lock.
@@ -182,7 +204,7 @@ export class Workspace extends EventEmitter {
       if (current.status === 'uncertain') throw new Error('Check the task status before sending more instructions.');
       this.store.saveRun(run);
       if (!BUSY.has(current.status)) this.store.updateTask(taskId, { status: 'queued', error: null });
-      this.store.saveItem({ id: run.id, taskId, type: 'user', text: options.feedback ? '' : text.trim(), createdAt: run.createdAt, ...(Object.keys(meta).length ? { meta } : {}) });
+      this.store.saveItem({ id: run.id, taskId, type: 'user', text: options.feedback || options.build ? '' : text.trim(), createdAt: run.createdAt, ...(Object.keys(meta).length ? { meta } : {}) });
       return run;
     });
     this.schedule();
@@ -205,12 +227,20 @@ export class Workspace extends EventEmitter {
       void this.startRun(run).catch(e => this.failRun(run, e));
     }
   }
-  private instructions(task: Task) {
+  // The paths a task's review covers, or none when it covers the whole worktree.
+  private async reviewScope(task: Task): Promise<string[]> {
+    try {
+      const client = await this.connectReview(this.store.project(task.projectId).path);
+      const files: string[] = (await client.get(taskRoute(task.name))).scope?.files || [];
+      return files.some(file => file === '' || file === '.') ? [] : files;
+    } catch { return []; }
+  }
+  private instructions(task: Task, scope: string[] = []) {
     return `You are ${this.agentOf(task) === 'codex' ? 'the official Codex agent' : AGENT_NAMES[this.agentOf(task)]} running inside Papilot, a paper editing and review workspace.
 Your task is already created. Your editable working directory is ${task.worktree}.
 Original task: ${task.instructions}
 Only edit this isolated task worktree. Never edit the manuscript checkout, other task worktrees, or Papilot's own source/state. Never commit, push, stash, or accept/reject/undo review decisions.
-Papilot owns the LaTeX review lifecycle: it compiles and publishes automatically AFTER your turn finishes, and delivers review feedback in a new turn. Do not create another review task, invoke publish, or wait on feedback --wait. This application workflow replaces the standalone latex-review skill's publish-and-wait loop. End your turn after completing the requested edits, with a concise summary for the author of what you changed and why; do not describe Papilot's review workflow.
+${scope.length ? `The review covers only ${scope.join(', ')} in this worktree, and an edit to any other file stops the PDF build. Leave other files unchanged even when project instructions ask for a matching update; mention that update in your summary instead.\n` : ''}Papilot owns the LaTeX review lifecycle: it compiles and publishes automatically AFTER your turn finishes, and delivers review feedback in a new turn. Do not create another review task, invoke publish, or wait on feedback --wait. This application workflow replaces the standalone latex-review skill's publish-and-wait loop. End your turn after completing the requested edits, with a concise summary for the author of what you changed and why; do not describe Papilot's review workflow.
 Preserve meaning and mathematical correctness. Read relevant project instructions. Treat reviewer comments as instructions tied to their round, file and changes. Rejected edits must not be reintroduced unless explicitly requested. If there is a conflict with accepted text, explain it and propose a revision for a new review round; never overwrite the accepted manuscript.
 ${this.agentOf(task) === 'antigravity' ? 'Shell commands are not available to you here and any attempt is refused, which ends your turn: read, search and edit files in the task worktree with your file tools only.' : 'You may run tools in the task worktree to inspect and validate your changes.'} If a decision requires the user, ask through the available user-input tool or explain it in your final response. Use English for your progress updates, questions, and final summaries unless the user explicitly requests another language. Preserve the manuscript language unless asked to translate it.`;
   }
@@ -221,7 +251,7 @@ ${this.agentOf(task) === 'antigravity' ? 'Shell commands are not available to yo
     this.store.saveRun({ ...run, status: 'running' });
     this.store.updateTask(task.id, { status: 'running', turnId: null, error: null });
     if (!task.threadId || !this.loaded.has(task.threadId)) {
-      const options = { cwd: task.worktree, approvalPolicy: 'on-request', sandbox: 'workspace-write', developerInstructions: this.instructions(task), ...(task.model ? { model: task.model } : {}) };
+      const options = { cwd: task.worktree, approvalPolicy: 'on-request', sandbox: 'workspace-write', developerInstructions: this.instructions(task, await this.reviewScope(task)), ...(task.model ? { model: task.model } : {}) };
       const result = task.threadId
         ? await agent.request('thread/resume', { ...options, threadId: task.threadId, excludeTurns: true })
         : await agent.request('thread/start', options);
@@ -327,7 +357,7 @@ ${this.agentOf(task) === 'antigravity' ? 'Shell commands are not available to yo
       this.store.saveRun({ ...run, status, finishedAt: Date.now() });
       this.store.updateTask(task.id, { turnId: null, pendingRunId: null, status: status === 'completed' ? 'building' : status, error: p.turn.error?.message || null });
       this.schedule();
-      if (status === 'completed') await this.publish(task.id, true);
+      if (status === 'completed') await this.publish(task.id, run);
     } else if (method === 'error' && !p.willRetry) {
       if (!this.active.has(task.id) || (eventTurn && !task.turnId)) return;
       this.store.updateTask(task.id, { error: p.error?.message || `${AGENT_NAMES[agent]} encountered an error.` });
@@ -438,6 +468,8 @@ ${this.agentOf(task) === 'antigravity' ? 'Shell commands are not available to yo
       }
     }
     if (this.active.has(taskId) || this.publishing.has(taskId) || BUSY.has(task.status) || task.status === 'queued') throw new Error('Pause the task before accepting, rejecting, or undoing changes. Wait for any PDF build to finish.');
+    if (this.committing.has(task.projectId)) throw new Error('A commit is in progress. Try again when it finishes.');
+    if (mergeInProgress(this.store.project(task.projectId).path)) throw new Error('Finish or abort the merge in the Git panel before accepting, rejecting, or undoing changes.');
     if (this.reviewWrites.has(taskId)) throw new Error('A review action is already in progress. Wait for it to finish.');
     this.reviewWrites.add(taskId);
     if (pending) this.store.updateTask(taskId, { pendingReview: { ...pending, previousStatus: task.status } });
@@ -451,17 +483,19 @@ ${this.agentOf(task) === 'antigravity' ? 'Shell commands are not available to yo
     }
     finally { this.reviewWrites.delete(taskId); this.schedule(); }
   }
-  publish(taskId: string, automatic = false): Promise<void> {
-    const task = this.store.task(taskId);
+  // A build is automatic after the agent's run `after` completes. When its
+  // edits break the build, the agent gets the error in a new turn, once.
+  publish(taskId: string, after?: Run): Promise<void> {
+    const task = this.store.task(taskId), automatic = Boolean(after);
     if (task.status === 'deleting') throw new Error('This task is being deleted.');
     if (this.active.has(taskId)) throw new Error('Pause Codex before building a review.');
     if (this.reviewWrites.has(taskId)) throw new Error('Wait for the current review action before building a review.');
     if (this.publishing.has(taskId) || (!automatic && (BUSY.has(task.status) || task.status === 'queued'))) throw new Error('This task is busy. Wait for it to finish or pause it first.');
     this.publishing.add(taskId);
     this.store.updateTask(taskId, { status: 'building', error: null });
-    return this.buildReview(task).finally(() => { this.publishing.delete(taskId); this.schedule(); });
+    return this.buildReview(task, Boolean(after && !after.requestKey.startsWith(BUILD_FIX))).finally(() => { this.publishing.delete(taskId); this.schedule(); });
   }
-  private async buildReview(task: Task) {
+  private async buildReview(task: Task, sendBack: boolean) {
     const taskId = task.id;
     try {
       const client = await this.connectReview(this.store.project(task.projectId).path);
@@ -472,7 +506,15 @@ ${this.agentOf(task) === 'antigravity' ? 'Shell commands are not available to yo
         const summary = await client.get(taskRoute(task.name));
         this.store.updateTask(taskId, { review: { ...this.store.task(taskId).review, state: summary.state, round: summary.round, counts: summary.counts, job: current } });
         if (current.status === 'done' || current.status === 'completed' || current.status === 'succeeded') break;
-        if (current.status === 'failed') throw new Error([current.error, ...(current.details || [])].filter(Boolean).join('\n') || 'PDF build failed.');
+        if (current.status === 'failed') {
+          const failure: BuildFailure = { error: current.error || 'PDF build failed.', details: current.details || [], ...(current.log ? { log: current.log } : {}) };
+          // Instructions the author queued meanwhile go first; the build after them sends any error that remains.
+          if (sendBack && FIXABLE.test(failure.error) && await this.enqueue(taskId, '', BUILD_FIX + job.job, false, { build: failure }).then(() => true, () => false)) {
+            this.store.updateTask(taskId, { status: 'queued', error: null });
+            return;
+          }
+          throw new Error([failure.error, ...failure.details].join('\n'));
+        }
         await delay(1500);
       }
       this.store.updateTask(taskId, { status: this.store.runs().some(r => r.taskId === taskId && r.status === 'queued') ? 'queued' : 'reviewing', error: null });
@@ -486,7 +528,7 @@ ${this.agentOf(task) === 'antigravity' ? 'Shell commands are not available to yo
       const project = this.store.project(task.projectId), client = await this.connectReview(project.path);
       const summary = await client.get(taskRoute(task.name));
       const { unsent, comments } = await this.unsentReviewFeedback(client, this.store.task(taskId));
-      const files = await acceptedFiles(project.path, task.name);
+      const files = await acceptedFiles(project.path, task.name, task.committed?.accepted);
       const current = this.store.task(taskId);
       if (current.status !== 'deleting') this.store.updateTask(taskId, { review: { state: summary.state, round: summary.round, counts: summary.counts, job: current.review?.job, unsent, comments, files } });
     } catch { /* The task remains visible even if its project is temporarily unavailable. */ }
@@ -500,6 +542,126 @@ ${this.agentOf(task) === 'antigravity' ? 'Shell commands are not available to yo
     const items = feedback.feedback || [];
     return { unsent: items.length, comments: items.filter(item => item.kind === 'comment' || item.kind === 'note').length };
   }
+  // The agent that writes a commit message or resolves a merge: the one the
+  // author chose, or else the first that is signed in, with the chosen model
+  // or the default one; light asks for the agent's small model when it has one.
+  private helper(choice: { agent?: AgentId; model?: string }, task: string, light = false) {
+    const usable = (id: AgentId) => this.agents[id].ready && this.runtimes[id].authenticated;
+    const id = choice.agent && usable(choice.agent) ? choice.agent : AGENTS.find(usable);
+    if (!id) throw new Error(`Sign in to Codex, Claude or Antigravity to ${task}.`);
+    const models = this.runtimes[id].models;
+    return { id, model: (light ? lightModel(models) : undefined) || models.find(item => item.id === choice.model) || models.find(item => item.isDefault) };
+  }
+  // One turn on a thread the agent does not keep, outside any task: its
+  // reply is returned and no chat shows it.
+  private async oneOff(id: AgentId, options: { cwd: string; sandbox: 'read-only' | 'workspace-write'; instructions: string; prompt: string; model?: AgentModel; effort?: string | null; timeout: number; what: string }) {
+    const agent = this.agents[id], name = AGENT_NAMES[id];
+    const thread = await agent.request('thread/start', { cwd: options.cwd, approvalPolicy: 'never', sandbox: options.sandbox, ephemeral: true, developerInstructions: options.instructions, ...(options.model ? { model: options.model.id } : {}) });
+    const threadId = thread.thread.id;
+    return new Promise<string>((resolve, reject) => {
+      let text = '', turnId = '';
+      const listen = (message: any) => {
+        const p = message.params || {};
+        if (p.threadId !== threadId) return;
+        if (message.method === 'item/completed' && p.item?.type === 'agentMessage') text = p.item.text || text;
+        else if (message.method === 'turn/completed') finish(p.turn?.status === 'completed' ? null : new Error(p.turn?.error?.message || `${name} stopped before it could ${options.what}.`));
+      };
+      const timer = setTimeout(() => {
+        if (turnId) agent.request('turn/interrupt', { threadId, turnId }).catch(() => undefined);
+        finish(new Error(`${name} did not ${options.what} in time. Try again.`));
+      }, options.timeout);
+      const finish = (error: Error | null) => { clearTimeout(timer); agent.off('notification', listen); if (error) reject(error); else resolve(text); };
+      agent.on('notification', listen);
+      agent.request('turn/start', { threadId, input: [{ type: 'text', text: options.prompt }], cwd: options.cwd, ...(options.effort ? { effort: options.effort } : {}) })
+        .then(result => { turnId = result?.turn?.id || ''; }, error => finish(error instanceof Error ? error : new Error(String(error))));
+    });
+  }
+  // Writes a commit message for the chosen manuscript files, like Cursor's
+  // generate button: one read-only turn on the agent's small model, with the
+  // lightest reasoning it offers. The same changes get the message already
+  // written, or being written, for them unless the author asks for a fresh one.
+  async commitMessage(projectId: string, paths: string[], choice: { agent?: AgentId; fresh?: boolean } = {}) {
+    const project = this.store.project(projectId), { id, model } = this.helper(choice, 'write a commit message', true);
+    const { files, patch, recent } = await commitChanges(project.path, paths);
+    const tasks = this.store.tasks().filter(task => task.projectId === projectId && task.review?.files?.some(file => paths.includes(file))).map(task => task.title);
+    const prompt = [
+      recent.length ? `Recent commit subjects in this repository:\n${recent.map(subject => `- ${subject}`).join('\n')}` : 'This repository has no commits yet.',
+      tasks.length ? `Papilot tasks whose accepted changes are in these files:\n${tasks.map(title => `- ${title}`).join('\n')}` : '',
+      `Changed files:\n${files.map(file => `${file.status === '?' ? 'A' : file.status} ${file.from ? `${file.from} -> ` : ''}${file.path}`).join('\n')}`,
+      `Diff:\n${patch}`,
+    ].filter(Boolean).join('\n\n');
+    const key = createHash('sha256').update(`${id}\0${model?.id ?? ''}\0${prompt}`).digest('hex'), kept = this.messages.get(key);
+    if (kept && !choice.fresh) return kept;
+    const written = this.oneOff(id, { cwd: project.path, sandbox: 'read-only', instructions: commitInstructions, prompt, model, effort: model?.efforts[0], timeout: 120000, what: 'write a commit message' }).then(reply => {
+      const message = commitMessageFrom(reply);
+      if (!message) throw new Error(`${AGENT_NAMES[id]} did not return a commit message. Try again.`);
+      return { message, agent: id };
+    });
+    // Only the latest few messages are kept, and never a failed one.
+    this.messages.delete(key); this.messages.set(key, written);
+    for (const old of this.messages.keys()) { if (this.messages.size <= 20) break; this.messages.delete(old); }
+    written.catch(() => { if (this.messages.get(key) === written) this.messages.delete(key); });
+    return written;
+  }
+  // A finished review offers to commit what it accepted, so after the
+  // author's last decision its commit message is written ahead.
+  async prepareCommitMessage(taskId: string) {
+    try {
+      const task = this.store.task(taskId), files = task.review?.files || [];
+      if (task.status !== 'reviewing' || task.review?.counts?.pending || !files.length) return;
+      const project = this.store.project(task.projectId), git = await gitStatus(project.path);
+      const paths = git.merging ? [] : files.filter(file => git.files.some(item => item.path === file));
+      if (paths.length) await this.commitMessage(project.id, paths, { agent: this.agentOf(task) });
+    } catch { /* The commit dialog writes the message when it opens. */ }
+  }
+  // Resolves a merge's conflicts in the manuscript checkout itself: the agent
+  // edits only the conflicted files, at the model's default reasoning, and
+  // leaves committing the merge to the author once they have read the diffs.
+  async resolveConflicts(projectId: string, choice: { agent?: AgentId; model?: string } = {}) {
+    const project = this.store.project(projectId), { id, model } = this.helper(choice, 'resolve conflicts');
+    const { files, branch, upstream, ours, theirs } = await mergeConflicts(project.path);
+    if (!files.length) throw new Error('No file has conflict markers left. Commit the merge.');
+    const list = (items: string[]) => items.length ? items.map(item => `- ${item}`).join('\n') : '- (none listed)';
+    const prompt = [
+      `${branch} is being merged with ${upstream} in ${project.path}, and these files have conflicts:\n${list(files)}`,
+      `Commits on ${branch} since the two diverged:\n${list(ours)}`,
+      `Commits from ${upstream} being merged in:\n${list(theirs)}`,
+      'Resolve every conflict in those files, then reply with a short summary for the author: how you resolved each conflict, and any place where you had to choose one side.',
+    ].join('\n\n');
+    const summary = await this.oneOff(id, { cwd: project.path, sandbox: 'workspace-write', instructions: mergeInstructions, prompt, model, effort: model?.defaultEffort, timeout: 600000, what: 'resolve the conflicts' });
+    return { summary: summary.trim(), remaining: files.filter(file => conflictMarkers(project.path, file)), agent: id, git: await gitStatus(project.path) };
+  }
+  // Commits what the author accepted from this task since its last commit,
+  // with the message they confirmed, and pushes it if they asked. Other
+  // uncommitted files stay as they are; a file another task also changed is
+  // committed as it is on disk.
+  async commitTask(taskId: string, message: string, push = false) {
+    const task = this.store.task(taskId);
+    if (task.status === 'deleting') throw new Error('This task is being deleted.');
+    if (task.pendingReview) throw new Error('Wait for the current review action before committing.');
+    const project = this.store.project(task.projectId);
+    return this.exclusiveCommit(project.id, async () => {
+      const accepted = await acceptedCommit(project.path, task.name);
+      const files = accepted ? await acceptedFiles(project.path, task.name, this.store.task(taskId).committed?.accepted) : [];
+      const paths = (await gitStatus(project.path)).files.filter(file => files.includes(file.path)).map(file => file.path);
+      if (!paths.length) throw new Error('This task has no accepted changes left to commit.');
+      const hash = await gitCommit(project.path, message, paths);
+      this.store.updateTask(taskId, { committed: { hash, accepted: accepted!, at: Date.now() } });
+      void this.refresh(taskId);
+      // The commit stands even when the push fails; the author can push again.
+      let pushError: string | undefined;
+      if (push) try { await gitRemote(project.path, 'push'); } catch (error) { pushError = errorText(error); }
+      return { commit: hash, git: await gitStatus(project.path), ...(pushError ? { pushError } : {}) };
+    });
+  }
+  // A commit reads the working tree that accepting, rejecting and undoing
+  // write, so neither starts while the other runs on the same paper.
+  async exclusiveCommit<T>(projectId: string, work: () => Promise<T>): Promise<T> {
+    if (this.committing.has(projectId)) throw new Error('A commit is already in progress. Wait for it to finish.');
+    if ([...this.reviewWrites].some(id => this.store.task(id).projectId === projectId)) throw new Error('Wait for the current review action before committing.');
+    this.committing.add(projectId);
+    try { return await work(); } finally { this.committing.delete(projectId); }
+  }
   renameTask(taskId: string, title: string) {
     if (this.store.task(taskId).status === 'deleting') throw new Error('This task is being deleted.');
     return this.store.updateTask(taskId, { title });
@@ -544,10 +706,15 @@ ${this.agentOf(task) === 'antigravity' ? 'Shell commands are not available to yo
 
 // The review engine records each task's accepted text as a commit beside the
 // one it started from; their difference is what the task put in the
-// manuscript. A rename counts as both of its paths.
-export async function acceptedFiles(root: string, name: string) {
+// manuscript, and the difference from the accepted text at the task's last
+// commit is what it has added since. A rename counts as both of its paths.
+export async function acceptedFiles(root: string, name: string, since?: string) {
   try {
-    const { stdout } = await execute('git', ['-C', root, 'diff', '--name-only', '--no-renames', '-z', `refs/latex-review/${name}/base`, `refs/latex-review/${name}/accepted`, '--']);
+    const { stdout } = await execute('git', ['-C', root, 'diff', '--name-only', '--no-renames', '-z', since || `refs/latex-review/${name}/base`, `refs/latex-review/${name}/accepted`, '--']);
     return stdout.split('\0').filter(Boolean);
   } catch { return []; }
 }
+export async function acceptedCommit(root: string, name: string) {
+  try { return (await execute('git', ['-C', root, 'rev-parse', '--verify', '-q', `refs/latex-review/${name}/accepted^{commit}`])).stdout.trim() || undefined; }
+  catch { return undefined; }
+}