papilot 0.8.1 → 0.8.3

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;
@@ -117,7 +149,9 @@ export class PaperImports {
   private save(value: PaperImport) {
     fs.mkdirSync(path.join(this.directory, 'imports'), { recursive: true, mode: 0o700 });
     const file = path.join(this.directory, 'imports', value.id + '.json');
-    fs.writeFileSync(file + '.tmp', JSON.stringify(value), { mode: 0o600 }); fs.renameSync(file + '.tmp', file);
+    // Progress is live state; a restarted server fails a running import anyway.
+    const { progress: _progress, ...stored } = value;
+    fs.writeFileSync(file + '.tmp', JSON.stringify(stored), { mode: 0o600 }); fs.renameSync(file + '.tmp', file);
     this.sessions.set(value.id, value); return { ...value };
   }
   get(id: string) {
@@ -170,28 +204,38 @@ 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);
     const previousError = value.error || '';
-    Object.assign(value, { main, engine, ...(input.name ? { name: input.name } : {}), phase: repair ? 'repairing' : 'building', error: undefined });
+    Object.assign(value, { main, engine, ...(input.name ? { name: input.name } : {}), phase: repair ? 'repairing' : 'building', error: undefined, startedAt: Date.now(), progress: undefined });
     this.save(value);
     void (async () => {
       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);
-        while (result.build.status === 'building') { await new Promise(resolve => setTimeout(resolve, 400)); result = await this.manuscripts.state('import-' + id, value.path); }
+        // 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') {
+          value.progress = result.build.progress;
+          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; }
-      finally { this.active.delete(id); this.save(value); }
+      finally { this.active.delete(id); value.progress = undefined; this.save(value); }
     })();
     return this.get(id);
   }

package/src/server/main.ts

@@ -3,8 +3,9 @@ import { pathToFileURL } from 'node:url';
 import { ROOT, DATA } from './paths.ts';
 import { activeInstallation, waitForActivation } from '../../bin/installation.mjs';
 
-await waitForActivation(DATA);
-const root = activeInstallation(ROOT, DATA);
+const desktop = process.env.PAPILOT_DESKTOP === '1';
+if (!desktop) await waitForActivation(DATA);
+const root = desktop ? ROOT : activeInstallation(ROOT, DATA);
 // A source checkout's default data directory must not move with the release.
 process.env.PAPILOT_DATA = DATA;
 await import(pathToFileURL(path.join(root, 'src/server/start.ts')).href);

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';
@@ -8,7 +8,7 @@ import path from 'node:path';
 import { promisify } from 'node:util';
 import { pathToFileURL } from 'node:url';
 import { ENGINE } from './paths.ts';
-import type { Annotation, BuildProblem, GitFile, GitStatus, ManuscriptBuild, ManuscriptProblems } from '../shared.ts';
+import type { Annotation, BuildProblem, BuildProgress, GitFile, GitStatus, ManuscriptBuild, ManuscriptProblems } from '../shared.ts';
 import { notesInstructions } from '../notes.ts';
 import { ignorePattern } from '../commit.ts';
 import { AnnotationPages, placeAnnotation } from './annotation-placement.ts';
@@ -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 }); }
 }
 
@@ -345,7 +360,7 @@ export async function pdfWords(pdf: string, page: number) {
 // `problems` come from the last finished build. They are placed on the PDF
 // named `problemsKey`; a failed build has no PDF of its own to place them on.
 interface Build {
-  tree: string; status: ManuscriptBuild['status']; key?: string; pdf?: string; root?: string; sourceDir?: string; pages?: [number, number][]; builtAt?: number; error?: string;
+  tree: string; status: ManuscriptBuild['status']; key?: string; pdf?: string; root?: string; sourceDir?: string; pages?: [number, number][]; builtAt?: number; error?: string; progress?: BuildProgress;
   problems?: StoredProblem[]; problemsKey?: string; log?: string; logFolder?: string;
 }
 
@@ -380,11 +395,14 @@ 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;
-    return { git: status, build: { status: state, key, pages, builtAt, error, current: build.tree === tree && state === 'ready', problems: build.problems && countProblems(build.problems) } };
+    return { git: status, build: { status: state, key, pages, builtAt, error, current: build.tree === tree && state === 'ready', problems: build.problems && countProblems(build.problems), ...(state === 'building' && build.progress ? { progress: build.progress } : {}) } };
   }
 
   // Keep the previous pages visible while a newer working tree compiles.
@@ -397,7 +415,8 @@ export class Manuscripts extends EventEmitter {
       try {
         const { Builder, Repo, loadProject, mupdf } = await engine();
         project = loadProject(root);
-        const result = await new Builder(project, new Repo(root)).build(tree, ['full'], null, { force });
+        const startedAt = Date.now();
+        const result = await new Builder(project, new Repo(root)).build(tree, ['full'], null, { force, progress: (progress: Omit<BuildProgress, 'startedAt'>) => { if (this.builds.get(projectId) === build) build.progress = { ...progress, startedAt }; } });
         const document = mupdf.Document.openDocument(fs.readFileSync(result.pdf), 'application/pdf');
         const pages: [number, number][] = [];
         for (let i = 0; i < document.countPages(); i++) { const [x0, y0, x1, y1] = document.loadPage(i).getBounds(); pages.push([Math.round(x1 - x0), Math.round(y1 - y0)]); }
@@ -444,7 +463,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/paths.ts

@@ -3,7 +3,7 @@ import fs from 'node:fs';
 import { fileURLToPath } from 'node:url';
 export const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../..');
 export const DATA = path.resolve(process.env.PAPILOT_DATA || path.join(ROOT, '.papilot'));
-export const ENGINE = path.resolve(process.env.PAPILOT_REVIEW_ENGINE || path.join(ROOT, 'vendor/latex-review'));
+export const ENGINE = path.resolve(process.env.PAPILOT_REVIEW_ENGINE || path.join(ROOT, 'engine'));
 export const VERSION: string = JSON.parse(fs.readFileSync(path.join(ROOT, 'package.json'), 'utf8')).version;
 export const PORT = Number(process.env.PAPILOT_PORT || 7274);
 export const PUBLIC_ORIGIN = process.env.PAPILOT_PUBLIC_ORIGIN || '';

package/src/server/start.ts

@@ -21,10 +21,10 @@ 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));
-const updates = new Updates({ root: ROOT, data: DATA, version: VERSION, port: PORT,
-  ...(desktop ? { supported: false, downloadUrl: 'https://github.com/PapilotAI/papilot/releases/latest' } : {}),
+// Desktop releases are complete installers; npm updates belong to the web server.
+const updates = new Updates({ root: ROOT, data: DATA, version: VERSION, port: PORT, desktop,
   busy: () => workspace.busyForUpdate || manuscripts.busyForUpdate || changes.busyForUpdate, shutdown: () => shutdown() });
-const activation = readJson(path.join(DATA, 'updates/active.json'));
+const activation = desktop ? null : 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;
 const shared = {
   store, workspace, accounts, manuscripts, changes, updates, updateInstance, csrf: randomBytes(32).toString('base64url'), serialGit: gitQueue(),

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

@@ -71,7 +71,7 @@ export async function prepareDev(root: string, version: string, log: number, run
   // Test-only tools can exclude a Node version that supports the application.
   // Build first, then enforce engine compatibility for the retained runtime.
   await run(['ci', '--include=dev', '--engine-strict=false', ...flags], root, log);
-  const engine = path.join(root, 'vendor/latex-review');
+  const engine = path.join(root, 'engine');
   await run(['ci', '--include=dev', '--engine-strict=false', ...flags], engine, log);
   // Only this installed snapshot gets a dev version; the repository stays unchanged.
   fs.writeFileSync(path.join(root, 'package.json'), JSON.stringify({ ...pkg, version }, null, 2) + '\n');
@@ -103,6 +103,7 @@ async function installDev(data: string, version: string) {
   finally { fs.closeSync(log); }
 }
 export async function installRelease(data: string, version: string) {
+  if (process.env.PAPILOT_DESKTOP === '1') throw new Error('Download desktop updates from GitHub Releases.');
   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 });
@@ -113,10 +114,12 @@ export async function installRelease(data: string, version: string) {
     await runInstall(['install', '--prefix', stage, '--save-exact', ...flags, `papilot@${version}`], stage, log);
     const pkg = readJson(path.join(root, 'package.json'));
     if (pkg?.name !== 'papilot' || pkg.version !== version) throw new Error('The downloaded package does not match the requested release.');
-    for (const file of ['dist/index.html', 'src/server/start.ts', 'src/server/main.ts', 'bin/papilot.mjs', 'vendor/latex-review/package-lock.json']) {
+    // Releases also ship an empty vendor/latex-review package, where 0.8.2 and
+    // earlier look for the engine when they install an update.
+    for (const file of ['dist/index.html', 'src/server/start.ts', 'src/server/main.ts', 'bin/papilot.mjs', 'engine/package-lock.json']) {
       if (!fs.existsSync(path.join(root, file))) throw new Error('The downloaded release is incomplete.');
     }
-    await runInstall(['ci', '--prefix', path.join(root, 'vendor/latex-review'), ...flags], stage, log);
+    await runInstall(['ci', '--prefix', path.join(root, 'engine'), ...flags], 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

@@ -8,34 +8,54 @@ import type { UpdateChannel, UpdateStatus } from '../shared.ts';
 
 const activePhases = new Set(['installing', 'waiting', 'restarting']);
 export const alive = (pid: number) => { try { process.kill(pid, 0); return true; } catch { return false; } };
-async function releaseInfo(url: string, fetcher: typeof fetch) {
+async function releaseInfo(url: string, fetcher: typeof fetch, limit = 256000) {
   const response = await fetcher(url, { signal: AbortSignal.timeout(10000), redirect: 'error', headers: { Accept: 'application/json', 'User-Agent': 'Papilot' } });
   if (!response.ok) throw new Error('Could not check for updates.');
   const text = await response.text();
-  if (text.length > 256000) throw new Error('Invalid release information.');
+  if (text.length > limit) 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;
+export const DESKTOP_RELEASES = 'https://github.com/PapilotAI/papilot/releases';
+// npm can be published before desktop builds finish. Only advertise releases
+// with an uploaded installer for this OS and CPU, and link to that exact release.
+export async function latestDesktopRelease(platform = process.platform, arch = process.arch, fetcher = fetch) {
+  const releases = await releaseInfo('https://api.github.com/repos/PapilotAI/papilot/releases?per_page=100', fetcher, 4 * 1024 * 1024);
+  if (!Array.isArray(releases)) throw new Error('Invalid release information.');
+  let latest: { version: string; downloadUrl: string } | null = null;
+  for (const release of releases) {
+    const version = typeof release.tag_name === 'string' ? release.tag_name.replace(/^v/, '') : '';
+    if (release.draft !== false || release.prerelease !== false || !stableVersion(version) || !Array.isArray(release.assets)) continue;
+    const names = platform === 'darwin' && ['arm64', 'x64'].includes(arch) ? [`Papilot-${version}-mac-${arch}.dmg`, `Papilot-${version}-mac-${arch}.zip`]
+      : platform === 'linux' && ['arm64', 'x64'].includes(arch) ? [`Papilot-${version}-linux-${arch === 'x64' ? 'x86_64' : arch}.AppImage`, `Papilot-${version}-linux-${arch === 'x64' ? 'amd64' : arch}.deb`] : [];
+    if (!release.assets.some((asset: any) => asset.state === 'uploaded' && asset.size > 0 && names.includes(asset.name))) continue;
+    if (!latest || newerVersion(version, latest.version)) latest = { version, downloadUrl: `${DESKTOP_RELEASES}/tag/${release.tag_name}` };
+  }
+  return latest;
 }
 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 {
-  downloadUrl?: string;
+  desktop?: boolean;
+  latestDesktop?: () => Promise<{ version: string; downloadUrl: string } | null>;
   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 +63,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,28 +70,28 @@ export class Updates {
   private file: string;
   private lock: string;
   private channel: UpdateChannel;
+  private downloadUrl = DESKTOP_RELEASES;
   constructor(private options: Options) {
-    this.file = path.join(options.data, 'updates/status.json'); this.lock = path.join(options.data, 'updates/install.lock');
+    this.file = path.join(options.data, options.desktop ? 'updates/desktop/status.json' : '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';
-    let supported = options.supported ?? true;
-    if (options.supported === undefined) try { npmCli(); } catch { supported = false; }
+    this.channel = options.desktop ? 'stable' : preference === 'dev' || preference === 'stable' ? preference : devRevision(options.version) ? 'dev' : 'stable';
+    let supported = options.desktop ? false : options.supported ?? true;
+    if (!options.desktop && options.supported === undefined) try { npmCli(); } catch { supported = false; }
     this.state = { currentVersion: options.version, latestVersion: null, phase: 'idle', checkedAt: null, error: null, canUpdate: supported };
-    const saved = readJson(this.file);
+    const saved = options.desktop ? null : readJson(this.file);
     if (saved && ['failed', 'updated', 'installing', 'waiting', 'restarting'].includes(saved.phase)) this.state = { ...this.state, ...saved, currentVersion: options.version, canUpdate: supported };
     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: 'stable', canUpdate: false, downloadUrl: this.downloadUrl };
     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();
@@ -85,7 +104,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.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();
@@ -96,14 +115,27 @@ 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 discovery = this.options.desktop ? (this.options.latestDesktop || latestDesktopRelease)() : (this.options.latest || latestManifest)(channel);
+    const checking = discovery.then(found => {
+      const manifest = typeof found === 'string' ? { version: found } : found;
+      if (!manifest && this.options.desktop) {
+        if (!this.closed && this.checking === checking) {
+          this.downloadUrl = DESKTOP_RELEASES;
+          this.change({ latestVersion: null, checkedAt: Date.now(), error: null, phase: 'idle' });
+        }
+        return this.snapshot();
+      }
+      const 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);
+        if (this.options.desktop) this.downloadUrl = manifest!.downloadUrl;
+        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.' });
@@ -113,7 +145,7 @@ export class Updates {
     return this.checking;
   }
   install(version: unknown) {
-    if (this.options.downloadUrl) throw new Error('Download desktop updates from GitHub Releases.');
+    if (this.options.desktop) throw new Error('Download desktop updates from GitHub Releases.');
     if (activePhases.has(this.state.phase)) return this.snapshot();
     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.');
@@ -123,11 +155,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,6 +9,7 @@ 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;
   channel?: UpdateChannel;
   currentVersion: string; latestVersion: string | null;
@@ -123,7 +124,10 @@ export interface GitWorktree {
 }
 export interface GitGraphCommit { hash: string; parents: string[]; subject: string; author: string; date: number; refs: string[] }
 export interface GitOverview { worktrees: GitWorktree[]; commits: GitGraphCommit[]; truncated: boolean }
-export interface ManuscriptBuild { status: 'building' | 'ready' | 'failed'; key?: string; pages?: [number, number][]; builtAt?: number; error?: string; current: boolean; problems?: BuildProblemCounts }
+// A running compilation, from latexmk's output: its step, the TeX pass, and
+// the pages typeset in that pass against the last known page count.
+export interface BuildProgress { step: 'tex' | 'bibliography' | 'pdf'; pass: number; pages: number; total: number | null; startedAt: number }
+export interface ManuscriptBuild { status: 'building' | 'ready' | 'failed'; key?: string; pages?: [number, number][]; builtAt?: number; error?: string; current: boolean; problems?: BuildProblemCounts; progress?: BuildProgress }
 // What the last finished build reported. Errors stop the build; warnings are
 // mistakes in the PDF (?? and missing citations); minor problems are
 // typesetting (overfull lines) and package remarks, listed but never counted.
@@ -153,6 +157,8 @@ export interface PaperImport {
   id: string; path: string; name: string; copied: boolean; candidates: string[]; main: string; engine: string;
   phase: 'choose' | 'building' | 'failed' | 'ready' | 'repairing';
   error?: string; summary?: string; versioned?: boolean;
+  // While building: when it started, and the compilation's progress.
+  startedAt?: number; progress?: BuildProgress;
 }
 // The paper's bibliography as the References panel reads it: the review
 // engine's report of every entry, with online checks and the entries the

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}`;
 }