papilot 0.2.0 → 0.3.0

package/dist/index.html

@@ -8,6 +8,6 @@
   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-Czf1eCno.js"></script>
-  <link rel="stylesheet" crossorigin href="/assets/index-CqhlgnOu.css">
+</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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "papilot",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "A Cursor-like workspace for your papers: annotate and review PDFs directly without ever touching LaTeX.",
   "keywords": [
     "latex",
@@ -36,6 +36,7 @@
     "src/shared.ts",
     "src/notes.ts",
     "src/conversation.ts",
+    "src/commit.ts",
     "skills",
     "dist",
     "scripts/demo.ts",

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

@@ -1,4 +1,4 @@
-import type { FeedbackSummary } from './shared.ts';
+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.
@@ -6,6 +6,17 @@ export const reviewInstructions = 'Continue this task using the decisions and co
 // 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 [

package/src/server/main.ts

@@ -10,7 +10,7 @@ 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';
 
@@ -72,6 +72,11 @@ app.post<{ Params: { id: string } }>('/api/tasks/:id/messages', async request =>
   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 })));
 app.post<{ Params: { id: string } }>('/api/tasks/:id/delete', request => {
@@ -97,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) }));

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, ...(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/workspace.ts

@@ -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 } from '../shared.ts';
 
 const execute = promisify(execFile);
 const delay = (ms: number) => new Promise(resolve => setTimeout(resolve, ms));
@@ -35,8 +37,16 @@ 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'];
+// 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 +59,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>();
@@ -145,9 +157,10 @@ export class Workspace extends EventEmitter {
       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 } = {}) {
     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 +168,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 +179,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 } : {}) };
     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 +195,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 +218,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 +242,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 +348,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 +459,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 +474,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 +497,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 +519,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 +533,105 @@ ${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.
+  private helper(choice: { agent?: AgentId; model?: string }, task: string) {
+    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: 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 with the lightest reasoning the model offers.
+  async commitMessage(projectId: string, paths: string[], choice: { agent?: AgentId; model?: string } = {}) {
+    const project = this.store.project(projectId), { id, model } = this.helper(choice, 'write a commit message');
+    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 reply = await this.oneOff(id, { cwd: project.path, sandbox: 'read-only', instructions: commitInstructions, prompt, model, effort: model?.efforts[0], timeout: 120000, what: 'write a commit message' });
+    const message = commitMessageFrom(reply);
+    if (!message) throw new Error(`${AGENT_NAMES[id]} did not return a commit message. Try again.`);
+    return { message, agent: id };
+  }
+  // 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 +676,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; }
+}