papilot 0.8.1 → 0.8.2

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-BlLyIqT9.js"></script>
-  <link rel="stylesheet" crossorigin href="/assets/index-DVZtyZvu.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-oAIkxhfp.js"></script>
+  <link rel="stylesheet" crossorigin href="/assets/index-t_qCOF_B.css">
 </head><body><div id="root"></div></body></html>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "papilot",
-  "version": "0.8.1",
+  "version": "0.8.2",
   "description": "A Cursor-like workspace for your papers: annotate and review PDFs directly without ever touching LaTeX.",
   "keywords": [
     "latex",
@@ -57,6 +57,7 @@
   "engines": {
     "node": ">=22.22.0"
   },
+  "desktopShell": 1,
   "scripts": {
     "dev": "tsx watch src/server/main.ts",
     "start": "tsx src/server/main.ts",
@@ -68,14 +69,17 @@
     "doctor": "node bin/papilot.mjs doctor",
     "service:install": "tsx scripts/service.ts install",
     "service:stop": "tsx scripts/service.ts stop",
-    "test:ui": "npm run build && node scripts/check-ui.mjs && node scripts/check-appearance.mjs && node scripts/check-updates.mjs && node scripts/check-papers.mjs && node scripts/check-imports.mjs && node scripts/check-compilation.mjs && node scripts/check-build-problems.mjs && node scripts/check-review-notes.mjs && node --import tsx scripts/check-note-groups.mjs && node scripts/check-note-selection.mjs && node scripts/check-ai-review.mjs && node --import tsx scripts/check-note-results.mjs && node --import tsx scripts/check-review-flow.mjs && node scripts/check-skills.mjs && node --import tsx scripts/check-skill-library.mjs && node scripts/check-attachments.mjs && node --import tsx scripts/check-accounts.mjs",
+    "test:ui": "npm run build && node scripts/check-ui.mjs && node scripts/check-task-model.mjs && node scripts/check-appearance.mjs && node scripts/check-updates.mjs && node scripts/check-papers.mjs && node scripts/check-imports.mjs && node scripts/check-compilation.mjs && node scripts/check-build-problems.mjs && node scripts/check-review-notes.mjs && node --import tsx scripts/check-note-groups.mjs && node scripts/check-note-selection.mjs && node scripts/check-ai-review.mjs && node --import tsx scripts/check-note-results.mjs && node --import tsx scripts/check-review-flow.mjs && node scripts/check-skills.mjs && node --import tsx scripts/check-skill-library.mjs && node scripts/check-attachments.mjs && node --import tsx scripts/check-accounts.mjs",
     "site": "node scripts/build-site.mjs",
     "test:site": "npm run site && node scripts/check-site.mjs",
     "prepack": "npm run build && npm run setup:review",
     "desktop:compile": "tsc -p desktop/tsconfig.json",
     "desktop": "npm run setup:review && npm run build && npm run desktop:compile && node scripts/desktop.mjs dev",
     "desktop:build": "npm run setup:review && npm run build && npm run desktop:compile && node scripts/desktop.mjs package",
-    "test:desktop": "node scripts/check-desktop.mjs"
+    "test:desktop": "node scripts/check-desktop.mjs",
+    "i18n": "tsx scripts/i18n.ts",
+    "i18n:check-app": "tsx scripts/i18n/app-locales.ts",
+    "test:locales": "npm run build && npm --prefix vendor/latex-review run build && node --import tsx scripts/check-locales.mjs"
   },
   "dependencies": {
     "@fastify/compress": "^9.2.2",
@@ -109,6 +113,9 @@
     "remark-gfm": "^4.0.1",
     "remark-math": "^6.0.0",
     "typescript": "^7.0.2",
-    "vite": "^8.3.5"
+    "vite": "^8.3.5",
+    "parse5": "^8.0.1",
+    "@babel/parser": "^8.0.10",
+    "@babel/types": "^8.0.10"
   }
 }

package/src/server/acp.ts

@@ -218,7 +218,8 @@ export class AcpAgent extends Adapter {
       const previous = this.catalog.find(entry => entry.model === option.value);
       const entry = { model: option.value, displayName: option.name, isDefault: option.value === this.defaultModel,
         supportedReasoningEfforts: option.value === current ? levels.map(choice => ({ reasoningEffort: choice.value })) : previous?.supportedReasoningEfforts || [],
-        defaultReasoningEffort: option.value === current ? level : previous?.defaultReasoningEffort || null };
+        // A turn's explicit effort must not become the catalog's default.
+        defaultReasoningEffort: previous?.supportedReasoningEfforts.length ? previous.defaultReasoningEffort : option.value === current ? level : null };
       if (previous) Object.assign(previous, entry); else this.catalog.push(entry);
     }
   }
@@ -239,10 +240,13 @@ export class AcpAgent extends Adapter {
     };
     try {
       const session = await this.session(turn.threadId, thread.cwd, thread.model);
-      if (effort) {
-        const option = session.configOptions?.find(option => option.category === 'thought_level' || option.id === 'thinking');
-        if (!option || !choices(option).some(choice => choice.value === effort)) throw new Error(`${this.name} does not support reasoning effort ${effort} for this model.`);
-        await this.rpc('session/set_config_option', { sessionId: turn.threadId, configId: option.id, value: effort });
+      const option = session.configOptions?.find(option => option.category === 'thought_level' || option.id === 'thinking');
+      const defaultEffort = choices(option).some(choice => choice.value === 'default') ? 'default' : this.catalog.find(model => model.model === thread.model)?.defaultReasoningEffort;
+      const chosenEffort = effort || defaultEffort;
+      if (chosenEffort) {
+        if (!option || !choices(option).some(choice => choice.value === chosenEffort)) throw new Error(`${this.name} does not support reasoning effort ${chosenEffort} for this model.`);
+        const result = await this.rpc('session/set_config_option', { sessionId: turn.threadId, configId: option.id, value: chosenEffort });
+        if (result?.configOptions) session.configOptions = result.configOptions;
       }
       const prompt: any[] = [{ type: 'text', text: thread.started ? text : `${thread.instructions}\n\n---\n\n${text}` }];
       if (images.length && !this.capabilities.promptCapabilities?.image) throw new Error(`This ${this.name} version does not support image input. Update it, or send the images to another agent.`);

package/src/server/agents.ts

@@ -8,7 +8,7 @@ import { createRequire } from 'node:module';
 import os from 'node:os';
 import path from 'node:path';
 import { pathToFileURL } from 'node:url';
-import type { AccountInfo, ModelInfo, Options, PermissionResult, Query, SDKMessage, SDKRateLimitInfo, SDKUserMessage } from '@anthropic-ai/claude-agent-sdk';
+import type { AccountInfo, ModelInfo, Options, PermissionResult, SDKMessage, SDKRateLimitInfo, SDKUserMessage } from '@anthropic-ai/claude-agent-sdk';
 import { AGENT_NAMES } from '../shared.ts';
 import { DATA, ROOT } from './paths.ts';
 import { imageType } from './attachments.ts';
@@ -79,13 +79,15 @@ export abstract class Adapter extends EventEmitter implements AgentRuntime {
     if (method === 'turn/start') {
       const thread = this.threads.get(String(params.threadId));
       if (!thread) throw new Error('Start or resume the thread before starting a turn.');
+      if (params.model !== undefined) thread.model = params.model || null;
       const text = (params.input || []).filter((part: { text?: unknown }) => typeof part.text === 'string').map((part: { text: string }) => part.text).join('\n');
       const images = (params.input || []).filter((part: { type?: string; path?: string }) => part.type === 'localImage' && typeof part.path === 'string').map((part: { path: string }) => part.path);
       const turn: Turn = { id: randomUUID(), threadId: String(params.threadId), clientId: params.clientUserMessageId, status: 'inProgress', stop: () => {} };
       turn.stop = () => this.finish(turn, 'interrupted');
       this.turns.set(turn.id, turn);
       // Papilot records the turn ID before the first event arrives.
-      setImmediate(() => { if (turn.status === 'inProgress') this.run(turn, { ...thread, cwd: params.cwd || thread.cwd }, text, params.effort || null, images); });
+      const settings = { ...thread, cwd: params.cwd || thread.cwd };
+      setImmediate(() => { if (turn.status === 'inProgress') this.run(turn, settings, text, params.effort || null, images); });
       return { turn: { id: turn.id } };
     }
     if (method === 'turn/interrupt') { this.turns.get(String(params.turnId))?.stop(); return {}; }

package/src/server/app.ts

@@ -263,6 +263,13 @@ export async function buildApp(options: AppOptions) {
     const task = store.task(request.params.id);
     return workspace.commitMessage(task.projectId, task.review?.files || [], { taskId: task.id, agent: task.agent, fresh: (request.body as any)?.fresh === true });
   });
+  app.post<{ Params: { id: string } }>('/api/tasks/:id/model', task, request => {
+    const b = (request.body || {}) as Record<string, unknown>;
+    if (Object.keys(b).some(key => !['model', 'effort', 'serviceTier'].includes(key))) throw new Error('Only the model and its settings can be changed.');
+    if (b.model !== undefined && (typeof b.model !== 'string' || b.model.length > 200)) throw new Error('Invalid model.');
+    if (b.effort !== undefined && b.effort !== '' && !effort(b.effort)) throw new Error('Invalid reasoning effort.');
+    return workspace.updateTaskModel(request.params.id, { ...(b.model !== undefined ? { model: b.model as string } : {}), ...(b.effort !== undefined ? { effort: b.effort as string } : {}), ...(b.serviceTier !== undefined ? { serviceTier: string(b.serviceTier, 'Service tier', 64) } : {}) });
+  });
   app.post<{ Params: { id: string } }>('/api/tasks/:id/rename', task, request => workspace.renameTask(request.params.id, string((request.body as any).title, 'Task title', 120)));
   app.post<{ Params: { id: string } }>('/api/tasks/:id/title', task, request => workspace.requestTaskTitle(request.params.id));
   app.post<{ Params: { id: string } }>('/api/tasks/:id/archive', task, request => workspace.archiveTask(request.params.id, (request.body as any)?.archived, (request.body as any)?.finished === true));

package/src/server/imports.ts

@@ -12,6 +12,7 @@ import type { PaperImport, Project } from '../shared.ts';
 import type { Manuscripts } from './manuscript.ts';
 
 const execute = promisify(execFile);
+// These limits apply to uploads, not folders already on this computer.
 const MAX_BYTES = 64 * 1024 * 1024, MAX_FILES = 5000;
 const CONFIG = '.latex-review.json';
 const skip = (name: string) => ['.git', '__macosx', '.ds_store', 'node_modules', '.papilot'].includes(name.toLowerCase()) || name.startsWith('._');
@@ -33,40 +34,71 @@ function config(root: string): Record<string, unknown> {
   return data;
 }
 export function texFiles(root: string) {
-  const files: string[] = []; let count = 0;
-  function walk(folder: string, depth: number) {
-    if (depth > 20) return;
+  const files: string[] = [], folders = [''];
+  while (folders.length) {
+    const folder = folders.pop()!;
     for (const item of fs.readdirSync(path.join(root, folder), { withFileTypes: true })) {
-      if (++count > MAX_FILES) throw new Error('This folder has too many files. Select the folder containing just the paper.');
       if (skip(item.name) || ['build', 'out', 'output'].includes(item.name)) continue;
       const file = path.posix.join(folder, item.name);
-      if (item.isDirectory()) walk(file, depth + 1);
+      if (item.isDirectory()) folders.push(file);
       else if (item.isFile() && /\.tex$/i.test(file)) files.push(file);
     }
   }
-  walk('', 0); return files.sort();
+  return files.sort();
+}
+function existingTex(root: string, file: unknown): file is string {
+  if (typeof file !== 'string' || !/\.tex$/i.test(file)) return false;
+  try {
+    safeName(file);
+    let current = root;
+    for (const part of file.split('/')) {
+      current = path.join(current, part);
+      if (fs.lstatSync(current).isSymbolicLink()) return false;
+    }
+    return fs.statSync(current).isFile();
+  } catch { return false; }
+}
+function sourceHead(file: string) {
+  const fd = fs.openSync(file, 'r');
+  try {
+    const buffer = Buffer.alloc(300000);
+    return buffer.subarray(0, fs.readSync(fd, buffer, 0, buffer.length, 0)).toString('utf8');
+  } finally { fs.closeSync(fd); }
 }
 export async function inspectPaper(root: string) {
-  const files = texFiles(root), roots = files.filter(file => {
-    const text = fs.readFileSync(path.join(root, file), 'utf8').slice(0, 300000).replace(/(?<!\\)%[^\n]*/g, '');
-    return /\\documentclass\b/.test(text) && /\\begin\s*\{document\}/.test(text);
-  });
-  let main = roots.length === 1 ? roots[0] : '', engine = '', error: string | undefined;
+  let settings: Record<string, unknown> = {}, error: string | undefined;
+  try { settings = config(root); } catch (failure) { error = (failure as Error).message; }
+  let main = existingTex(root, settings.main) ? settings.main : '', engine = '';
+  // Most papers already declare their main file or keep it near the root.
+  // Do not enumerate caches, assets and supporting papers just to open them.
+  if (!main) {
+    try {
+      const module = await import(pathToFileURL(path.join(ENGINE, 'src/core/config.ts')).href);
+      const detected = module.detectMain(root);
+      if (existingTex(root, detected)) main = detected;
+    } catch { /* Unusual layouts fall back to a deeper search. */ }
+  }
+  let candidates = main ? [main] : [];
+  if (!main) {
+    const files = texFiles(root), roots = files.filter(file => {
+      const text = sourceHead(path.join(root, file)).replace(/(?<!\\)%[^\n]*/g, '');
+      return /\\documentclass\b/.test(text) && /\\begin\s*\{document\}/.test(text);
+    });
+    main = roots.length === 1 ? roots[0] : '';
+    const found = new Set(roots);
+    candidates = [...roots, ...files.filter(file => !found.has(file))];
+  }
   try {
-    const settings = config(root);
-    if (typeof settings.main === 'string' && files.includes(settings.main)) main = settings.main;
-    const module = await import(pathToFileURL(path.join(ENGINE, 'src/core/config.ts')).href);
-    if (!main) { try { main = module.detectMain(root); } catch { /* The author chooses among all TeX files. */ } }
     // Engine detection also works before Git initialization by reading the source hints.
     if (main) {
-      const text = fs.readFileSync(path.join(root, main), 'utf8');
+      const text = sourceHead(path.join(root, main));
       engine = typeof settings.engine === 'string' ? settings.engine : '';
       const rc = [path.join(path.dirname(main), '.latexmkrc'), path.join(path.dirname(main), 'latexmkrc'), '.latexmkrc', 'latexmkrc'].find(file => fs.existsSync(path.join(root, file)));
       const mode = rc ? fs.readFileSync(path.join(root, rc), 'utf8').match(/^\s*\$pdf_mode\s*=\s*(\d)/m)?.[1] : undefined;
       if (!engine) engine = text.match(/^%\s*!\s*TEX\s+(?:TS-)?program\s*=\s*(pdflatex|xelatex|lualatex)/im)?.[1].toLowerCase() || ({ '1': 'pdflatex', '4': 'lualatex', '5': 'xelatex' } as Record<string, string>)[mode || ''] || (/\\(?:usepackage(?:\[[^\]]*\])?\{[^}]*\b(?:fontspec|xeCJK|unicode-math|polyglossia)\b|documentclass(?:\[[^\]]*\])?\{ctex)/.test(text) ? 'xelatex' : 'pdflatex');
     }
   } catch (failure) { error = (failure as Error).message; }
-  return { candidates: [...roots, ...files.filter(file => !roots.includes(file))], main, engine: engine || 'pdflatex', error };
+  return { candidates, main, engine: engine || 'pdflatex', error };
 }
 async function repositoryRoot(root: string) {
   let top: string | undefined;
@@ -170,7 +202,7 @@ export class PaperImports {
     if (this.active.has(id)) return value;
     if (this.registered(value.path)) throw new Error('This paper is already added. Open it from the paper list.');
     const main = input.main ?? value.main, engine = input.engine ?? value.engine;
-    if (typeof main !== 'string' || !texFiles(value.path).includes(main)) throw new Error('Choose an existing TeX main file.');
+    if (!existingTex(value.path, main)) throw new Error('Choose an existing TeX main file.');
     if (!['pdflatex', 'xelatex', 'lualatex'].includes(engine as string)) throw new Error('Choose a supported LaTeX engine.');
     if (input.name !== undefined && (typeof input.name !== 'string' || !input.name.trim() || input.name.length > 120)) throw new Error('Enter a paper name under 120 characters.');
     this.active.add(id);
@@ -181,13 +213,20 @@ export class PaperImports {
       try {
         await repositoryRoot(value.path);
         if (!repair) {
-          const settings = config(value.path);
-          fs.writeFileSync(path.join(value.path, CONFIG), JSON.stringify({ ...settings, main, engine, source_dir: '' }, null, 2) + '\n');
+          // Keep the author's settings, including a source folder that still
+          // contains the main file; without one, the whole folder compiles.
+          const settings = config(value.path), folder = typeof settings.source_dir === 'string' ? settings.source_dir.replace(/\/+$/, '') : null;
+          const contains = folder === '' || (folder !== null && (main as string).startsWith(folder + '/'));
+          const next = { ...settings, main, engine, ...(contains ? {} : { source_dir: '' }) };
+          if (JSON.stringify(next) !== JSON.stringify(settings)) fs.writeFileSync(path.join(value.path, CONFIG), JSON.stringify(next, null, 2) + '\n');
         }
         await prepareRepository(value.path); value.versioned = true;
         if (repair) { value.summary = await repair(value.path, previousError); Object.assign(value, await inspectPaper(value.path)); }
         value.phase = 'building'; this.save(value);
-        let result = await this.manuscripts.state('import-' + id, value.path, true);
+        // A retry starts a new build without forcing a clean one, so the
+        // opened paper finds this PDF in the cache instead of compiling again.
+        this.manuscripts.forgetProject('import-' + id);
+        let result = await this.manuscripts.state('import-' + id, value.path);
         while (result.build.status === 'building') { await new Promise(resolve => setTimeout(resolve, 400)); result = await this.manuscripts.state('import-' + id, value.path); }
         value.phase = result.build.status === 'ready' ? 'ready' : 'failed'; value.error = result.build.error;
       } catch (error) { value.phase = 'failed'; value.error = (error as Error).message; }

package/src/server/manuscript.ts

@@ -1,6 +1,6 @@
 import type { ReviewSnapshot } from './ai-review.ts';
 import { execFile } from 'node:child_process';
-import { createHash } from 'node:crypto';
+import { createHash, randomUUID } from 'node:crypto';
 import { EventEmitter } from 'node:events';
 import fs from 'node:fs';
 import os from 'node:os';
@@ -223,14 +223,29 @@ async function gitAction(root: string, args: string[], timeout = 60_000) {
 }
 
 // The preview shows the manuscript as it is on disk, including accepted but
-// uncommitted review changes. A temporary index records it as a Git tree
-// without touching the real index, branches or files.
+// uncommitted review changes. A private index records it as a Git tree
+// without touching the real index, branches or files. It starts from the
+// previous snapshot's index, or the repository's, so Git rehashes only files
+// whose size or modification time changed.
 export async function workingTree(root: string) {
-  const folder = fs.mkdtempSync(path.join(os.tmpdir(), 'papilot-index-')), env = { GIT_INDEX_FILE: path.join(folder, 'index') };
-  try {
-    await git(root, ['read-tree', 'HEAD'], env);
+  const dir = gitDir(root), saved = dir && path.join(dir, 'latex-review', 'working-index');
+  const folder = fs.mkdtempSync(path.join(os.tmpdir(), 'papilot-index-')), index = path.join(folder, 'index'), env = { GIT_INDEX_FILE: index };
+  const snapshot = async (seed: string | null | undefined) => {
+    if (seed && fs.existsSync(seed)) fs.copyFileSync(seed, index);
+    else { fs.rmSync(index, { force: true }); await git(root, ['read-tree', 'HEAD'], env).catch(() => git(root, ['read-tree', '--empty'], env)); }
     await git(root, ['add', '-A'], env);
     return (await git(root, ['write-tree'], env)).trim();
+  };
+  try {
+    let tree: string;
+    try { tree = await snapshot(saved && fs.existsSync(saved) ? saved : dir && path.join(dir, 'index')); }
+    catch { tree = await snapshot(null); }
+    if (saved) try {
+      fs.mkdirSync(path.dirname(saved), { recursive: true });
+      const temporary = `${saved}.${randomUUID()}.tmp`;
+      fs.copyFileSync(index, temporary); fs.renameSync(temporary, saved);
+    } catch { /* The next snapshot rehashes more files. */ }
+    return tree;
   } finally { fs.rmSync(folder, { recursive: true, force: true }); }
 }
 
@@ -380,7 +395,10 @@ export class Manuscripts extends EventEmitter {
   }
 
   async state(projectId: string, root: string, rebuild = false): Promise<{ git: GitStatus; build: ManuscriptBuild }> {
-    const [status, tree] = await Promise.all([gitStatus(root), workingTree(root)]);
+    const current = this.builds.get(projectId);
+    // Polling an in-flight build needs its status, not another source snapshot.
+    // Once it finishes, the next read checks for edits made during compilation.
+    const [status, tree] = await Promise.all([gitStatus(root), current?.status === 'building' ? current.tree : workingTree(root)]);
     let build = this.builds.get(projectId);
     if (!build || (build.status !== 'building' && (build.tree !== tree || rebuild))) build = this.start(projectId, root, tree, build, rebuild);
     const { status: state, key, pages, builtAt, error } = build;
@@ -444,7 +462,7 @@ export class Manuscripts extends EventEmitter {
   async reanchor(projectId: string, root: string, notes: Annotation[]): Promise<Annotation[]> {
     const build = this.builds.get(projectId);
     if (!build?.pdf || !build.key || build.status !== 'ready' || !notes.some(note => note.key !== build.key)) return notes;
-    const { PdfDocument, loadProject } = await engine();
+    const { PdfDocument } = await engine();
     const current = new PdfDocument(build.pdf), target = new AnnotationPages(current);
     const old = new Map<string, { document: InstanceType<typeof PdfDocument>; pages: AnnotationPages }>();
     try {

package/src/server/start.ts

@@ -10,6 +10,7 @@ import { Manuscripts } from './manuscript.ts';
 import { Changes } from './changes.ts';
 import { buildApp, gitQueue } from './app.ts';
 import { Updates } from './updates.ts';
+import { installRelease } from './update-install.ts';
 import { readJson } from '../../bin/installation.mjs';
 import { desktopDemo } from './desktop-demo.ts';
 
@@ -21,8 +22,14 @@ const accounts = new Accounts(store, ACCOUNT_ORIGIN || null);
 const manuscripts = new Manuscripts(), changes = new Changes();
 const desktop = process.env.PAPILOT_DESKTOP === '1';
 if (desktop) await desktopDemo(ROOT, DATA, store, workspace, manuscripts).catch(error => console.error('Could not prepare the demo paper:', error));
+// A packaged desktop app installs newer releases and restarts them itself.
+const shell = desktop && process.send ? Number(process.env.PAPILOT_DESKTOP_SHELL) || 0 : 0, downloadUrl = 'https://github.com/PapilotAI/papilot/releases/latest';
 const updates = new Updates({ root: ROOT, data: DATA, version: VERSION, port: PORT,
-  ...(desktop ? { supported: false, downloadUrl: 'https://github.com/PapilotAI/papilot/releases/latest' } : {}),
+  ...(shell ? {
+    desktop: { shell, installer: process.env.PAPILOT_DESKTOP_INSTALLER || VERSION, downloadUrl },
+    install: (data: string, version: string) => installRelease(data, version, { shell, codex: process.env.PAPILOT_DESKTOP_CODEX }),
+    restart: async (root: string, version: string) => { process.send!({ type: 'papilot:activate', root, version }); },
+  } : desktop ? { supported: false, downloadUrl } : {}),
   busy: () => workspace.busyForUpdate || manuscripts.busyForUpdate || changes.busyForUpdate, shutdown: () => shutdown() });
 const activation = readJson(path.join(DATA, 'updates/active.json'));
 const updateInstance = typeof activation?.root === 'string' && fs.existsSync(activation.root) && fs.realpathSync(activation.root) === fs.realpathSync(ROOT) ? activation.id : undefined;

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,27 +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;
@@ -43,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;
@@ -51,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 = options.downloadUrl ? 'stable' : 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 };
@@ -66,7 +72,9 @@ export class Updates {
     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'; }
@@ -85,7 +93,7 @@ export class Updates {
     writeJson(this.file, { ...this.state, pid: process.pid });
   }
   setChannel(channel: unknown) {
-    if (this.options.downloadUrl) throw new Error('Download desktop updates from GitHub Releases.');
+    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();
@@ -101,9 +109,14 @@ export class Updates {
     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.' });
@@ -115,6 +128,7 @@ export class Updates {
   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 });
@@ -123,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

@@ -451,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;
@@ -1081,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,7 +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';