papilot 0.8.0 → 0.8.2

package/src/server/store.ts

@@ -83,14 +83,6 @@ export class Store extends EventEmitter {
     });
     this.emit('change');
   }
-  // Runs a one-off change the first time this database sees its key.
-  migrate(key: string, fn: () => void) {
-    this.transaction(() => {
-      if (this.db.prepare('SELECT 1 FROM migrations WHERE key=?').get(key)) return;
-      fn();
-      this.db.prepare('INSERT INTO migrations VALUES(?,?)').run(key, Date.now());
-    });
-  }
   transaction<T>(fn: () => T): T { this.db.exec('BEGIN IMMEDIATE'); try { const result = fn(); this.db.exec('COMMIT'); return result; } catch (e) { this.db.exec('ROLLBACK'); throw e; } }
   recover() {
     this.transaction(() => {

package/src/server/update-install.ts

@@ -4,7 +4,7 @@ import net from 'node:net';
 import { execFile, spawn } from 'node:child_process';
 import { promisify } from 'node:util';
 import { createRequire } from 'node:module';
-import { devRevision, readJson, stableVersion } from '../../bin/installation.mjs';
+import { devRevision, newerVersion, readJson, stableVersion } from '../../bin/installation.mjs';
 
 export const DEV_REPOSITORY = 'https://github.com/PapilotAI/papilot.git';
 const git = async (args: string[], cwd: string) => (await promisify(execFile)('git', args, { cwd, timeout: 120000, maxBuffer: 1024 * 1024, env: { ...process.env, GIT_TERMINAL_PROMPT: '0' } })).stdout.trim();
@@ -18,6 +18,19 @@ export function npmCli(env = process.env, executable = process.execPath) {
   }
   throw new Error('npm is unavailable to Papilot.');
 }
+// A desktop installer runs a newer release when it provides the shell level the
+// release declares and its bundled Node meets the release's engine range.
+export const NEEDS_INSTALLER = 'This version needs the latest desktop app. Download it from GitHub Releases.';
+export function desktopSupports(pkg: any, shell: number, node = process.versions.node) {
+  if (!Number.isInteger(pkg?.desktopShell) || pkg.desktopShell < 1 || pkg.desktopShell > shell) return false;
+  // npm's --engine-strict checks other range forms during installation.
+  const minimum = typeof pkg.engines?.node === 'string' ? /^\s*>=\s*v?(\d+\.\d+\.\d+)\s*$/.exec(pkg.engines.node)?.[1] : undefined;
+  return !minimum || !newerVersion(minimum, node);
+}
+// The installer's Codex serves releases that test the same or an older one.
+export function codexVersion(bin: string | undefined) {
+  try { return readJson(path.join(path.dirname(fs.realpathSync(bin!)), '../package.json'))?.version || null; } catch { return null; }
+}
 export const loaderFor = (root: string) => createRequire(path.join(root, 'package.json')).resolve('tsx/esm');
 export function runInstall(args: string[], cwd: string, log: number, timeout = 600000) {
   return new Promise<void>((resolve, reject) => {
@@ -102,7 +115,7 @@ async function installDev(data: string, version: string) {
   } catch (error) { fs.rmSync(stage, { recursive: true, force: true }); throw error; }
   finally { fs.closeSync(log); }
 }
-export async function installRelease(data: string, version: string) {
+export async function installRelease(data: string, version: string, desktop?: { shell: number; codex?: string }) {
   if (devRevision(version)) return installDev(data, version);
   if (!stableVersion(version)) throw new Error('Invalid release version.');
   const releases = path.join(data, 'updates/releases'); fs.mkdirSync(releases, { recursive: true, mode: 0o700 });
@@ -116,7 +129,14 @@ export async function installRelease(data: string, version: string) {
     for (const file of ['dist/index.html', 'src/server/start.ts', 'src/server/main.ts', 'bin/papilot.mjs', 'vendor/latex-review/package-lock.json']) {
       if (!fs.existsSync(path.join(root, file))) throw new Error('The downloaded release is incomplete.');
     }
+    if (desktop && !desktopSupports(pkg, desktop.shell)) throw new Error(NEEDS_INSTALLER);
     await runInstall(['ci', '--prefix', path.join(root, 'vendor/latex-review'), ...flags], stage, log);
+    // Like the CLI's first run, Codex installs with its own scripts. The app
+    // finds it beside the release.
+    const tested = pkg.devDependencies?.['@openai/codex'], bundled = desktop && codexVersion(desktop.codex);
+    if (desktop && stableVersion(tested) && (!bundled || newerVersion(tested, bundled))) {
+      await runInstall(['install', '--prefix', path.join(stage, 'codex'), '--registry=https://registry.npmjs.org', '--no-audit', '--no-fund', `@openai/codex@${tested}`], stage, log);
+    }
     await probeInstallation(root, version, stage, log);
     return root;
   } catch (error) { fs.rmSync(stage, { recursive: true, force: true }); throw error; }

package/src/server/updates.ts

@@ -3,7 +3,7 @@ import path from 'node:path';
 import { spawn } from 'node:child_process';
 import { randomUUID } from 'node:crypto';
 import { devRevision, newerVersion, readJson, stableVersion, writeJson } from '../../bin/installation.mjs';
-import { installRelease, loaderFor, npmCli } from './update-install.ts';
+import { desktopSupports, installRelease, loaderFor, NEEDS_INSTALLER, npmCli } from './update-install.ts';
 import type { UpdateChannel, UpdateStatus } from '../shared.ts';
 
 const activePhases = new Set(['installing', 'waiting', 'restarting']);
@@ -15,26 +15,32 @@ async function releaseInfo(url: string, fetcher: typeof fetch) {
   if (text.length > 256000) throw new Error('Invalid release information.');
   return JSON.parse(text);
 }
-export async function latestRelease(channel: UpdateChannel = 'stable', fetcher = fetch): Promise<string> {
+// The package.json of the newest release on a channel.
+export async function latestManifest(channel: UpdateChannel = 'stable', fetcher = fetch): Promise<Record<string, any>> {
   if (channel === 'dev') {
     const commit = await releaseInfo('https://api.github.com/repos/PapilotAI/papilot/git/ref/heads/main', fetcher);
     const revision = commit.object?.sha;
     if (!/^[a-f0-9]{40}$/.test(revision)) throw new Error('Invalid development revision.');
     const pkg = await releaseInfo(`https://raw.githubusercontent.com/PapilotAI/papilot/${revision}/package.json`, fetcher);
     if (pkg.name !== 'papilot' || !stableVersion(pkg.version)) throw new Error('Invalid development version.');
-    return `${pkg.version}-dev.${revision}`;
+    return { ...pkg, version: `${pkg.version}-dev.${revision}` };
   }
   const pkg = await releaseInfo('https://registry.npmjs.org/papilot/latest', fetcher);
   if (pkg.name !== 'papilot' || !stableVersion(pkg.version)) throw new Error('Invalid release information.');
-  return pkg.version;
+  return pkg;
 }
+export const latestRelease = async (channel: UpdateChannel = 'stable', fetcher = fetch) => (await latestManifest(channel, fetcher)).version as string;
 const validTarget = (version: unknown, channel: UpdateChannel): version is string => channel === 'dev' ? Boolean(devRevision(version)) : stableVersion(version);
 const available = (next: string, current: string, channel: UpdateChannel) => validTarget(next, channel)
   && (channel === 'dev' || devRevision(current) ? next !== current : newerVersion(next, current));
 interface Options {
+  // Desktop builds that cannot install releases link to this download page.
+  downloadUrl?: string;
+  // A desktop installer that runs newer releases from npm (see desktop/runtime.ts).
+  desktop?: { shell: number; installer: string; downloadUrl: string };
   root: string; data: string; version: string; port: number;
   busy: () => boolean; shutdown: () => void;
-  latest?: (channel: UpdateChannel) => Promise<string>; install?: (data: string, version: string) => Promise<string>;
+  latest?: (channel: UpdateChannel) => Promise<string | Record<string, any>>; install?: (data: string, version: string) => Promise<string>;
   restart?: (root: string, version: string) => Promise<void>; supported?: boolean;
 }
 // Both HTTP listeners share one updater. Downloads do not interrupt editing;
@@ -42,7 +48,6 @@ interface Options {
 export class Updates {
   private state: UpdateStatus;
   private checking: Promise<UpdateStatus> | null = null;
-  private operation: Promise<void> | null = null;
   private prepared = '';
   private inFlight = 0;
   private timer?: NodeJS.Timeout;
@@ -50,10 +55,12 @@ export class Updates {
   private file: string;
   private lock: string;
   private channel: UpdateChannel;
+  // The latest release needs a newer desktop installer.
+  private needsInstaller = false;
   constructor(private options: Options) {
     this.file = path.join(options.data, 'updates/status.json'); this.lock = path.join(options.data, 'updates/install.lock');
     const preference = readJson(path.join(options.data, 'updates/channel.json'))?.channel;
-    this.channel = preference === 'dev' || preference === 'stable' ? preference : devRevision(options.version) ? 'dev' : 'stable';
+    this.channel = options.downloadUrl || options.desktop ? 'stable' : preference === 'dev' || preference === 'stable' ? preference : devRevision(options.version) ? 'dev' : 'stable';
     let supported = options.supported ?? true;
     if (options.supported === undefined) try { npmCli(); } catch { supported = false; }
     this.state = { currentVersion: options.version, latestVersion: null, phase: 'idle', checkedAt: null, error: null, canUpdate: supported };
@@ -62,14 +69,18 @@ export class Updates {
     if (saved && activePhases.has(saved.phase) && !alive(saved.pid)) this.change({ phase: 'failed', checkedAt: Date.now(), error: 'The update was interrupted. Your current installation is still available; retry the update.' });
   }
   snapshot(): UpdateStatus {
+    if (this.options.downloadUrl) return { currentVersion: this.options.version, latestVersion: null, phase: 'idle', checkedAt: null, error: null, canUpdate: false, channel: 'stable', downloadUrl: this.options.downloadUrl };
     const saved = readJson(this.file);
     if (saved && activePhases.has(this.state.phase) && ['updated', 'failed'].includes(saved.phase)) this.state = { ...this.state, ...saved, currentVersion: this.options.version };
-    const { currentVersion, latestVersion, phase, checkedAt, error, canUpdate } = this.state;
+    const { currentVersion, latestVersion, phase, checkedAt, error, canUpdate } = this.state, desktop = this.options.desktop;
+    if (desktop) return { currentVersion, latestVersion, phase, checkedAt, error, channel: this.channel, installerVersion: desktop.installer,
+      ...(this.needsInstaller ? { canUpdate: false, downloadUrl: desktop.downloadUrl } : { canUpdate }) };
     return { currentVersion, latestVersion, phase, checkedAt, error, canUpdate, channel: this.channel };
   }
   get restarting() { return this.snapshot().phase === 'restarting'; }
   enter() { this.inFlight++; let released = false; return () => { if (!released) { released = true; this.inFlight--; } }; }
   start() {
+    if (this.options.downloadUrl) return;
     if (this.state.phase !== 'failed') void this.check();
     this.timer = setInterval(() => {
       if (this.state.phase === 'waiting') void this.activate();
@@ -82,6 +93,7 @@ export class Updates {
     writeJson(this.file, { ...this.state, pid: process.pid });
   }
   setChannel(channel: unknown) {
+    if (this.options.downloadUrl || this.options.desktop) throw new Error('Download desktop updates from GitHub Releases.');
     if (channel !== 'stable' && channel !== 'dev') throw new Error('Choose a valid update channel.');
     if (activePhases.has(this.state.phase)) throw new Error('Wait for the current update to finish before changing channels.');
     if (channel === this.channel) return this.check();
@@ -92,13 +104,19 @@ export class Updates {
     return this.check();
   }
   check(): Promise<UpdateStatus> {
+    if (this.options.downloadUrl) return Promise.resolve(this.snapshot());
     if (this.checking) return this.checking;
     if (activePhases.has(this.state.phase)) return Promise.resolve(this.snapshot());
     this.change({ phase: 'checking' });
     const channel = this.channel;
-    const checking = (this.options.latest || latestRelease)(channel).then(version => {
+    const checking = (this.options.latest || latestManifest)(channel).then(found => {
+      const manifest = typeof found === 'string' ? { version: found } : found, version = manifest?.version;
       if (!validTarget(version, channel)) throw new Error('Invalid release version.');
-      if (!this.closed && this.checking === checking && !activePhases.has(this.state.phase)) this.change({ latestVersion: version, checkedAt: Date.now(), error: null, phase: available(version, this.options.version, channel) ? 'available' : 'idle' });
+      if (!this.closed && this.checking === checking && !activePhases.has(this.state.phase)) {
+        const newer = available(version, this.options.version, channel);
+        this.needsInstaller = Boolean(this.options.desktop && newer && !desktopSupports(manifest, this.options.desktop.shell));
+        this.change({ latestVersion: version, checkedAt: Date.now(), error: null, phase: newer ? 'available' : 'idle' });
+      }
       return this.snapshot();
     }).catch(() => {
       if (!this.closed && this.checking === checking && !activePhases.has(this.state.phase)) this.change({ phase: this.state.latestVersion && available(this.state.latestVersion, this.options.version, channel) ? 'available' : 'idle', checkedAt: Date.now(), error: 'Could not check for updates. Try again when connected.' });
@@ -108,7 +126,9 @@ export class Updates {
     return this.checking;
   }
   install(version: unknown) {
+    if (this.options.downloadUrl) throw new Error('Download desktop updates from GitHub Releases.');
     if (activePhases.has(this.state.phase)) return this.snapshot();
+    if (this.needsInstaller) throw new Error(NEEDS_INSTALLER);
     if (!this.state.canUpdate) throw new Error('npm is unavailable to Papilot.');
     if (!validTarget(version, this.channel) || version !== this.state.latestVersion || !available(version, this.options.version, this.channel)) throw new Error('Check for a newer release before updating.');
     fs.mkdirSync(path.dirname(this.lock), { recursive: true, mode: 0o700 });
@@ -117,11 +137,11 @@ export class Updates {
     if (previous) fs.rmSync(this.lock);
     const fd = fs.openSync(this.lock, 'wx', 0o600); fs.writeFileSync(fd, JSON.stringify({ pid: process.pid })); fs.closeSync(fd);
     this.change({ phase: 'installing', error: null });
-    this.operation = (this.options.install || installRelease)(this.options.data, version).then(root => {
+    void (this.options.install || installRelease)(this.options.data, version).then(root => {
       if (this.closed) return;
       this.prepared = root; this.change({ phase: 'waiting' });
       return this.activate();
-    }).catch(error => { this.change({ phase: 'failed', error: error instanceof Error ? error.message : 'The update failed.' }); this.release(); }).finally(() => { this.operation = null; });
+    }).catch(error => { this.change({ phase: 'failed', error: error instanceof Error ? error.message : 'The update failed.' }); this.release(); });
     return this.snapshot();
   }
   // Public for deterministic tests; the periodic tick calls this in production.

package/src/server/workspace.ts

@@ -17,13 +17,14 @@ import { VERSION } from './paths.ts';
 import { prepareRepository } from './imports.ts';
 import { findSkill, type SkillFile } from './skills.ts';
 import { buildFixPrompt, reviewInstructions, skillPrompt, summarizeFeedback } from '../conversation.ts';
+import { reconciliationPrompt } from './reconcile.ts';
 import { commitMessageFrom } from '../commit.ts';
 import { taskCaptionFrom, taskCaptionInstructions } from '../task-caption.ts';
 import { notesInstructions, reviewNotesInstructions, summarizeNotes } from '../notes.ts';
 import { canonicalGroup, groupsWithoutInstructions, parseGroupInstructions, type GroupInstructions } from '../note-groups.ts';
 import { commitChanges, conflictMarkers, gitCommit, gitRemote, gitStatus, mergeConflicts, mergeInProgress } from './manuscript.ts';
 import { AGENT_IDS, isTaskReviewNote } from '../shared.ts';
-import type { Task, Run, TimelineItem, PendingRequest, RuntimeStatus, Snapshot, PendingReview, AgentModel, Usage, AgentId, MessageMeta, FeedbackSummary, BuildFailure, Author, Annotation, NoteSummary } from '../shared.ts';
+import type { Task, Run, TimelineItem, PendingRequest, RuntimeStatus, Snapshot, PendingReview, AgentModel, Usage, AgentId, MessageMeta, FeedbackSummary, BuildFailure, Author, Annotation, NoteSummary, TaskReconciliation, TaskCommitReview } from '../shared.ts';
 
 const execute = promisify(execFile);
 const delay = (ms: number) => new Promise(resolve => setTimeout(resolve, ms));
@@ -132,7 +133,7 @@ export class Workspace extends EventEmitter {
   constructor(public store: Store, public codex: AgentRuntime = new Codex(), private concurrency = 2, private connectReview = reviewClient, others: Partial<Record<AgentId, AgentRuntime>> = {}) {
     super();
     this.attachments = new Attachments(store);
-    this.agents = { codex, claude: others.claude || new ClaudeAgent(), cursor: others.cursor || new CursorAgent(), antigravity: others.antigravity || new AntigravityAgent(),
+    this.agents = { codex, claude: others.claude || new ClaudeAgent(), cursor: others.cursor || new CursorAgent(), copilot: others.copilot || new AcpAgent(ACP_PROFILES.copilot), grok: others.grok || new AcpAgent(ACP_PROFILES.grok), antigravity: others.antigravity || new AntigravityAgent(),
       kimi: others.kimi || new AcpAgent(ACP_PROFILES.kimi), glm: others.glm || new GlmAgent(), deepseek: others.deepseek || new AcpAgent(ACP_PROFILES.deepseek),
       qwen: others.qwen || new AcpAgent(ACP_PROFILES.qwen), opencode: others.opencode || new AcpAgent(ACP_PROFILES.opencode) };
     store.on('change', () => this.emit('change'));
@@ -328,7 +329,7 @@ export class Workspace extends EventEmitter {
   // 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: { attachments?: string[]; skill?: SkillFile; notes?: Annotation[]; groupInstructions?: GroupInstructions; reviewNotes?: NoteSummary[]; feedback?: boolean; build?: BuildFailure; author?: Author } = {}) {
+  async enqueue(taskId: string, text: string, requestKey: string, includeFeedback = true, options: { attachments?: string[]; skill?: SkillFile; notes?: Annotation[]; groupInstructions?: GroupInstructions; reviewNotes?: NoteSummary[]; feedback?: boolean; build?: BuildFailure; author?: Author; merge?: TaskReconciliation } = {}) {
     const task = this.store.task(taskId);
     if (task.status === 'deleting') throw new Error('This task is being deleted.');
     if (task.mode === 'review' && ((options.skill && options.skill.output !== 'annotations') || options.notes?.length || options.reviewNotes?.length || options.attachments?.length || options.feedback || options.build)) throw new Error('AI review accepts review instructions only. Start an editing task to send notes, skills or attachments.');
@@ -342,7 +343,7 @@ export class Workspace extends EventEmitter {
     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.');
     const instructions = options.notes?.length ? notesInstructions(options.notes, text, options.groupInstructions) : options.reviewNotes?.length ? reviewNotesInstructions(options.reviewNotes, text) : text.trim();
-    let prompt = options.build ? buildFixPrompt(options.build) : options.feedback ? reviewInstructions : options.skill ? skillPrompt(options.skill, instructions) : instructions, cursor = task.feedbackCursor;
+    let prompt = options.merge ? reconciliationPrompt(options.merge) : options.build ? buildFixPrompt(options.build) : options.feedback ? reviewInstructions : options.skill ? skillPrompt(options.skill, instructions) : instructions, cursor = task.feedbackCursor;
     let summary: FeedbackSummary | undefined;
     if (task.mode === 'review') includeFeedback = false;
     if (includeFeedback) {
@@ -417,6 +418,7 @@ export class Workspace extends EventEmitter {
     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}
+Papilot offers two ways to save accepted changes: Apply to workspace leaves them uncommitted; Commit to manuscript creates one commit containing only this task on the current manuscript branch. Both update the manuscript directly, including for tasks previously saved to a task branch. Do not tell the author to export patches or run Git commands to apply a task. If application conflicts, Papilot automatically asks AI to prepare another review in this task. Ask the author only when the instructions and manuscript context cannot determine the intended content; continue after their answer.
 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.
 ${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.
@@ -449,13 +451,21 @@ ${this.agentOf(task) === 'antigravity' ? 'Shell commands are not available to yo
         }
       }
       if (this.active.get(task.id)?.id !== run.id) return;
-      task = this.store.updateTask(task.id, { threadId: result.thread.id, model: result.model || task.model, ...(task.threadId ? {} : { viewPdf }) });
+      // Settings can change while the agent loads. Keep this turn's snapshot,
+      // and never overwrite a newer choice with the thread's resolved model.
+      const current = this.store.task(task.id);
+      this.store.updateTask(task.id, { threadId: result.thread.id, ...(current.model === task.model ? { model: result.model || task.model } : {}), ...(task.threadId ? {} : { viewPdf }) });
+      task = { ...task, threadId: result.thread.id, model: result.model || task.model };
       this.loaded.add(result.thread.id);
     }
     this.store.updateTask(task.id, { pendingRunId: run.id });
     const input = [{ type: 'text', text: run.prompt }, ...(run.attachments || []).filter(file => file.mime.startsWith('image/')).map(file => ({ type: 'localImage', path: this.attachments.path(file) }))];
     let result: any;
-    try { result = await agent.request('turn/start', { threadId: task.threadId, input, cwd: task.worktree, clientUserMessageId: run.id, ...(task.effort ? { effort: task.effort } : {}), ...(this.agentOf(task) === 'codex' && task.serviceTier ? { serviceTier: task.serviceTier } : {}) }); }
+    const models = this.runtimes[this.agentOf(task)].models;
+    const model = task.model ? models.find(model => model.id === task.model) : models.find(model => model.isDefault);
+    // Explicit defaults replace a previous turn's reasoning override.
+    const effort = task.effort || (this.agentOf(task) === 'codex' ? model?.defaultEffort : undefined);
+    try { result = await agent.request('turn/start', { threadId: task.threadId, input, cwd: task.worktree, clientUserMessageId: run.id, ...(task.model ? { model: task.model } : {}), ...(effort ? { effort } : {}), ...(this.agentOf(task) === 'codex' && task.serviceTier ? { serviceTier: task.serviceTier } : {}) }); }
     catch (error) {
       if (this.active.get(task.id)?.id !== run.id) return;
       if (error instanceof RpcResponseError) throw error;
@@ -811,9 +821,16 @@ ${this.agentOf(task) === 'antigravity' ? 'Shell commands are not available to yo
       const { unsent, comments } = await this.unsentReviewFeedback(client, this.store.task(taskId));
       const deferred = summary.deferred === true || task.deferred;
       const delivery = summary.delivery ?? task.delivery;
-      const files = await acceptedFiles(project.path, task.name, deferred ? delivery?.accepted : task.committed?.accepted);
+      const reconciliation = summary.reconciliation ?? null;
+      const files = await acceptedFiles(project.path, task.name, deferred ? reconciliation?.base ?? (delivery && delivery.mode !== 'branch' ? delivery.accepted : undefined) : task.committed?.accepted);
       const current = this.store.task(taskId);
-      if (current.status !== 'deleting') this.store.updateTask(taskId, { deferred, delivery, review: { state: summary.state, round: summary.round, counts: summary.counts, job: current.review?.job, unsent, comments, files } });
+      if (current.status !== 'deleting') this.store.updateTask(taskId, { deferred, delivery, reconciliation, review: { state: summary.state, round: summary.round, counts: summary.counts, job: current.review?.job, unsent, comments, files } });
+      // Recover an application interrupted after the engine prepared its
+      // proposal but before Papilot persisted the agent run.
+      if (reconciliation?.ready && (summary.round ?? 0) <= reconciliation.round && current.status === 'reviewing' && !this.committing.has(task.projectId) && !this.reviewWrites.has(taskId)
+        && !current.pendingReview && !this.store.runByKey('merge-review-' + reconciliation.id)
+        && !this.store.runs().some(run => run.taskId === taskId && run.status === 'queued'))
+        await this.queueMergeSuggestion(taskId, reconciliation);
     } catch { /* The task remains visible even if its project is temporarily unavailable. */ }
     finally { release?.(); }
   }
@@ -951,7 +968,7 @@ ${this.agentOf(task) === 'antigravity' ? 'Shell commands are not available to yo
     try {
       const task = this.store.task(taskId), files = task.review?.files || [];
       if (task.status !== 'reviewing' || task.review?.counts?.pending || !files.length) return;
-      if (task.deferred) { await this.commitMessage(task.projectId, files, { agent: this.agentOf(task), taskId }); return; }
+      if (task.deferred) 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) });
@@ -959,9 +976,10 @@ ${this.agentOf(task) === 'antigravity' ? 'Shell commands are not available to yo
   }
   private async taskCommitChanges(task: Task) {
     const root = this.store.project(task.projectId).path;
-    const before = task.delivery?.accepted ?? `refs/latex-review/${task.name}/base`;
+    const delivered = task.reconciliation?.base ?? (task.delivery?.mode !== 'branch' ? task.delivery?.accepted : undefined);
+    const before = delivered ?? `refs/latex-review/${task.name}/base`;
     const after = `refs/latex-review/${task.name}/accepted`;
-    const paths = await acceptedFiles(root, task.name, task.delivery?.accepted);
+    const paths = await acceptedFiles(root, task.name, delivered);
     if (!paths.length) throw new Error('This task has no accepted changes left to commit.');
     const { stdout: patch } = await execute('git', ['-C', root, 'diff', '--no-ext-diff', '--no-textconv', before, after, '--'], { maxBuffer: 8 * 1024 * 1024 });
     return { files: paths.map(path => ({ path, status: 'M', from: undefined })), patch: patch.slice(0, 80000), recent: [] as string[] };
@@ -982,6 +1000,38 @@ ${this.agentOf(task) === 'antigravity' ? 'Shell commands are not available to yo
       } finally { await this.refresh(taskId); this.reviewWrites.delete(taskId); this.schedule(); }
     });
   }
+  async applyTask(taskId: string, keepCurrent = false, commit?: { message: string; confirmation?: string }) {
+    const task = this.store.task(taskId), project = this.store.project(task.projectId);
+    if (task.mode === 'review') throw new Error('AI review has no manuscript changes to apply.');
+    if (!task.deferred) throw new Error('Accepted changes are already in the manuscript.');
+    if (task.status !== 'reviewing' || this.active.has(taskId) || this.publishing.has(taskId) || task.pendingReview || this.store.runs().some(run => run.taskId === taskId && run.status === 'queued'))
+      throw new Error('Wait for the task and review actions to finish before applying changes.');
+    const result = await this.exclusiveCommit(project.id, async () => {
+      this.reviewWrites.add(taskId);
+      try {
+        const client = await this.connectReview(project.path);
+        const result = await client.post<{ delivery?: NonNullable<Task['delivery']>; reconciliation?: TaskReconciliation; commitReview?: TaskCommitReview }>(`${taskRoute(task.name)}/apply`, { keepCurrent, mode: commit ? 'commit' : 'workspace', ...(commit ? { message: commit.message, confirmation: commit.confirmation } : {}) });
+        if (result.delivery) this.store.updateTask(taskId, { delivery: result.delivery, reconciliation: null });
+        if (result.reconciliation) this.store.updateTask(taskId, { reconciliation: result.reconciliation });
+        return { ...result, git: await gitStatus(project.path) };
+      } finally { await this.refresh(taskId); this.reviewWrites.delete(taskId); }
+    }).catch(async error => {
+      // A lost response is not a failed application. refresh above checks the
+      // engine's persisted result before we retry or start the suggestion.
+      const confirmed = this.store.task(taskId);
+      if (confirmed.reconciliation?.ready && confirmed.reconciliation.id !== task.reconciliation?.id)
+        return { reconciliation: confirmed.reconciliation, delivery: undefined, commitReview: undefined, git: await gitStatus(project.path) };
+      if (confirmed.delivery && confirmed.delivery.mode !== 'branch' && !confirmed.delivery.pending && (confirmed.delivery.mode !== task.delivery?.mode || confirmed.delivery.accepted !== task.delivery?.accepted))
+        return { delivery: confirmed.delivery, reconciliation: undefined, commitReview: undefined, git: await gitStatus(project.path) };
+      throw error;
+    });
+    if (result.reconciliation?.ready) await this.queueMergeSuggestion(taskId, result.reconciliation);
+    this.schedule();
+    return result;
+  }
+  private queueMergeSuggestion(taskId: string, merge: TaskReconciliation) {
+    return this.enqueue(taskId, 'The manuscript has changed in overlapping passages. Prepare a merge suggestion for me to review; keep the manuscript unchanged.', 'merge-review-' + merge.id, false, { merge });
+  }
   // 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.
@@ -1006,10 +1056,9 @@ ${this.agentOf(task) === 'antigravity' ? 'Shell commands are not available to yo
   async commitTask(taskId: string, message: string, push = false) {
     const task = this.store.task(taskId);
     if (task.deferred) {
-      if (push) throw new Error('Task branch commits are kept locally.');
-      const result = await this.deliverTask(taskId, 'branch', message);
-      if (!result.commit) throw new Error('The review engine did not confirm the commit. Retry the task commit.');
-      return { ...result, commit: result.commit, pushError: undefined as string | undefined };
+      if (push) throw new Error('Commit the task first, then push from Git.');
+      const result = await this.applyTask(taskId, false, { message });
+      return { ...result, commit: result.delivery?.commit, pushError: undefined };
     }
     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.');
@@ -1040,6 +1089,20 @@ ${this.agentOf(task) === 'antigravity' ? 'Shell commands are not available to yo
     this.committing.add(projectId);
     try { return await work(); } finally { this.committing.delete(projectId); }
   }
+  updateTaskModel(taskId: string, change: { model?: string; effort?: string; serviceTier?: string }) {
+    const task = this.store.task(taskId), agent = this.agentOf(task);
+    if (task.status === 'deleting') throw new Error('This task is being deleted.');
+    const models = this.runtimes[agent].models;
+    const id = change.model ?? task.model;
+    const model = id ? models.find(model => model.id === id) : models.find(model => model.isDefault);
+    if (change.model && change.model !== task.model && !model) throw new Error('Choose an available model for this agent.');
+    const effort = change.effort ?? (change.model !== undefined && model && !model.efforts.includes(task.effort || '') ? '' : task.effort);
+    if (change.effort && model && !model.efforts.includes(change.effort)) throw new Error('This model does not support that reasoning effort.');
+    const serviceTier = change.serviceTier ?? (change.model !== undefined && task.serviceTier !== model?.fastMode?.serviceTier ? 'default' : task.serviceTier);
+    if (change.serviceTier !== undefined && agent !== 'codex') throw new Error('Service tiers are only available for Codex.');
+    if (serviceTier && serviceTier !== 'default' && serviceTier !== model?.fastMode?.serviceTier) throw new Error('Fast mode is not available for this model.');
+    return this.store.updateTask(taskId, { model: id || null, effort: effort || null, ...(serviceTier ? { serviceTier } : {}) });
+  }
   renameTask(taskId: string, title: string) {
     const task = this.store.task(taskId);
     if (task.status === 'deleting') throw new Error('This task is being deleted.');

package/src/shared.ts

@@ -9,6 +9,10 @@ export const MAX_ATTACHMENT_TOTAL = 100 * 1024 * 1024;
 export interface Attachment { id: string; projectId: string; name: string; size: number; mime: string }
 export type UpdateChannel = 'stable' | 'dev';
 export interface UpdateStatus {
+  // Present when the update must be downloaded as a new desktop app.
+  downloadUrl?: string;
+  // The desktop app's own Papilot version; newer releases run on top of it.
+  installerVersion?: string;
   channel?: UpdateChannel;
   currentVersion: string; latestVersion: string | null;
   phase: 'idle' | 'checking' | 'available' | 'installing' | 'waiting' | 'restarting' | 'updated' | 'failed';
@@ -19,12 +23,19 @@ export interface UpdateStatus {
 // accepted changes touched since its last commit, relative to the repository root.
 export interface ReviewSummary { state: string; round: number | null; counts: Record<string, number>; unsent?: number; comments?: number; files?: string[]; next?: string; job?: { phase: string; status: string; error?: string; details?: string[] } | null }
 export interface PendingReview { route: string; body: Record<string, unknown>; previousStatus: TaskStatus }
+export interface TaskCommitReview { token: string; files: string[]; diff: string }
+export interface TaskReconciliation {
+  id: string; round: number; files: string[];
+  sourceBase: string; sourceAccepted: string; base: string; ready: boolean;
+  intent?: { mode: 'workspace' | 'commit'; message: string };
+}
 export interface Task {
   mode?: 'edit' | 'review';
   aiReview?: { key: string; notes?: number; revision?: number };
-  // New tasks keep acceptance isolated until the author chooses a destination.
+  // Accepted changes remain isolated until the author applies them.
+  reconciliation?: TaskReconciliation | null;
   deferred?: boolean;
-  delivery?: { mode: 'workspace' | 'branch'; accepted: string; branch?: string; commit?: string; pending?: boolean } | null;
+  delivery?: { mode: 'workspace' | 'commit' | 'branch'; accepted: string; branch?: string; commit?: string; pending?: boolean } | null;
   id: string; projectId: string; name: string; title: string; instructions: string;
   titleSource?: 'prompt' | 'generated' | 'manual'; titleRevision?: number; titleGeneration?: 'pending' | 'failed' | null;
   worktree: string; threadId: string | null; turnId: string | null; agent?: AgentId; model: string | null; effort?: string | null; serviceTier?: string;
@@ -38,18 +49,18 @@ export interface Task {
   // The task's last commit from its review, and the accepted text it included.
   committed?: { hash: string; accepted: string; at: number; pushed?: boolean } | null;
 }
-// A task the author is through with, which Papilot archives once they leave
-// it: every change of its last result is decided, no comment or rejection
+// A task the author is through with, so the saved result can offer archiving:
+// every change of its last result is decided, no comment or rejection
 // waits to go back to the agent, and what was accepted has left the task
 // (applied or committed; older tasks accept straight into the working
 // directory). An answer without manuscript changes is finished too.
 export function taskFinished(task: Task) {
   const review = task.review;
-  if (task.status !== 'reviewing' || !review || task.pendingReview || task.delivery?.pending || review.counts?.pending || review.state === 'build_failed') return false;
+  if (task.status !== 'reviewing' || !review || task.reconciliation || task.pendingReview || task.delivery?.pending || review.counts?.pending || review.state === 'build_failed') return false;
   const unsent = review.unsent ?? ['accepted', 'rejected', 'commented'].reduce((count, kind) => count + (review.counts?.[kind] || 0), 0);
   if ((review.comments ?? unsent) > 0 || (unsent > 0 && !review.counts?.accepted)) return false;
   if (review.round === null) return true;
-  return review.state === 'done' && (!task.deferred || review.files?.length === 0);
+  return review.state === 'done' && (!task.deferred || (review.files?.length === 0 && task.delivery?.mode !== 'branch'));
 }
 // reviewRound is 0 while awaiting a result, null when no changes were produced,
 // or the published round. Older runs omit it.
@@ -70,10 +81,10 @@ export interface BuildFailure { error: string; details: string[]; log?: string }
 export interface FeedbackSummary { round: number | null; accepted: number; rejected: number; undone: number; comments: { where: string; text: string }[]; buildError?: boolean }
 export interface Skill { output?: 'annotations'; id: string; name: string; description: string; hint: string; icon?: SkillIcon; source: 'builtin' | 'user' | 'paper' }
 export interface PendingRequest { id: string; taskId: string; method: string; params: Record<string, any>; createdAt: number }
-export type AgentId = 'codex' | 'claude' | 'antigravity' | 'kimi' | 'cursor' | 'opencode' | 'qwen' | 'glm' | 'deepseek';
+export type AgentId = 'codex' | 'claude' | 'antigravity' | 'kimi' | 'cursor' | 'copilot' | 'grok' | 'opencode' | 'qwen' | 'glm' | 'deepseek';
 // Every agent Papilot can drive, in menu order. Only the ones found on the host are offered.
-export const AGENT_IDS: AgentId[] = ['codex', 'claude', 'cursor', 'antigravity', 'kimi', 'glm', 'deepseek', 'qwen', 'opencode'];
-export const AGENT_NAMES: Record<AgentId, string> = { codex: 'Codex', claude: 'Claude', cursor: 'Cursor', antigravity: 'Antigravity', kimi: 'Kimi', glm: 'GLM', deepseek: 'DeepSeek', qwen: 'Qwen', opencode: 'OpenCode' };
+export const AGENT_IDS: AgentId[] = ['codex', 'claude', 'cursor', 'copilot', 'grok', 'antigravity', 'kimi', 'glm', 'deepseek', 'qwen', 'opencode'];
+export const AGENT_NAMES: Record<AgentId, string> = { codex: 'Codex', claude: 'Claude', cursor: 'Cursor', copilot: 'Copilot', grok: 'Grok', antigravity: 'Antigravity', kimi: 'Kimi', glm: 'GLM', deepseek: 'DeepSeek', qwen: 'Qwen', opencode: 'OpenCode' };
 export const isAgentId = (value: unknown): value is AgentId => AGENT_IDS.includes(value as AgentId);
 export interface AgentModel { id: string; name: string; isDefault: boolean; efforts: string[]; defaultEffort: string | null; fastMode?: { serviceTier: string; description: string } }
 // The account's included usage: rolling windows (minutes long, reset time in ms) and credits.

package/src/skill-metadata.ts

@@ -40,6 +40,6 @@ export function setSkillMetadata(content: string, field: 'name' | 'description'
   return `${bom}---${newline}${next.join(newline)}${newline}---${closingNewline}${source.slice(header[0].length)}`;
 }
 export function setSkillInstructions(content: string, body: string) {
-  const { bom, source, header, newline } = parts(content);
+  const { bom, header, newline } = parts(content);
   return header ? `${bom}${header[0]}${header[0].endsWith('\n') ? '' : newline}${body}` : `${bom}${body}`;
 }