papilot 0.0.0-stage → 0.1.0

package/src/server/workspace.ts

@@ -0,0 +1,529 @@
+import { randomUUID } from 'node:crypto';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import fs from 'node:fs';
+import path from 'node:path';
+import { EventEmitter } from 'node:events';
+import { Store } from './store.ts';
+import { Codex, RpcResponseError } from './codex.ts';
+import { AGENT_NAMES, AntigravityAgent, ClaudeAgent, type AgentRuntime } from './agents.ts';
+import { reviewClient, taskRoute, confirmedReviewResponse, type ReviewClient } from './review.ts';
+import type { Task, Run, TimelineItem, PendingRequest, RuntimeStatus, Snapshot, PendingReview, AgentModel, Usage, AgentId } from '../shared.ts';
+
+const execute = promisify(execFile);
+const delay = (ms: number) => new Promise(resolve => setTimeout(resolve, ms));
+const errorText = (e: unknown) => e instanceof Error ? e.message : String(e);
+// A Codex model/list entry with the reasoning efforts it supports.
+export const agentModel = (m: any): AgentModel => ({
+  id: m.model || m.id, name: m.displayName || m.model || m.id, isDefault: Boolean(m.isDefault),
+  efforts: (m.supportedReasoningEfforts || []).map((e: any) => e?.reasoningEffort).filter((e: unknown) => typeof e === 'string'),
+  defaultEffort: typeof m.defaultReasoningEffort === 'string' ? m.defaultReasoningEffort : null,
+});
+// An account/rateLimits/read response as the usage Papilot shows; null when
+// the account reports neither limits nor credits (for example, an API key).
+export function accountUsage(response: any): Usage | null {
+  const limits = response?.rateLimits;
+  if (!limits) return null;
+  const windows = [limits.primary, limits.secondary].filter((w: any) => typeof w?.usedPercent === 'number')
+    .map((w: any) => ({ usedPercent: Math.min(100, Math.max(0, w.usedPercent)), minutes: typeof w.windowDurationMins === 'number' ? w.windowDurationMins : null, resetsAt: typeof w.resetsAt === 'number' ? w.resetsAt * 1000 : null }));
+  const balance = Number(limits.credits?.balance);
+  const credits = limits.credits?.hasCredits || limits.credits?.unlimited ? { unlimited: Boolean(limits.credits.unlimited), balance: Number.isFinite(balance) ? balance : null } : null;
+  if (!windows.length && !credits) return null;
+  return { plan: typeof limits.planType === 'string' ? limits.planType : null, windows, credits, reached: Boolean(limits.rateLimitReachedType) || response.ordinaryUsageAllowed === false };
+}
+const BUSY = new Set(['running', 'waiting_input', 'building', 'uncertain', 'deleting']);
+
+const AGENTS: AgentId[] = ['codex', 'claude', 'antigravity'];
+const blankRuntime = (): RuntimeStatus => ({ connected: false, authenticated: false, account: null, error: null, models: [] });
+
+export class Workspace extends EventEmitter {
+  // Each task runs on one agent; `runtime` is Codex's status, kept for older clients.
+  runtimes: Record<AgentId, RuntimeStatus> = { codex: blankRuntime(), claude: blankRuntime(), antigravity: blankRuntime() };
+  runtime = this.runtimes.codex;
+  agents: Record<AgentId, AgentRuntime>;
+  requests = new Map<string, PendingRequest & { rpcId: string | number; agent: AgentId }>();
+  private active = new Map<string, Run>();
+  private loaded = new Set<string>();
+  private preparing = new Set<string>();
+  private reviewWrites = new Set<string>();
+  private commentWrites = new Map<string, number>();
+  private deletions = new Set<string>();
+  private publishing = new Set<string>();
+  private earlyCompletions = new Map<string, Map<string, any>>();
+  private earlyRequests = new Map<string, any[]>();
+  private queued = false;
+  private closing = false;
+  private liveItems = new Map<string, TimelineItem>();
+  private flushTimer: NodeJS.Timeout | null = null;
+  private connecting: Promise<void> | null = null;
+  private usageTimers = new Map<AgentId, NodeJS.Timeout>();
+  constructor(public store: Store, public codex: AgentRuntime = new Codex(), private concurrency = 2, private connectReview = reviewClient, others: Partial<Record<AgentId, AgentRuntime>> = {}) {
+    super();
+    this.agents = { codex, claude: others.claude || new ClaudeAgent(), antigravity: others.antigravity || new AntigravityAgent() };
+    store.on('change', () => this.emit('change'));
+    for (const id of AGENTS) {
+      const agent = this.agents[id];
+      agent.on('notification', message => void this.notification(message, id).catch(e => console.error(`${AGENT_NAMES[id]} event:`, errorText(e))));
+      agent.on('request', message => this.serverRequest(message, id));
+      agent.on('disconnected', e => this.disconnected(id, e));
+    }
+  }
+  private agentOf(task: Task): AgentId { return task.agent && AGENTS.includes(task.agent) ? task.agent : 'codex'; }
+  private disconnected(id: AgentId, e: unknown) {
+    this.runtimes[id].connected = false; this.runtimes[id].error = errorText(e);
+    for (const [key, request] of this.requests) if (request.agent === id) this.requests.delete(key);
+    for (const [taskId, run] of this.active) {
+      const task = this.store.task(taskId);
+      if (this.agentOf(task) !== id) continue;
+      if (task.threadId) this.loaded.delete(task.threadId);
+      this.earlyCompletions.delete(taskId); this.earlyRequests.delete(taskId); this.active.delete(taskId);
+      this.store.saveRun({ ...run, status: 'interrupted', finishedAt: Date.now() });
+      this.store.updateTask(taskId, { status: 'interrupted', turnId: null, error: `${AGENT_NAMES[id]} disconnected. You can resume the same task.` });
+    }
+    if (id === 'codex') this.loaded.clear();
+    this.emit('change');
+  }
+  snapshot(): Snapshot { return { version: '0.1.0', projects: this.store.projects(), tasks: this.store.tasks(), requests: [...this.requests.values()].map(({ rpcId: _, agent: __, ...r }) => r), runtime: this.runtime, runtimes: this.runtimes }; }
+  async connect() {
+    if (this.connecting) return this.connecting;
+    this.connecting = Promise.all(AGENTS.map(id => this.connectAgent(id))).then(() => { this.emit('change'); this.schedule(); }).finally(() => { this.connecting = null; });
+    return this.connecting;
+  }
+  private async connectAgent(id: AgentId) {
+    const agent = this.agents[id], runtime = this.runtimes[id], name = AGENT_NAMES[id];
+    try {
+      await agent.start();
+      const account = await agent.request('account/read', { refreshToken: false });
+      runtime.connected = true;
+      runtime.authenticated = Boolean(account.account) || account.requiresOpenaiAuth === false;
+      runtime.account = account.account?.email || account.account?.type || (runtime.authenticated ? `Local ${name} configuration` : null);
+      runtime.error = runtime.authenticated ? null : account.reason || `Sign in to ${name} on this host, then select Reconnect.`;
+      try {
+        const models = await agent.request('model/list', {}, 20000);
+        runtime.models = (models.data || []).map(agentModel);
+      } catch { /* Tasks can still use the account's configured default model. */ }
+      await this.readUsage(id);
+    } catch (e) { runtime.error = errorText(e); runtime.connected = false; }
+  }
+  async addProject(input: string, name?: string) {
+    const expanded = input.startsWith('~/') ? path.join(process.env.HOME!, input.slice(2)) : input;
+    const root = fs.realpathSync(expanded);
+    const git = await execute('git', ['-C', root, 'rev-parse', '--show-toplevel']);
+    if (fs.realpathSync(git.stdout.trim()) !== root) throw new Error('Select the root directory of the Git repository.');
+    await execute('git', ['-C', root, 'rev-parse', '--verify', 'HEAD']);
+    const existing = this.store.projectByPath(root); if (existing) return existing;
+    const client = await this.connectReview(root);
+    await client.get('/api/tasks');
+    const project = { id: randomUUID(), name: name?.trim() || path.basename(root), path: root, createdAt: Date.now() };
+    this.store.saveProject(project); return project;
+  }
+  renameProject(projectId: string, name: string) {
+    const project = { ...this.store.project(projectId), name };
+    this.store.saveProject(project); return project;
+  }
+  async createTask(input: { projectId: string; title: string; instructions: string; agent?: AgentId; model?: string; effort?: string; id: string }) {
+    if (!/^[\w-]{16,64}$/.test(input.id)) throw new Error('Invalid task ID.');
+    if (this.store.taskDeleted(input.id)) throw new Error('This task was deleted. Create a new task instead.');
+    const existing = this.store.tasks().find(t => t.id === input.id); if (existing) return existing;
+    if (this.preparing.has(input.id)) throw new Error('This task is being created. Refresh in a moment.');
+    this.preparing.add(input.id);
+    try {
+      const project = this.store.project(input.projectId), client = await this.connectReview(project.path);
+      const name = 'p-' + input.id.toLowerCase().replace(/[^a-z0-9-]/g, '').slice(0, 48);
+      const info = await client.post('/api/tasks', { name, title: input.title });
+      const task: Task = { id: input.id, projectId: project.id, name, title: input.title, instructions: input.instructions,
+        worktree: info.worktree, threadId: null, turnId: null, agent: input.agent || 'codex', model: input.model || null, effort: input.effort || null, status: 'idle',
+        createdAt: Date.now(), updatedAt: Date.now(), feedbackCursor: 0, error: null, review: null };
+      this.store.saveTask(task);
+      await this.enqueue(task.id, input.instructions, 'initial-' + task.id, false);
+      return this.store.task(task.id);
+    } finally { this.preparing.delete(input.id); }
+  }
+  async enqueue(taskId: string, text: string, requestKey: string, includeFeedback = true) {
+    const task = this.store.task(taskId);
+    if (task.status === 'deleting') throw new Error('This task is being deleted.');
+    const existing = this.store.runByKey(requestKey);
+    if (existing) { if (existing.taskId !== taskId) throw new Error('This request ID is already in use by another task.'); return existing; }
+    if (task.status === 'uncertain') throw new Error('Check the task status before sending more instructions.');
+    const pauseVersion = task.pauseVersion || 0;
+    if (this.store.runs().some(r => r.taskId === taskId && r.status === 'queued')) throw new Error('This task already has queued instructions. Wait or pause it first.');
+    let prompt = text.trim(), cursor = task.feedbackCursor;
+    if (includeFeedback) {
+      const client = await this.connectReview(this.store.project(task.projectId).path);
+      const feedback = await client.get(`${taskRoute(task.name)}/feedback?after=${task.feedbackCursor}`);
+      cursor = feedback.cursor;
+      if (feedback.feedback?.length || feedback.build_error) prompt += '\n\nPapilot review feedback (bound to the specified review round and source changes):\n' + JSON.stringify(feedback, null, 2);
+      if (task.error) prompt += '\n\nLatest task/review error:\n' + task.error + '\nThe latest accepted manuscript is at ' + this.store.project(task.projectId).path + '. You may read it to understand accepted changes, but must only edit your isolated task worktree. Prepare a revised proposal for another review; never write to or accept changes in the manuscript checkout.';
+    }
+    const run: Run = { id: randomUUID(), taskId, requestKey, prompt, feedbackCursor: cursor, status: 'queued', createdAt: Date.now(), finishedAt: null };
+    const saved = this.store.transaction(() => {
+      // Feedback loading yields to other requests. Recheck identity, queue, and
+      // task status together before committing; none of the earlier reads own a lock.
+      const duplicate = this.store.runByKey(requestKey);
+      if (duplicate) {
+        if (duplicate.taskId !== taskId) throw new Error('This request ID is already in use by another task.');
+        return duplicate;
+      }
+      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 current = this.store.task(taskId);
+      if (current.status === 'deleting') throw new Error('This task is being deleted. Your instructions were not queued.');
+      if ((current.pauseVersion || 0) !== pauseVersion) throw new Error('The task was paused before these instructions were queued. Your draft has been kept.');
+      if (current.status === 'uncertain') throw new Error('Check the task status before sending more instructions.');
+      this.store.saveRun(run);
+      if (!BUSY.has(current.status)) this.store.updateTask(taskId, { status: 'queued', error: null });
+      this.store.saveItem({ id: run.id, taskId, type: 'user', text: text.trim(), createdAt: run.createdAt });
+      return run;
+    });
+    this.schedule();
+    if (includeFeedback) void this.refresh(taskId);
+    return saved;
+  }
+  private schedule() {
+    if (this.queued || this.closing) return;
+    this.queued = true;
+    setImmediate(() => { this.queued = false; void this.drain(); });
+  }
+  private async drain() {
+    if (this.closing) return;
+    for (const run of this.store.runs().filter(r => r.status === 'queued')) {
+      if (this.active.size >= this.concurrency) break;
+      const agent = this.agentOf(this.store.task(run.taskId));
+      if (!this.agents[agent].ready || !this.runtimes[agent].authenticated) continue;
+      if (this.active.has(run.taskId) || this.reviewWrites.has(run.taskId) || this.publishing.has(run.taskId) || BUSY.has(this.store.task(run.taskId).status)) continue;
+      this.active.set(run.taskId, run);
+      void this.startRun(run).catch(e => this.failRun(run, e));
+    }
+  }
+  private instructions(task: Task) {
+    return `You are ${this.agentOf(task) === 'codex' ? 'the official Codex agent' : AGENT_NAMES[this.agentOf(task)]} running inside Papilot, a paper editing and review workspace.
+Your task is already created. Your editable working directory is ${task.worktree}.
+Original task: ${task.instructions}
+Only edit this isolated task worktree. Never edit the manuscript checkout, other task worktrees, or Papilot's own source/state. Never commit, push, stash, or accept/reject/undo review decisions.
+Papilot owns the LaTeX review lifecycle: it compiles and publishes automatically AFTER your turn finishes, and delivers review feedback in a new turn. Do not create another review task, invoke publish, or wait on feedback --wait. This application workflow replaces the standalone latex-review skill's publish-and-wait loop. End your turn after completing the requested edits, with a concise summary.
+Preserve meaning and mathematical correctness. Read relevant project instructions. Treat reviewer comments as instructions tied to their round, file and changes. Rejected edits must not be reintroduced unless explicitly requested. If there is a conflict with accepted text, explain it and propose a revision for a new review round; never overwrite the accepted manuscript.
+${this.agentOf(task) === 'antigravity' ? 'Shell commands are not available to you here and any attempt is refused, which ends your turn: read, search and edit files in the task worktree with your file tools only.' : 'You may run tools in the task worktree to inspect and validate your changes.'} If a decision requires the user, ask through the available user-input tool or explain it in your final response. Use English for your progress updates, questions, and final summaries unless the user explicitly requests another language. Preserve the manuscript language unless asked to translate it.`;
+  }
+  private async startRun(run: Run) {
+    let task = this.store.task(run.taskId);
+    const agent = this.agents[this.agentOf(task)], name = AGENT_NAMES[this.agentOf(task)];
+    this.earlyCompletions.delete(task.id); this.earlyRequests.delete(task.id);
+    this.store.saveRun({ ...run, status: 'running' });
+    this.store.updateTask(task.id, { status: 'running', turnId: null, error: null });
+    if (!task.threadId || !this.loaded.has(task.threadId)) {
+      const options = { cwd: task.worktree, approvalPolicy: 'on-request', sandbox: 'workspace-write', developerInstructions: this.instructions(task), ...(task.model ? { model: task.model } : {}) };
+      const result = task.threadId
+        ? await agent.request('thread/resume', { ...options, threadId: task.threadId, excludeTurns: true })
+        : await agent.request('thread/start', options);
+      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 });
+      this.loaded.add(result.thread.id);
+    }
+    this.store.updateTask(task.id, { pendingRunId: run.id });
+    let result: any;
+    try { result = await agent.request('turn/start', { threadId: task.threadId, input: [{ type: 'text', text: run.prompt }], cwd: task.worktree, clientUserMessageId: run.id, ...(task.effort ? { effort: task.effort } : {}) }); }
+    catch (error) {
+      if (this.active.get(task.id)?.id !== run.id) return;
+      if (error instanceof RpcResponseError) throw error;
+      this.store.saveRun({ ...run, status: 'uncertain' });
+      this.store.updateTask(task.id, { status: 'uncertain', error: `${name} did not confirm whether this turn started. Select Check status before continuing. ` + errorText(error) });
+      return;
+    }
+    if (this.active.get(task.id)?.id !== run.id) return;
+    // A cancelled queued message has not delivered its comments. Advance only
+    // after Codex acknowledges starting the turn that contains that feedback.
+    if (run.feedbackCursor !== undefined) this.store.updateTask(task.id, { feedbackCursor: Math.max(this.store.task(task.id).feedbackCursor, run.feedbackCursor) });
+    this.store.updateTask(task.id, { turnId: result.turn.id, pendingRunId: null });
+    const requests = this.earlyRequests.get(task.id) || [];
+    const completion = this.earlyCompletions.get(task.id)?.get(result.turn.id);
+    this.earlyRequests.delete(task.id); this.earlyCompletions.delete(task.id);
+    for (const request of requests) this.serverRequest(request, this.agentOf(task));
+    if (completion) await this.notification(completion, this.agentOf(task));
+  }
+  private failRun(run: Run, error: unknown) {
+    if (this.active.get(run.taskId)?.id !== run.id) return;
+    this.active.delete(run.taskId);
+    this.earlyCompletions.delete(run.taskId); this.earlyRequests.delete(run.taskId);
+    this.store.saveRun({ ...run, status: 'failed', finishedAt: Date.now() });
+    this.store.updateTask(run.taskId, { status: 'failed', turnId: null, pendingRunId: null, error: errorText(error) });
+    this.schedule();
+  }
+  private flush() {
+    if (this.flushTimer) clearTimeout(this.flushTimer); this.flushTimer = null;
+    for (const item of this.liveItems.values()) this.store.saveItem(item);
+    this.liveItems.clear();
+  }
+  private appendDelta(task: Task, params: any, type: string) {
+    const id = `${task.id}:${params.turnId}:${params.itemId}`;
+    const item = this.liveItems.get(id) || this.store.items(task.id).find(item => item.id === id) || { id, taskId: task.id, type, text: '', createdAt: Date.now() };
+    if (type === 'command') item.detail = ((item.detail || '') + (params.delta || '')).slice(-40000);
+    else item.text += params.delta || '';
+    this.liveItems.set(id, item);
+    this.flushTimer ??= setTimeout(() => this.flush(), 350);
+  }
+  // Usage is shown on the new-task page. Agents report changes after turns;
+  // read the full snapshot again rather than merging their sparse updates.
+  async readUsage(id: AgentId = 'codex') {
+    try { this.runtimes[id].usage = accountUsage(await this.agents[id].request('account/rateLimits/read', { excludeResetCreditDetails: true }, 20000)); }
+    catch { this.runtimes[id].usage = null; }
+    this.emit('change');
+  }
+  private async notification(message: any, agent: AgentId = 'codex') {
+    const p = message.params || {}, method = message.method;
+    if (method === 'account/rateLimits/updated') {
+      clearTimeout(this.usageTimers.get(agent));
+      this.usageTimers.set(agent, setTimeout(() => { this.usageTimers.delete(agent); void this.readUsage(agent); }, 1500));
+      return;
+    }
+    const task = this.store.tasks().find(t => t.threadId === p.threadId);
+    if (!task || task.status === 'deleting') return;
+    const eventTurn = p.turnId || p.turn?.id;
+    if (eventTurn && task.turnId && eventTurn !== task.turnId) return;
+    if (method === 'item/agentMessage/delta') this.appendDelta(task, p, 'assistant');
+    else if (method === 'item/commandExecution/outputDelta') this.appendDelta(task, p, 'command');
+    else if ((method === 'item/started' || method === 'item/completed') && p.item) {
+      const item = p.item, id = `${task.id}:${p.turnId}:${item.id}`;
+      if (['userMessage', 'reasoning'].includes(item.type)) return;
+      this.flush();
+      const previous = this.store.items(task.id).find(i => i.id === id);
+      const entry: TimelineItem = { id, taskId: task.id, createdAt: previous?.createdAt || Date.now(), type: item.type, text: item.text || item.command || '', status: item.status || (method === 'item/completed' ? 'completed' : 'inProgress') };
+      if (item.type === 'agentMessage') entry.type = 'assistant';
+      if (item.type === 'commandExecution') { entry.type = 'command'; entry.detail = String(item.aggregatedOutput || previous?.detail || '').slice(-40000); }
+      if (item.type === 'fileChange') { entry.type = 'files'; entry.text = (item.changes || []).map((change: any) => change.path).join('\n'); }
+      if (item.type === 'mcpToolCall') { entry.type = 'tool'; entry.text = `${item.server} / ${item.tool}`; }
+      if (item.type === 'toolCall') entry.type = 'tool';
+      if (entry.text || entry.detail) this.store.saveItem(entry);
+    } else if (method === 'serverRequest/resolved') {
+      const buffered = this.earlyRequests.get(task.id);
+      if (buffered) this.earlyRequests.set(task.id, buffered.filter(request => String(request.id) !== String(p.requestId)));
+      let removed = false;
+      for (const [key, request] of this.requests) if (request.taskId === task.id && String(request.rpcId) === String(p.requestId)) { this.requests.delete(key); removed = true; }
+      if (removed && task.status === 'waiting_input' && ![...this.requests.values()].some(r => r.taskId === task.id) && this.active.has(task.id)) this.store.updateTask(task.id, { status: 'running' });
+      this.emit('change');
+    } else if (method === 'turn/completed') {
+      if (!eventTurn || !this.active.has(task.id)) return;
+      if (!task.turnId) {
+        // Very short turns can finish before the turn/start response arrives.
+        const pending = this.earlyCompletions.get(task.id) || new Map<string, any>();
+        if (pending.size < 32) pending.set(eventTurn, message);
+        this.earlyCompletions.set(task.id, pending);
+        return;
+      }
+      this.flush();
+      const run = this.active.get(task.id); if (!run) return;
+      this.active.delete(task.id);
+      for (const [key, r] of this.requests) if (r.taskId === task.id) this.requests.delete(key);
+      const status = p.turn.status === 'completed' ? 'completed' : p.turn.status === 'interrupted' ? 'interrupted' : 'failed';
+      this.store.saveRun({ ...run, status, finishedAt: Date.now() });
+      this.store.updateTask(task.id, { turnId: null, pendingRunId: null, status: status === 'completed' ? 'building' : status, error: p.turn.error?.message || null });
+      this.schedule();
+      if (status === 'completed') await this.publish(task.id, true);
+    } else if (method === 'error' && !p.willRetry) {
+      if (!this.active.has(task.id) || (eventTurn && !task.turnId)) return;
+      this.store.updateTask(task.id, { error: p.error?.message || `${AGENT_NAMES[agent]} encountered an error.` });
+    }
+  }
+  private serverRequest(message: any, agent: AgentId = 'codex') {
+    const task = this.store.tasks().find(t => t.threadId === message.params?.threadId), runtime = this.agents[agent];
+    const allowed = ['item/commandExecution/requestApproval', 'item/fileChange/requestApproval', 'item/permissions/requestApproval', 'item/tool/requestUserInput'];
+    if (!task || this.agentOf(task) !== agent || !this.active.has(task.id) || !allowed.includes(message.method)) { runtime.reject(message.id, 'This request is not supported or its turn is no longer active.'); return; }
+    if (message.params?.turnId && task.turnId && message.params.turnId !== task.turnId) { runtime.reject(message.id, 'This turn is no longer active.'); return; }
+    if (!task.turnId && message.params?.turnId) {
+      const pending = this.earlyRequests.get(task.id) || [];
+      if (pending.length < 32) { pending.push(message); this.earlyRequests.set(task.id, pending); }
+      else runtime.reject(message.id, 'Too many pending requests.');
+      return;
+    }
+    const id = randomUUID();
+    this.requests.set(id, { id, taskId: task.id, rpcId: message.id, agent, method: message.method, params: message.params, createdAt: Date.now() });
+    this.store.updateTask(task.id, { status: 'waiting_input' });
+  }
+  answer(id: string, input: { decision?: string; answers?: Record<string, string> }) {
+    const request = this.requests.get(id); if (!request) throw new Error('This request has ended or the connection has restarted.');
+    if (this.store.task(request.taskId).status === 'deleting') throw new Error('This task is being deleted.');
+    let response: unknown;
+    if (request.method === 'item/tool/requestUserInput') {
+      const questions = request.params.questions || [];
+      response = { answers: Object.fromEntries(questions.map((q: any) => {
+        const answer = input.answers?.[q.id]?.trim(); if (!answer) throw new Error('Answer every question before submitting.');
+        return [q.id, { answers: [answer] }];
+      })) };
+    } else {
+      if (!['accept', 'decline', 'cancel'].includes(input.decision || '')) throw new Error('Invalid approval decision.');
+      response = request.method === 'item/permissions/requestApproval'
+        ? { permissions: input.decision === 'accept' ? request.params.permissions : {}, scope: 'turn' }
+        : { decision: input.decision };
+    }
+    this.agents[request.agent].respond(request.rpcId, response);
+    this.requests.delete(id);
+    if (![...this.requests.values()].some(r => r.taskId === request.taskId)) this.store.updateTask(request.taskId, { status: 'running' });
+  }
+  async interrupt(taskId: string) {
+    const task = this.store.task(taskId);
+    if (task.status === 'deleting') throw new Error('This task is being deleted. Retry deletion to finish cleanup.');
+    if (task.status === 'building') throw new Error('The PDF is building. Wait for this build to finish.');
+    this.store.updateTask(taskId, { pauseVersion: (task.pauseVersion || 0) + 1 });
+    for (const run of this.store.runs().filter(r => r.taskId === taskId && r.status === 'queued')) this.store.saveRun({ ...run, status: 'interrupted', finishedAt: Date.now() });
+    void this.refresh(taskId);
+    if (this.active.has(taskId)) {
+      if (!task.turnId) throw new Error(`${AGENT_NAMES[this.agentOf(task)]} is starting. Try pausing again in a moment.`);
+      await this.agents[this.agentOf(task)].request('turn/interrupt', { threadId: task.threadId, turnId: task.turnId });
+    } else if (task.status === 'uncertain') throw new Error('Check the task status before pausing this turn.');
+    else this.store.updateTask(taskId, { status: 'interrupted' });
+  }
+  async reconcile(taskId: string) {
+    const task = this.store.task(taskId);
+    if (task.status === 'deleting') throw new Error('Retry deletion to confirm this task was removed.');
+    if (task.status !== 'uncertain') return task;
+    if (task.pendingReview) return this.reconcileReview(task);
+    const run = this.active.get(taskId) || this.store.runs().find(r => r.id === task.pendingRunId && r.taskId === taskId);
+    const name = AGENT_NAMES[this.agentOf(task)];
+    if (!run || !task.threadId) throw new Error(`The pending turn could not be identified. Reconnect ${name} and check again.`);
+    const { thread } = await this.agents[this.agentOf(task)].request('thread/read', { threadId: task.threadId, includeTurns: true }, 20000);
+    if (this.store.task(taskId).status !== 'uncertain') return this.store.task(taskId);
+    const turn = thread.turns?.find((turn: any) => turn.id === task.turnId || turn.items?.some((item: any) => item.type === 'userMessage' && item.clientId === run.id));
+    if (!turn) throw new Error(`${name} has not confirmed this turn yet. Check again in a moment.`);
+    const completion = this.earlyCompletions.get(taskId)?.get(turn.id);
+    this.earlyCompletions.delete(taskId);
+    this.active.set(taskId, run);
+    this.store.updateTask(taskId, { turnId: turn.id, pendingRunId: null, error: null, feedbackCursor: Math.max(task.feedbackCursor, run.feedbackCursor || 0) });
+    if (completion) {
+      await this.notification(completion, this.agentOf(task));
+    } else if (turn.status === 'inProgress' && thread.status?.type !== 'notLoaded') {
+      this.store.saveRun({ ...run, status: 'running' });
+      this.store.updateTask(taskId, { status: 'running' });
+      const requests = this.earlyRequests.get(taskId) || [];
+      this.earlyRequests.delete(taskId);
+      for (const request of requests) this.serverRequest(request, this.agentOf(task));
+    } else {
+      await this.notification({ method: 'turn/completed', params: { threadId: task.threadId, turn: turn.status === 'inProgress' ? { ...turn, status: 'interrupted' } : turn } }, this.agentOf(task));
+    }
+    return this.store.task(taskId);
+  }
+  private async reconcileReview(task: Task) {
+    if (this.reviewWrites.has(task.id)) throw new Error('The review action is still being checked. Wait for it to finish.');
+    this.reviewWrites.add(task.id);
+    try {
+      const pending = task.pendingReview!;
+      const client = await this.connectReview(this.store.project(task.projectId).path);
+      // Replay exactly the original action identity. Decisions are idempotent;
+      // undo is bound to its original action ID and cannot undo a different one.
+      const response = await fetch(client.url + pending.route, { method: 'POST', headers: { 'Content-Type': 'application/json', 'X-Review-Token': client.token }, body: JSON.stringify(pending.body), signal: AbortSignal.timeout(120000), redirect: 'error' });
+      const value = await response.json() as { error?: string };
+      if (!confirmedReviewResponse(response.status, value, task.name)) throw new Error('The review engine could not confirm this action. Check again when it is available.');
+      await this.refresh(task.id);
+      this.store.updateTask(task.id, { pendingReview: null, status: this.store.runs().some(r => r.taskId === task.id && r.status === 'queued') ? 'queued' : pending.previousStatus, error: response.ok ? null : value.error || 'Check the review result before continuing.' });
+      return this.store.task(task.id);
+    } finally { this.reviewWrites.delete(task.id); this.schedule(); }
+  }
+  async reviewWrite<T>(taskId: string, writesFiles: boolean, operation: () => Promise<T>, pending?: Omit<PendingReview, 'previousStatus'>): Promise<T> {
+    const task = this.store.task(taskId);
+    if (task.status === 'deleting') throw new Error('This task is being deleted.');
+    if (!writesFiles) {
+      this.commentWrites.set(taskId, (this.commentWrites.get(taskId) || 0) + 1);
+      try { return await operation(); }
+      finally {
+        const remaining = (this.commentWrites.get(taskId) || 1) - 1;
+        if (remaining) this.commentWrites.set(taskId, remaining); else this.commentWrites.delete(taskId);
+      }
+    }
+    if (this.active.has(taskId) || this.publishing.has(taskId) || BUSY.has(task.status) || task.status === 'queued') throw new Error('Pause the task before accepting, rejecting, or undoing changes. Wait for any PDF build to finish.');
+    if (this.reviewWrites.has(taskId)) throw new Error('A review action is already in progress. Wait for it to finish.');
+    this.reviewWrites.add(taskId);
+    if (pending) this.store.updateTask(taskId, { pendingReview: { ...pending, previousStatus: task.status } });
+    try {
+      const result = await operation();
+      if (pending) this.store.updateTask(taskId, { pendingReview: null });
+      return result;
+    } catch (error) {
+      if (pending) this.store.updateTask(taskId, { status: 'uncertain', error: 'The review action could not be confirmed. Select Check status before continuing. ' + errorText(error) });
+      throw error;
+    }
+    finally { this.reviewWrites.delete(taskId); this.schedule(); }
+  }
+  publish(taskId: string, automatic = false): Promise<void> {
+    const task = this.store.task(taskId);
+    if (task.status === 'deleting') throw new Error('This task is being deleted.');
+    if (this.active.has(taskId)) throw new Error('Pause Codex before building a review.');
+    if (this.reviewWrites.has(taskId)) throw new Error('Wait for the current review action before building a review.');
+    if (this.publishing.has(taskId) || (!automatic && (BUSY.has(task.status) || task.status === 'queued'))) throw new Error('This task is busy. Wait for it to finish or pause it first.');
+    this.publishing.add(taskId);
+    this.store.updateTask(taskId, { status: 'building', error: null });
+    return this.buildReview(task).finally(() => { this.publishing.delete(taskId); this.schedule(); });
+  }
+  private async buildReview(task: Task) {
+    const taskId = task.id;
+    try {
+      const client = await this.connectReview(this.store.project(task.projectId).path);
+      const job = await client.post(`${taskRoute(task.name)}/publish`, {});
+      for (;;) {
+        if (this.closing) return;
+        const current = await client.get(`/api/jobs/${job.job}`);
+        const summary = await client.get(taskRoute(task.name));
+        this.store.updateTask(taskId, { review: { state: summary.state, round: summary.round, counts: summary.counts, job: current, unsent: this.store.task(taskId).review?.unsent } });
+        if (current.status === 'done' || current.status === 'completed' || current.status === 'succeeded') break;
+        if (current.status === 'failed') throw new Error([current.error, ...(current.details || [])].filter(Boolean).join('\n') || 'PDF build failed.');
+        await delay(1500);
+      }
+      this.store.updateTask(taskId, { status: this.store.runs().some(r => r.taskId === taskId && r.status === 'queued') ? 'queued' : 'reviewing', error: null });
+      await this.refresh(taskId);
+    } catch (e) { this.store.updateTask(taskId, { status: 'failed', error: errorText(e) }); }
+  }
+  async refresh(taskId: string) {
+    try {
+      const task = this.store.task(taskId);
+      if (task.status === 'deleting') return;
+      const client = await this.connectReview(this.store.project(task.projectId).path);
+      const summary = await client.get(taskRoute(task.name));
+      const unsent = await this.unsentComments(client, this.store.task(taskId));
+      const current = this.store.task(taskId);
+      if (current.status !== 'deleting') this.store.updateTask(taskId, { review: { state: summary.state, round: summary.round, counts: summary.counts, job: current.review?.job, unsent } });
+    } catch { /* The task remains visible even if its project is temporarily unavailable. */ }
+  }
+  // Review comments Codex has not received yet. A queued or in-flight message
+  // already carries the feedback up to its own cursor.
+  private async unsentComments(client: ReviewClient, task: Task) {
+    const after = Math.max(task.feedbackCursor, ...this.store.runs().filter(r => r.taskId === task.id && ['queued', 'running', 'uncertain'].includes(r.status)).map(r => r.feedbackCursor || 0));
+    const feedback = await client.get<{ feedback?: { kind?: string }[] }>(`${taskRoute(task.name)}/feedback?after=${after}`);
+    return (feedback.feedback || []).filter(item => item.kind === 'comment').length;
+  }
+  renameTask(taskId: string, title: string) {
+    if (this.store.task(taskId).status === 'deleting') throw new Error('This task is being deleted.');
+    return this.store.updateTask(taskId, { title });
+  }
+  async deleteTask(taskId: string): Promise<{ ok: true }> {
+    if (this.preparing.has(taskId)) throw new Error('Wait for task creation to finish before deleting it.');
+    if (this.deletions.has(taskId)) throw new Error('Deletion is already in progress. Wait for it to finish.');
+    const task = this.store.tasks().find(t => t.id === taskId);
+    if (!task) return { ok: true };
+    if (!['idle', 'interrupted', 'reviewing', 'failed', 'deleting'].includes(task.status)
+      || this.active.has(taskId) || this.publishing.has(taskId) || this.reviewWrites.has(taskId) || this.commentWrites.has(taskId)
+      || task.pendingReview || this.store.runs().some(run => run.taskId === taskId && run.status === 'queued')) {
+      throw new Error('Pause the task and wait for its current work or review action to finish before deleting it. Resolve any uncertain action first.');
+    }
+    // Persist the reservation before connecting to the engine. A restart or
+    // lost response must not let queued instructions reuse a removed worktree.
+    this.deletions.add(taskId);
+    this.store.updateTask(taskId, { status: 'deleting', pauseVersion: (task.pauseVersion || 0) + 1, error: null });
+    try {
+      const client = await this.connectReview(this.store.project(task.projectId).path);
+      const state = await client.get(`${taskRoute(task.name)}/state`);
+      if (!confirmedReviewResponse(200, state, task.name)) throw new Error('The review engine could not confirm this task’s cleanup status.');
+      if (!state.closed) {
+        const result = await client.post(`${taskRoute(task.name)}/finish`, { force: true });
+        if (result?.task !== task.name || result.finished !== true) throw new Error('The review engine did not confirm task deletion.');
+      }
+      // All file cleanup belongs to the review engine. Drop only Papilot data
+      // after an identified closed state or explicit finish acknowledgement.
+      for (const [id, item] of this.liveItems) if (item.taskId === taskId) this.liveItems.delete(id);
+      for (const [id, request] of this.requests) if (request.taskId === taskId) this.requests.delete(id);
+      this.earlyCompletions.delete(taskId); this.earlyRequests.delete(taskId);
+      if (task.threadId) this.loaded.delete(task.threadId);
+      this.store.deleteTask(taskId);
+      return { ok: true };
+    } catch (error) {
+      this.store.updateTask(taskId, { status: 'deleting', error: 'Deletion has not been confirmed. Retry deletion to finish cleanup. ' + errorText(error) });
+      throw error;
+    } finally { this.deletions.delete(taskId); this.schedule(); }
+  }
+  close() { this.closing = true; for (const timer of this.usageTimers.values()) clearTimeout(timer); this.flush(); for (const id of AGENTS) this.agents[id].close(); }
+}

package/src/shared.ts

@@ -0,0 +1,28 @@
+export type TaskStatus = 'idle' | 'queued' | 'running' | 'waiting_input' | 'building' | 'reviewing' | 'interrupted' | 'failed' | 'uncertain' | 'deleting';
+export interface Project { id: string; name: string; path: string; createdAt: number }
+export interface ReviewSummary { state: string; round: number | null; counts: Record<string, number>; unsent?: number; 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 Task {
+  id: string; projectId: string; name: string; title: string; instructions: string;
+  worktree: string; threadId: string | null; turnId: string | null; agent?: AgentId; model: string | null; effort?: string | null;
+  status: TaskStatus; createdAt: number; updatedAt: number; feedbackCursor: number;
+  error: string | null; review: ReviewSummary | null;
+  pauseVersion?: number; pendingRunId?: string | null;
+  pendingReview?: PendingReview | null;
+}
+export interface Run { id: string; taskId: string; requestKey: string; prompt: string; feedbackCursor?: number; status: 'queued' | 'running' | 'completed' | 'failed' | 'interrupted' | 'uncertain'; createdAt: number; finishedAt: number | null }
+export interface TimelineItem { id: string; taskId: string; type: string; text: string; detail?: string; status?: string; createdAt: number }
+export interface PendingRequest { id: string; taskId: string; method: string; params: Record<string, any>; createdAt: number }
+export type AgentId = 'codex' | 'claude' | 'antigravity';
+export interface AgentModel { id: string; name: string; isDefault: boolean; efforts: string[]; defaultEffort: string | null }
+// The account's included usage: rolling windows (minutes long, reset time in ms) and credits.
+export interface UsageWindow { usedPercent: number; minutes: number | null; resetsAt: number | null }
+export interface Usage { plan: string | null; windows: UsageWindow[]; credits: { unlimited: boolean; balance: number | null } | null; reached: boolean }
+export interface RuntimeStatus { connected: boolean; authenticated: boolean; account: string | null; error: string | null; models: AgentModel[]; usage?: Usage | null }
+export interface Snapshot { projects: Project[]; tasks: Task[]; requests: PendingRequest[]; runtime: RuntimeStatus; runtimes?: Partial<Record<AgentId, RuntimeStatus>>; version: string }
+export interface GitFile { path: string; status: string; staged: boolean; lines?: [number, number]; from?: string }
+export interface GitStatus { branch: string | null; upstream: string | null; ahead: number; behind: number; files: GitFile[]; head: { hash: string; subject: string; date: number } | null; remote?: boolean }
+export interface GitDiff { path: string; diff: string; truncated: boolean }
+export interface ManuscriptBuild { status: 'building' | 'ready' | 'failed'; key?: string; pages?: [number, number][]; builtAt?: number; error?: string; current: boolean }
+export interface Annotation { id: string; projectId: string; key: string; page: number; rect: [number, number, number, number]; rects?: [number, number, number, number][]; comment: string; quote: string; source: { file: string; lines: [number, number]; excerpt?: string } | null; createdAt: number; taskId?: string }
+export interface Manuscript { git: GitStatus; build: ManuscriptBuild; annotations: Annotation[] }

package/vendor/latex-review/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Cui Chen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/vendor/latex-review/dist/web/assets/index-DyzYnIGk.css

@@ -0,0 +1 @@
+@font-face{font-family:Review Serif;src:url(/assets/TeXGyrePagellaX-Regular-DQJjZE_L.otf)format("opentype");font-weight:400;font-display:swap}@font-face{font-family:Review Serif;src:url(/assets/TeXGyrePagellaX-Bold-CEtYdOXj.otf)format("opentype");font-weight:700;font-display:swap}:root{--lightningcss-light:initial;--lightningcss-dark: ;color-scheme:light;--serif:"Review Serif", Palatino, "Palatino Linotype", "Songti SC", Georgia, serif;--sans:-apple-system, BlinkMacSystemFont, "Segoe UI", "PingFang SC", "Noto Sans", sans-serif;--frame:#fff;--bar:#fff;--ink:#171717;--muted:#666;--line:#e5e5e5;--paper:#fff;--accent:#356aa0;--accept:#1d7448;--reject:#b0313b;--comment:#356aa0;--before:#fbeeee;--before-edge:#d17c82;--after:#eef8f1;--after-edge:#68ab82;--head:#fafafa;--shadow:0 1px 2px #0000000f, 0 4px 18px #0000000d;--paper-top:24px;font:14px/1.5 var(--sans);color:var(--ink);background:var(--frame)}*{box-sizing:border-box}body{background:var(--frame);text-rendering:optimizelegibility;grid-template-rows:auto 1fr;height:100dvh;margin:0;display:grid;overflow:hidden}button,input,select,textarea{font:inherit;color:inherit}button{cursor:pointer}button:disabled{cursor:default;opacity:.38}button:focus-visible,a:focus-visible,input:focus-visible,select:focus-visible{outline:2px solid var(--accent);outline-offset:3px}[hidden]{display:none!important}.muted{color:var(--muted)}a{color:var(--accent);text-underline-offset:.18em}h1,h2,.brand{font-family:var(--serif);font-weight:400;line-height:1.3}.brand{letter-spacing:.02em;color:var(--ink);font-size:20px;font-variant-caps:small-caps;text-decoration:none}kbd{border:1px solid var(--line);color:var(--muted);background:var(--frame);vertical-align:1px;border-radius:4px;margin-left:6px;padding:2px 4px;font:600 10px/1 ui-monospace,SFMono-Regular,Menlo,monospace}.bar{background:var(--bar);border-bottom:1px solid var(--line);z-index:3;align-items:center;gap:18px;min-height:62px;padding:10px 24px;display:flex}.identity{flex:1;align-items:baseline;gap:10px;min-width:0;display:flex}.identity h1{letter-spacing:.02em;white-space:nowrap;text-overflow:ellipsis;margin:0;font-size:20px;font-variant-caps:small-caps;overflow:hidden}.identity span{white-space:nowrap;font-size:13px}.meter{color:var(--muted);white-space:nowrap;font-variant-numeric:tabular-nums;align-items:center;gap:10px;font-size:12px;display:flex}.track{background:var(--line);width:120px;height:2px;overflow:hidden}.track i{background:#999;width:0;height:100%;transition:width .3s;display:block}.bar-end{align-items:center;gap:8px;display:flex}.status:empty{display:none}.status{background:var(--head);color:var(--muted);white-space:nowrap;border-radius:999px;padding:3px 9px;font-size:12px}.status[data-state=build_failed],.status[data-state=offline]{color:var(--reject)}.ghost{color:var(--muted);background:0 0;border:1px solid #0000;border-radius:7px;padding:5px 9px;font-size:13px}.ghost:hover{border-color:var(--line);color:var(--ink);text-underline-offset:.18em;text-decoration:underline}.accept-all,.reject-all{color:var(--ink);border-color:var(--line);border-radius:999px;box-shadow:0 1px 3px #0000000d}.overview-link{color:var(--accent);flex:none;text-decoration:none}.ghost.round{border-color:var(--line);border-radius:50%;width:30px;height:30px;padding:0}#paper{padding:var(--paper-top) 24px 90px;overflow-anchor:none;outline:none;scroll-padding:70px 0 90px;overflow:auto}.document{max-width:980px;margin:0 auto}.empty{text-align:center;color:var(--muted);padding:60px 16px}.part+.part{margin-top:30px}.part-title{color:var(--muted);letter-spacing:.02em;margin:14px 0 18px;font-size:19px;font-variant-caps:small-caps;font-weight:400}.part-title .number{font-variant-numeric:tabular-nums;margin-right:8px}.sheet{background:var(--paper);box-shadow:var(--shadow);border-radius:3px;padding:10px 0}.context,.side{line-height:0}.document img{width:100%;height:auto;display:block}.fold{color:#9a9d98;letter-spacing:4px;background:repeating-linear-gradient(90deg,#0000 0 6px,#ececec 6px 12px) 50%/100% 1px no-repeat;justify-content:center;align-items:center;height:22px;margin:4px 0;font-size:16px;display:flex}.change{color:var(--ink);outline:none;scroll-margin:70px;position:relative}.change.standalone{background:var(--paper);box-shadow:var(--shadow);border-radius:3px;margin-bottom:26px}.change.inline{margin:6px 0}.change-head{background:var(--head);color:var(--muted);border-top:1px solid var(--line);border-bottom:1px solid var(--line);align-items:baseline;gap:10px;padding:8px 12px;font-size:12px;line-height:1.6;display:flex}.change-number{color:var(--ink);white-space:nowrap;font-weight:400}.change-where{text-overflow:ellipsis;white-space:nowrap;flex:1;min-width:0;font:11px/1.8 ui-monospace,SFMono-Regular,Menlo,monospace;overflow:hidden}.change-kind{white-space:nowrap}.badge{white-space:nowrap;font-weight:600}.badge:empty{display:none}.link{color:var(--accent);background:0 0;border:0;padding:0 2px;font-size:12px}.link.active{font-weight:600;text-decoration:underline}.edits{white-space:nowrap}.side{border-left:2px solid #0000;position:relative}.side.before{background:var(--before);border-left-color:var(--before-edge)}.side.after{background:var(--after);border-left-color:var(--after-edge)}.side.after.identical{border-left-color:var(--line);background:0 0}.side img{mix-blend-mode:multiply}.side:after{font:10px/1 var(--sans);letter-spacing:.06em;text-transform:uppercase;color:var(--before-edge);opacity:.9;pointer-events:none;position:absolute;top:4px;right:8px}.side.before:after{content:"before"}.side.after:after{content:"after";color:var(--after-edge)}.side.after.identical:after,.change[data-resolved] .side:after{content:none}.caption{color:var(--muted);margin:0;padding:4px 12px 8px;font-size:12px}.change.current{box-shadow:0 0 0 2px var(--accent);z-index:1}.change.current .change-head{background:color-mix(in srgb, var(--accent) 8%, var(--head));color:var(--ink)}.change[data-state=accepted] .badge{color:var(--accept)}.change[data-state=rejected] .badge{color:var(--reject)}.change[data-state=commented] .badge,.change[data-state=mixed] .badge{color:var(--comment)}.change[data-resolved=after] .side.before,.change[data-resolved=before] .side.after:not(.identical){display:none}.change[data-resolved] .side{background:0 0;border-left-color:#0000}.change[data-resolved] .caption{display:none}.remark,.histories{padding:8px 14px;font-size:13px;line-height:1.55}.remark{background:color-mix(in srgb, var(--comment) 8%, #fff);border-top:1px solid var(--line);color:var(--ink)}.remark p,.histories p{white-space:pre-wrap;margin:0}.histories{border-bottom:1px solid var(--line);color:var(--muted);background:#f6f7fb}.source{background:var(--paper);border-top:1px solid var(--line);padding:10px 14px 12px;line-height:1.5}.source-unit+.source-unit{margin-top:12px}.source-title{color:#555;align-items:center;gap:8px;margin-bottom:6px;font:11px ui-monospace,SFMono-Regular,Menlo,monospace;display:flex}.unit-actions{font:13px var(--sans);align-items:center;gap:2px;margin-left:auto;display:flex}.unit-actions button{border:1px solid var(--line);background:var(--paper);border-radius:0;padding:1px 8px;font-weight:600}.unit-actions button:not(:disabled):hover{background:var(--frame)}.unit-actions .accept{color:var(--accept)}.unit-actions .reject{color:var(--reject)}.unit-actions .comment{color:var(--comment)}.unit-state{font-weight:600}.source-unit[data-state=accepted] .unit-state{color:var(--accept)}.source-unit[data-state=rejected] .unit-state{color:var(--reject)}.source-unit[data-state=commented] .unit-state{color:var(--comment)}.source-code{border:1px solid var(--line);white-space:pre-wrap;overflow-wrap:anywhere;color:#2b2f33;background:#fff;border-radius:5px;max-height:420px;margin:0;padding:10px 12px;font:12.5px/1.65 ui-monospace,SFMono-Regular,Menlo,monospace;overflow:auto}.source-code del{color:#8e1d28;background:#fadfe1;-webkit-text-decoration:line-through #c9636b;text-decoration:line-through #c9636b}.source-code ins{color:#11603a;background:#d6f0df;text-decoration:none}.banner{background:color-mix(in srgb, var(--accent) 6%, var(--paper));border:1px solid var(--line);border-radius:8px;max-width:980px;margin:0 auto 14px;padding:10px 14px;font-size:13px}.banner p{margin:3px 0}.banner .details{background:var(--bar);white-space:pre-wrap;border-radius:5px;max-height:220px;margin:6px 0 2px;padding:8px 10px;font:11.5px/1.5 ui-monospace,Menlo,monospace;overflow:auto}.banner summary{cursor:pointer;color:var(--muted)}.waiting{text-align:center;padding:90px 16px}.waiting p{margin:6px 0}.pulse{background:var(--accent);border-radius:50%;width:12px;height:12px;margin:0 auto 18px;animation:1.6s ease-in-out infinite pulse}@keyframes pulse{0%,to{opacity:.25;transform:scale(.8)}50%{opacity:1;transform:scale(1.15)}}.task-list{background:var(--bar);border:1px solid var(--line);box-shadow:var(--shadow);border-radius:8px;margin:0;padding:0;list-style:none}.task-list li+li{border-top:1px solid var(--line)}.index .document{max-width:880px}.overview-heading{margin:32px 0}.overview-heading h1{letter-spacing:.02em;margin:0 0 6px;font-size:34px;font-variant-caps:small-caps}.overview-heading p{margin:6px 0}.overview-summary{color:var(--muted);font-size:13px}.task-tools{gap:10px;margin-bottom:16px;display:flex}.task-tools input,.task-tools select{font:inherit;color:var(--ink);background:var(--bar);border:1px solid var(--line);border-radius:7px;padding:9px 12px}.task-tools input{flex:1;min-width:0}.task-tools input::placeholder{color:var(--muted)}.task-card{color:var(--ink);border-radius:7px;padding:24px 20px;text-decoration:none;display:block}.task-card:hover{background:var(--head)}.task-card:focus-visible,.overview-link:focus-visible,.task-tools :focus-visible{outline:2px solid var(--accent);outline-offset:2px}.task-heading{justify-content:space-between;align-items:baseline;gap:10px;display:flex}.task-heading h2{overflow-wrap:anywhere;margin:0;font-size:21px;font-weight:400}.task-meta{color:var(--muted);flex-wrap:wrap;gap:4px 14px;margin-top:5px;font-size:12px;display:flex}.task-name{overflow-wrap:anywhere;font-family:ui-monospace,SFMono-Regular,Menlo,monospace}.task-progress{color:var(--muted);align-items:center;gap:10px;margin-top:14px;font-size:12px;display:flex}.task-progress .track{width:140px}.task-footer{justify-content:space-between;align-items:baseline;gap:10px;margin-top:9px;font-size:12px;display:flex}.task-counts{color:var(--muted);flex-wrap:wrap;gap:4px 14px;display:flex}.task-counts [data-kind=pending]{color:var(--accent);font-weight:600}.task-counts [data-kind=commented]{color:var(--comment)}.task-open{color:var(--accent);flex:none;font-weight:600}.actions{z-index:4;background:var(--bar);border:1px solid var(--line);max-width:calc(100vw - 24px);box-shadow:var(--shadow);border-radius:12px;align-items:center;gap:2px;padding:5px;display:flex;position:fixed;bottom:22px;left:50%;transform:translate(-50%)}.actions button{white-space:nowrap;background:0 0;border:0;border-radius:8px;padding:9px 14px;font-size:14px}.actions button:not(:disabled):hover{background:var(--head)}.actions .nav{color:var(--muted);padding:6px 12px;font-size:20px;line-height:1}.actions .accept{color:var(--accept)}.actions .reject{color:var(--reject)}.actions .comment{color:var(--comment)}.actions .skip{font-weight:600}.actions .undo{color:var(--muted);border-left:1px solid var(--line);border-radius:0 8px 8px 0;margin-left:4px;font-size:13px}.actions .working{opacity:.55}.position{text-align:center;min-width:52px;color:var(--muted);font-variant-numeric:tabular-nums;font-size:12px}.complete{color:var(--muted);white-space:nowrap;padding:0 14px;font-size:13px}.change.current>.change-head{top:calc(-1 * var(--paper-top));z-index:4;position:sticky}.change-head .dock{flex:none;align-items:center;margin:0;display:flex}.change-head .actions{background:var(--bar);border:1px solid var(--line);border-radius:10px;gap:0;max-width:none;padding:3px;position:static;transform:none;box-shadow:0 1px 2px #00000014,0 6px 20px #0000001f}.change-head .actions button{padding:4px 8px;font-size:13px;line-height:1.5}.change-head .actions .nav{padding:2px 8px;font-size:17px}.change-head .actions .undo{margin-left:3px;padding:4px 10px;font-size:12px}.change-head .position{min-width:40px;font-size:11.5px}.change-head .complete{padding:0 8px;font-size:12px}.change-head .composer{width:min(380px,100vw - 24px);position:absolute;inset:calc(100% + 6px) 8px auto auto;transform:none}.composer{z-index:5;background:var(--bar);border:1px solid var(--line);border-radius:12px;width:min(540px,100vw - 24px);padding:12px;position:fixed;bottom:84px;left:50%;transform:translate(-50%);box-shadow:0 6px 24px #00000014}.composer label{color:var(--ink);margin-bottom:6px;font-size:17px;font-weight:400;display:block}.composer textarea{resize:vertical;border:1px solid var(--line);background:var(--paper);color:#1f2328;border-radius:7px;width:100%;min-height:84px;padding:8px 10px}.composer textarea:focus{outline:2px solid color-mix(in srgb, var(--comment) 45%, transparent);border-color:#0000}.composer-row{justify-content:space-between;align-items:center;margin-top:8px;font-size:12px;display:flex}.composer-row kbd{margin-left:0}.composer button{border:1px solid var(--line);background:var(--paper);color:var(--ink);border-radius:7px;padding:6px 16px}.toast{z-index:6;border:1px solid var(--line);background:var(--paper);max-width:min(640px,100vw - 24px);color:var(--ink);white-space:pre-wrap;padding:9px 14px;font-size:13px;position:fixed;top:74px;left:50%;transform:translate(-50%);box-shadow:0 3px 12px #0000000f}.toast.error{background:#7f2b31}dialog{border:1px solid var(--line);box-shadow:var(--shadow);background:var(--bar);color:var(--ink);border-radius:12px;max-width:min(460px,100vw - 32px);padding:20px 24px}dialog::backdrop{background:#00000040}dialog h2{margin:0 0 12px;font-size:23px}dialog dl{grid-template-columns:auto 1fr;gap:8px 16px;margin:0 0 12px;font-size:13px;display:grid}dialog dt{white-space:nowrap}dialog dt kbd{margin:0 2px 0 0}dialog dd{margin:0}dialog form{text-align:right}dialog button{border:1px solid var(--line);background:var(--frame);border-radius:7px;padding:5px 14px}@media (width<=720px){.bar{grid-template-columns:auto 1fr auto;gap:8px;padding:12px 16px;display:grid}.identity{grid-area:1/1/auto/-1}.bar .meter{justify-self:center;font-size:11px}.bar-end{gap:2px}.bar .ghost{padding:4px 2px;font-size:12px}.side{min-height:20px}.track{width:70px}.actions button{padding:9px}.change-head{flex-wrap:wrap}.change-head .dock{flex-basis:100%;order:9;justify-content:center;margin:4px 0 2px}.change-head .composer{width:calc(100vw - 24px);right:0}:root{--paper-top:10px}#paper{padding:var(--paper-top) 6px 90px}#paper.index{padding:10px 14px 40px}.overview-heading{margin-top:16px}.task-tools{flex-wrap:wrap}.task-tools input{flex-basis:100%}.task-tools select{width:100%}.task-card{padding:14px}.task-heading{flex-direction:column;gap:6px}}@media (prefers-reduced-motion:reduce){*{scroll-behavior:auto!important;transition:none!important;animation:none!important}}body{display:block}#root{grid-template-rows:auto 1fr;height:100dvh;display:grid;overflow:hidden}.review-body{min-height:0;position:relative}.review-body>#paper{scrollbar-width:none;height:100%;padding-right:54px}.review-body>#paper::-webkit-scrollbar{display:none}.change-map{z-index:5;border:1px solid var(--line);touch-action:none;-webkit-user-select:none;user-select:none;background:#fafafa;border-radius:7px;width:22px;position:absolute;top:12px;bottom:12px;right:18px;box-shadow:0 1px 4px #0000000d}.change-map-viewport{cursor:grab;background:#6a6f741c;border:1px solid #c6c9cc;border-radius:5px;position:absolute;left:0;right:0}.change-map-viewport:active{cursor:grabbing}.change-map-mark{--mark:#b18a3c;background:var(--mark);border:0;border-radius:2px;width:calc(100% - 10px);min-height:0;padding:0;position:absolute;left:5px}.change-map-mark[data-state=accepted]{--mark:var(--accept)}.change-map-mark[data-state=rejected]{--mark:var(--reject)}.change-map-mark[data-state=commented]{--mark:var(--comment)}.change-map-mark[data-state=mixed]{--mark:#796195}.change-map-mark[aria-current]{outline:2px solid var(--ink);outline-offset:2px}.change-map-mark:hover,.change-map-mark:focus-visible{z-index:1;outline:2px solid var(--accent);outline-offset:2px}.change-map-tooltip{border:1px solid var(--line);background:var(--paper);width:max-content;max-width:min(360px,100vw - 64px);box-shadow:var(--shadow);color:var(--ink);font:12px/1.5 var(--sans);text-align:left;overflow-wrap:anywhere;pointer-events:none;visibility:hidden;border-radius:7px;padding:7px 10px;position:absolute;top:0;right:calc(100% + 12px)}.change-map-mark:hover .change-map-tooltip,.change-map-mark:focus-visible .change-map-tooltip{visibility:visible}@media (width<=720px){.review-body>#paper{padding-right:46px}.change-map{width:18px;right:16px}.change-map-mark{width:calc(100% - 6px);left:3px}.change-head .actions{flex-wrap:wrap;justify-content:center;max-width:100%}.change-head .actions button{padding:4px 6px;font-size:12px}.change-head .actions .nav{padding:2px 6px}.change-head .position{min-width:32px}}.pdf-strip{isolation:isolate;width:100%;position:relative;container-type:inline-size}.pdf-strip img{-webkit-user-select:none;user-select:none;pointer-events:none;position:absolute;inset:0}.pdf-text{color:#0000;-webkit-user-select:text;user-select:text;cursor:text;line-height:1;position:absolute;inset:0;overflow:hidden}.pdf-text-line{white-space:pre}.pdf-glyph{white-space:pre;transform-origin:0 0;color:#0000;font-family:Times New Roman,serif;font-weight:400;line-height:1;position:absolute}.pdf-glyph::selection{color:#0000;background:#437ee759}.copy-reference{white-space:nowrap}.change-head{flex-wrap:wrap}.change-head .change-where{min-width:160px}.document .source-unit button{line-height:1.5}.help-backdrop{z-index:8;background:#00000040;place-items:center;display:grid;position:fixed;inset:0}.help-backdrop dialog{margin:0;position:static}.composer{line-height:1.5}@media (width<=900px){.change-head .dock{flex-basis:100%;order:9;justify-content:center;margin:4px 0 2px}}