agentbox-app 0.1.7 → 0.1.12

package/main/account-discovery.mjs

@@ -1,10 +1,10 @@
 // THE ACCOUNTS AGENTBOX RUNS ON ARE THE ONES ON THE DISK, not the ones somebody
 // remembered to type into a config file.
 //
-// It was logged in. ~/.claude-work held work@example.com, signed in at 15:19
-// that afternoon, and the fleet had been stopped since 15:14 on a personal
-// subscription that had hit its WEEKLY limit — three days of nothing, with a
-// rested paid account on the same disk. The register of accounts was the
+// Picture someone with two subscriptions: a second account signed in through
+// its own CLAUDE_CONFIG_DIR, and a first one that has hit its WEEKLY limit.
+// The fleet stops for days, with a rested account on the same disk the whole
+// time. The register of accounts was the
 // hand-written `authProfiles` key in zero.config.json, which nothing in the app
 // writes and nothing in the app checks against reality, so an account set up
 // the ordinary way (a new CLAUDE_CONFIG_DIR, a /login) was invisible BY
@@ -18,24 +18,25 @@
 //   - A folder under the home directory named `.claude` or `.claude-<anything>`
 //     that holds a login is an account.
 //   - IT ONLY COUNTS IF ITS SUBSCRIPTION IS NEW. Two folders holding one
-//     account is her exact setup (~/.claude and ~/.claude-second were both
-//     you@example.com), and counting it twice sends two thirds of every spawn
-//     round to an account that is already at its limit. The test is on
+//     account is a real setup (~/.claude and ~/.claude-second both signed in
+//     as the same person), and counting it twice sends two thirds of every
+//     spawn round to an account that is already at its limit. The test is on
 //     `accountUuid`, the id Claude Code stores for the subscription itself,
-//     never on the email — she made that point herself and she was right.
-//   - NOTHING SHE CONFIGURED IS EVER DROPPED OR REORDERED. Her file is a
-//     decision; this is only a discovery. Discovered accounts go after hers.
-//   - A folder with no login is not an account. Two of hers are exactly that
-//     (~/.claude-swap-backup, ~/.claude-worktrees) and neither is a place to
-//     send her work.
+//     never on the email, because one email can hold more than one subscription.
+//   - NOTHING THE USER CONFIGURED IS EVER DROPPED OR REORDERED. The config is a
+//     decision; this is only a discovery. Discovered accounts go after the
+//     configured ones.
+//   - A folder with no login is not an account. Folders such as
+//     ~/.claude-swap-backup or ~/.claude-worktrees are exactly that, and
+//     neither is a place to send work.
 //
-// WHY THERE IS NO REFRESH BUTTON, which was her own question. It is not costly.
+// WHY THERE IS NO REFRESH BUTTON. It is not costly.
 // The directory listing is cached on the home folder's own mtime, so the
 // readdir happens once and then only when a folder appears or disappears; the
 // login inside each candidate is read through `accountIdentity`, which is
-// already cached on that file's mtime. Measured on her own home folder on
-// 2026-08-31 — 200 entries, 9 .claude-shaped, 5 of them directories, 3 holding
-// a login — a warm call costs 0.029 ms, and it is asked on the supervisor's
+// already cached on that file's mtime. Measured on a home folder of 200
+// entries, 9 .claude-shaped, 5 of them directories, 3 holding a login, a
+// warm call costs 0.029 ms, and it is asked on the supervisor's
 // 15-second tick. A button would only be a thing to remember to press.
 //
 // THE DELIBERATE LIMIT: one level, under the home directory only. A profile
@@ -103,9 +104,9 @@ export function discoverProfiles({ home = os.homedir() } = {}) {
 }
 
 /**
- * THE PROFILES THE FLEET ACTUALLY RUNS ON: hers first, exactly as she wrote
- *  them, then any subscription found on the disk that none of hers is already
- *  running on.
+ * THE PROFILES THE FLEET ACTUALLY RUNS ON: the configured ones first, exactly
+ *  as written, then any subscription found on the disk that none of the
+ *  configured ones is already running on.
  *
  *  Profiles are the strings the rest of the app has always used: the literal
  *  'default' for ~/.claude (which is what spawning with no CLAUDE_CONFIG_DIR

package/main/account-tooling.mjs

@@ -182,16 +182,15 @@ function list(names) {
 //
 // The Accounts page named its two rows `default` and `.claude-second`, which
 // are folders, not people. So there was no way to tell from the screen which
-// subscription either row was running on, and on 2026-08-29 that cost her the
-// second one. The page said the second account was signed out. She did exactly
-// what it told her to do, ran the command and typed /login at 1:47pm, and the
-// browser was already signed in as her personal account, so the login handed
-// that one back. Her work account, work@example.com, had been in that folder
-// since at least 08-23 and was gone by 1:50pm, replaced by the same account the
-// first row was already using. Measured off the config backups the CLI itself
-// writes. Nothing on the page changed when it happened, because nothing on the
-// page had ever said whose account it was, which is also exactly what she
-// reported: "Idk which is logged in nothing changed in settings".
+// subscription either row was running on, and that can cost a person their
+// second account. Say the page reports the second account signed out. They do
+// exactly what it tells them to do, run the command and type /login, and the
+// browser is already signed in as the account the first row uses, so the login
+// hands that one back. The other account that had been in that folder is gone,
+// replaced by the same account the first row was already using; the config
+// backups the CLI itself writes show the swap. Nothing on the page changes
+// when it happens, because nothing on the page had ever said whose account it
+// was: "Idk which is logged in nothing changed in settings".
 //
 // One line of the answer, read from the file Claude Code keeps its own account
 // in. Null when the folder holds no login, which reads on the page as the one
@@ -199,7 +198,8 @@ function list(names) {
 const identityCache = new Map();
 
 export function accountIdentity(dir, { home = os.homedir() } = {}) {
-  const file = path.join(dir || defaultClaudeHome(home), '.claude.json');
+  let file = path.join(dir || defaultClaudeHome(home), '.claude.json');
+  if (!dir && !fs.existsSync(file)) file = path.join(home, '.claude.json');
   // Cached on the file's own mtime rather than on a timer. That file is ~120 KB
   // on this machine and the settings page re-reads on every poll, so parsing it
   // each time would be real work for an answer that changes about twice a

package/main/agent-activity.mjs

@@ -1,7 +1,7 @@
 // Ephemeral, local status from matched tool start/end events. A persisted trace
 // is history and cannot prove a command is still running. Nothing here executes
 // commands, records reasoning, or changes worker permissions.
-import { plainCommand, shortPath } from '../shared/work-lines.mjs';
+import { commandWork, isBookkeeping, plainCommand, shortPath } from '../shared/work-lines.mjs';
 const clean = value => typeof value === 'string' ? value.replace(/\s+/g, ' ').trim() : '';
 function add(session, id, label, detail) {
   if (!id || !label) return false;
@@ -11,12 +11,43 @@ function add(session, id, label, detail) {
   return true;
 }
 function finish(session, id) { return session.activeTools?.delete(id) ?? false; }
-function clear(session) { const changed = !!session.activeTools?.size; session.activeTools?.clear(); return changed; }
+// A turn ending clears what it was doing, but not a background job: that is
+// still running, and the session is kept open waiting for it
+// (main/claude-input.mjs), so the row keeps saying what it waits on.
+function clear(session) {
+  let changed = false;
+  for (const [id, entry] of session.activeTools ?? []) {
+    if (entry.background) continue;
+    session.activeTools.delete(id);
+    changed = true;
+  }
+  return changed;
+}
+function backgroundJobs(session, tasks) {
+  const pending = session.activeTools ??= new Map();
+  const live = new Set(tasks.map(t => `bg:${t?.task_id}`));
+  let changed = false;
+  for (const [id, entry] of pending) if (entry.background && !live.has(id)) { pending.delete(id); changed = true; }
+  for (const task of tasks) {
+    const description = clean(task?.description);
+    const plain = commandWork(description);
+    const label = plain ? `${plain.doing} ${plain.subject}`.trim() : `Waiting on: ${description || 'a background job'}`;
+    if (add(session, `bg:${task?.task_id}`, label, description)) { pending.get(`bg:${task?.task_id}`).background = true; changed = true; }
+  }
+  return changed;
+}
 export function currentActivity(session) { return [...(session.activeTools?.values() ?? [])]; }
 function toolLabel(name, input) {
   const command = clean(input.command);
   const file = clean(input.file_path ?? input.path);
-  if (name === 'Bash') return ['Running ' + (plainCommand(command) || 'command'), input.command ?? ''];
+  if (name === 'Bash') {
+    // WHAT IT IS DOING, IN WORDS, when the whole command is recognised. The
+    // line under a running row is the same event as the line in the thread
+    // above it, read in the present tense (`doing`, shared/work-lines.mjs).
+    const plain = commandWork(command);
+    if (plain) return [`${plain.doing} ${plain.subject}`.trim(), input.command ?? ''];
+    return ['Running ' + (plainCommand(command) || 'command'), input.command ?? ''];
+  }
   if (['Read','Write','Edit','MultiEdit'].includes(name)) return [`${name === 'Read' ? 'Reading' : name === 'Write' ? 'Writing' : 'Editing'} ${shortPath(file) || 'file'}`, file];
   if (['Grep','Glob','WebSearch'].includes(name)) return [`Searching ${clean(input.pattern ?? input.query) || 'files'}`, input.pattern ?? input.query ?? ''];
   if (name === 'WebFetch') return ['Reading web page', input.url ?? ''];
@@ -28,9 +59,13 @@ export function claudeActivity(session, line) {
     const obj = JSON.parse(line);
     if (obj.parent_tool_use_id) return false;
     if (obj.type === 'result') return clear(session);
+    if (obj.type === 'system' && obj.subtype === 'background_tasks_changed' && Array.isArray(obj.tasks)) return backgroundJobs(session, obj.tasks);
     let changed = false;
     for (const part of Array.isArray(obj.message?.content) ? obj.message.content : []) {
       if (obj.type === 'assistant' && part.type === 'tool_use') {
+        // The store's own records never become the word on the row: taking the
+        // item is not what the session is doing (w-0bd0d8b2ef).
+        if (isBookkeeping(part.name)) continue;
         const [label, detail] = toolLabel(part.name, part.input ?? {});
         changed = add(session, part.id, label, detail) || changed;
       }
@@ -47,9 +82,14 @@ export function codexActivity(session, method, params) {
   if (method !== 'item/started') return false;
   if (item.status && !['inProgress', 'in_progress', 'running'].includes(item.status)) return false;
   switch (item.type) {
-    case 'commandExecution': return add(session, item.id, `Running ${plainCommand(clean(item.command)) || 'command'}`, item.command);
+    case 'commandExecution': {
+      const plain = commandWork(clean(item.command));
+      const label = plain ? `${plain.doing} ${plain.subject}`.trim() : `Running ${plainCommand(clean(item.command)) || 'command'}`;
+      return add(session, item.id, label, item.command);
+    }
     case 'fileChange': return add(session, item.id, 'Editing files', (Array.isArray(item.changes) ? item.changes : []).map(c => c?.path ?? '').join('\n'));
-    case 'mcpToolCall': return add(session, item.id, `Using ${clean(item.tool).replace(/_/g, ' ') || 'tool'}`, `${item.server ?? ''} · ${item.tool ?? ''}`);
+    case 'mcpToolCall': return isBookkeeping(clean(item.tool)) ? false
+      : add(session, item.id, `Using ${clean(item.tool).replace(/_/g, ' ') || 'tool'}`, `${item.server ?? ''} · ${item.tool ?? ''}`);
     case 'webSearch': return add(session, item.id, 'Searching the web', item.query ?? '');
     default: return false;
   }

package/main/agent-schedule.mjs

@@ -1,4 +1,4 @@
-// WHEN SHE ASKED TO SEE AN AGENT AGAIN, AND WHEN SHE ASKED NOT TO. One small
+// WHEN THE USER ASKED TO SEE AN AGENT AGAIN, AND WHEN THEY ASKED NOT TO. One small
 // durable map, and the only state the app keeps about a session it did not start.
 //
 // Three facts per agent and they are different facts. `runAt` is a moment she
@@ -41,9 +41,9 @@ import { agentKey } from '../shared/agents.mjs';
 
 const num = (v) => (Number.isFinite(Number(v)) ? Math.max(0, Math.trunc(Number(v))) : 0);
 
-// HER SIDE OF A THREAD IS SMALL, and this file is read on every draw. Measured
-// across her 16 real sessions on 2026-08-17: 155 turns of hers in total, median
-// 6 per session, median 131 characters. The card shows three. Eight, at 600
+// THE USER'S SIDE OF A THREAD IS SMALL, and this file is read on every draw. A
+// real session has a handful of human turns, typically a sentence or two each.
+// The card shows three. Eight, at 600
 // characters, is far more than anything draws and small enough that a session
 // left running for a month cannot grow the file without bound.
 const KEEP_SPOKE = 8;
@@ -116,8 +116,8 @@ export class AgentSchedule {
   }
 
   // An entry that says none of "later", "seen", "I spoke to it" or "here is what
-  // she said" is not an entry. The last of those four is why this is not the
-  // same list as it was: her words outlive the reply that carried them, so an
+  // the user said" is not an entry. The last of those four is why this is not the
+  // same list as it was: the user's words outlive the reply that carried them, so an
   // entry holding only `spoke` is still the record of a conversation.
   _keep(key, entry, now) {
     if (entry.runAt > now || entry.doneThrough > 0 || entry.repliedAt > 0 || entry.spoke?.length) this.byKey[key] = entry;
@@ -155,8 +155,8 @@ export class AgentSchedule {
     // undid the close, saying a session was working on something she had
     // already finished with.
     //
-    // BUT IT DOES NOT UNSAY WHAT SHE SAID. This used to empty `spoke` as well,
-    // and `spoke` is the ONLY record anywhere that she ever spoke to a session:
+    // BUT IT DOES NOT UNSAY WHAT THE USER SAID. This used to empty `spoke` as well,
+    // and `spoke` is the ONLY record anywhere that the user ever spoke to a session:
     // Claude Code stamps an injected message `isMeta` and the transcript reader
     // drops it, correctly, so nothing else on the machine knows. Measured on
     // session-46: four of her messages reached that session and the file holds
@@ -200,12 +200,12 @@ export class AgentSchedule {
    *
    * It is here because it is the only place that knows. Claude Code stamps a
    * message injected over its socket `isMeta: true` and wraps it in "Another
-   * Claude session sent a message… not typed by y measured 2026-08-17 on
-   * session-67, where two messages she sent at 19:41 left the row saying only
-   * what she had started it with four days earlier.
+   * Claude session sent a message…", so the transcript reader drops it, and
+   * without this record messages sent from Agentbox left the row saying only
+   * what the session was started with days earlier.
    *
-   * A another of her sessions pinging this one is a real peer and drawing it as
-   * her words would be a lie on the one card built to be trusted. So the record
+   * Another of the user's sessions pinging this one is a real peer, and drawing
+   * it as the user's words would be a lie on the one card built to be trusted. So the record
    * is written at the moment of delivery, by the only process that knows it
    * delivered it.
    */
@@ -236,7 +236,7 @@ export class AgentSchedule {
       if (entry.runAt > now) { out.runAt = entry.runAt; out.runAtSetAt = entry.setAt; }
       if (entry.doneThrough > 0) out.doneThrough = entry.doneThrough;
       if (entry.repliedAt > 0) out.repliedAt = entry.repliedAt;
-      // the card quotes what she said last, and a session that has since
+      // the card quotes what the user said last, and a session that has since
       // stopped is exactly when she most needs to see it.
       if (entry.spoke?.length) out.spoke = entry.spoke;
       return out;

package/main/agent-sessions.mjs

@@ -58,8 +58,12 @@ import path from 'node:path';
  *  the last three days and 9 in the last seven, in two folders she works in.
  *  Three days is a card with tonight's test on it and almost nothing else; the
  *  filters have already done the work that "a few" was standing in for, so the
- *  window can afford to be the generous reading. */
-export const RECENT_DAYS = 7;
+ *  window can afford to be the generous reading.
+ *
+ *  Ten since the launch list (w-db6f5e331e, 2026-10-05): "showing your recently
+ *  active agents over the last 10 days". Codex reads the same number
+ *  (main/codex-threads.mjs), so the two halves of the card agree. */
+export const RECENT_DAYS = 10;
 
 /**
  * How much of a transcript is read to find its first human turn. The first
@@ -67,6 +71,15 @@ export const RECENT_DAYS = 7;
  *  the largest in her store on 2026-08-29 is 13MB, and there are hundreds. */
 const HEAD_BYTES = 96 * 1024;
 
+/**
+ * How far past the head one cut-off first message may be followed
+ *  (w-24edc04548, 2026-10-05). A screenshot pasted into the first message is
+ *  written into that row as base64, so the row outgrows the head: three of her
+ *  ten days' terminal threads opened with rows of 240KB, 294KB and 486KB, were
+ *  cut, lost their name and fell off the card. Eight megabytes is the Codex
+ *  reader's own ceiling (main/codex-threads.mjs) and several screenshots. */
+const FIRST_TURN_BYTES = 8 * 1024 * 1024;
+
 /**
  * A stop on how many transcripts are OPENED, for the same reason the folder
  *  scan in agent-files.mjs has one: opening a card may not turn into a disk
@@ -80,6 +93,10 @@ const HEAD_BYTES = 96 * 1024;
  *  whether tonight's thread survived was down to where its folder sorted. A
  *  cap that can drop the newest thread on the machine is not a safety rail. */
 const MAX_READS = 1200;
+// How long the conversation read may take, in ms (w-ec62ab6b38). The card that
+// uses it says "Looking" meanwhile; three seconds reaches two thirds of her
+// week's 9,073 transcripts and all of a normal Mac's.
+const READ_BUDGET_MS = 3000;
 
 /* ------------------------- WHAT IS NOT HERS TO IMPORT ---------------------- */
 
@@ -106,6 +123,21 @@ export function isScratchFolder(folder, home = os.homedir()) {
     || /^\/var\/folders(\/|$)/.test(p);
 }
 
+/**
+ * THE SAME RULE, READ OFF THE FOLDER CLAUDE CODE FILED THE TRANSCRIPT IN, so
+ *  it can be applied before the file is opened (w-24edc04548, 2026-10-05).
+ *  Claude Code names that folder after the working folder with every other
+ *  character turned into `-`, so `/private/tmp/w-1` is `-private-tmp-w-1`.
+ *  Of her 12,272 transcripts touched in ten days about 12,000 were in temp
+ *  folders, and opening each one only to refuse it spent the card's three
+ *  seconds before it reached her oldest threads. */
+export function isScratchProjectDir(name, home = os.homedir()) {
+  const n = String(name ?? '');
+  const here = path.resolve(String(home ?? '')).replace(/[^a-zA-Z0-9]/g, '-');
+  if (here.length > 1 && (n === here || n.startsWith(`${here}-`))) return false;
+  return /^-(private-)?(tmp|var-folders)(-|$)/.test(n);
+}
+
 /**
  * THE ONES A PERSON STARTED, which is the whole filter.
  *
@@ -171,7 +203,9 @@ export function threadTitle(texts, max = 72) {
 function titleFromOne(text, max) {
   const raw = String(text ?? '').replace(/\r/g, '');
   for (const line of raw.split('\n')) {
-    const t = line.trim();
+    // `[Image #1]` and `[Pasted text #1 +40 lines]` are Claude Code's stand-ins
+    // for what was pasted, not words she typed.
+    const t = line.replace(/\[(?:Image|Pasted text) #\d+[^\]]*\]/g, '').trim();
     if (!t) continue;
     if (NOT_TYPED.some((re) => re.test(t))) return '';
     const clean = t
@@ -209,7 +243,7 @@ export function shortFolder(folder, home = os.homedir()) {
  *  every message row and the first human turn is the first message, so all
  *  three are at the top, and the alternative is reading gigabytes to fill in a
  *  list. Her largest transcript is 13MB and there are hundreds. */
-export function readTranscriptHead(file, bytes = HEAD_BYTES) {
+export function readTranscriptHead(file, bytes = HEAD_BYTES, most = FIRST_TURN_BYTES) {
   let fd = null;
   try {
     fd = fs.openSync(file, 'r');
@@ -218,22 +252,37 @@ export function readTranscriptHead(file, bytes = HEAD_BYTES) {
     const text = buf.slice(0, n).toString('utf8');
     // The last line of a fixed read is usually cut in half. Dropping it costs
     // nothing, because what is wanted is at the top.
-    const lines = text.split('\n').slice(0, -1);
+    const lines = text.split('\n');
+    const cut = lines.pop();
     let cwd = null;
     let entrypoint = null;
     const said = [];
-    for (const line of lines) {
-      if (!line.trim()) continue;
+    const take = (line) => {
       let row;
-      try { row = JSON.parse(line); } catch { continue; }
+      try { row = JSON.parse(line); } catch { return; }
       if (!cwd && typeof row.cwd === 'string' && row.cwd) cwd = row.cwd;
       if (!entrypoint && typeof row.entrypoint === 'string' && row.entrypoint) entrypoint = row.entrypoint;
       if (row.type === 'user' && said.length < 5) {
         const t = messageText(row);
         if (t.trim()) said.push(t);
       }
+    };
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      take(line);
       if (cwd && entrypoint && said.length >= 5) break;
     }
+    // UNLESS THE HALF LINE IS HER FIRST MESSAGE, cut because a screenshot was
+    // pasted into it. Then it is read to its end, once, up to `most`. Only a
+    // cut row that names itself a user message near its start qualifies, and
+    // only when nothing she said was found and the session is not already
+    // known to be the app's own, so the thousands of worker transcripts are
+    // never read past their head.
+    if (!said.length && n === bytes && cut && /"type":"user"/.test(cut.slice(0, 2048))
+      && (!entrypoint || startedByHand(entrypoint))) {
+      const rest = restOfLine(fd, n, most - n);
+      if (rest) take(Buffer.concat([buf.subarray(buf.lastIndexOf(0x0a, n - 1) + 1, n), rest]).toString('utf8'));
+    }
     return { cwd, entrypoint, said };
   } catch {
     return { cwd: null, entrypoint: null, said: [] };
@@ -242,6 +291,25 @@ export function readTranscriptHead(file, bytes = HEAD_BYTES) {
   }
 }
 
+/**
+ * The bytes from `from` up to the next newline, or null if there is none
+ *  within `budget` bytes: a line that long is given up on, not read whole. A
+ *  file that ends without a newline ends the line too. */
+function restOfLine(fd, from, budget) {
+  const parts = [];
+  let at = from;
+  const chunk = Buffer.alloc(256 * 1024);
+  while (at - from < budget) {
+    const n = fs.readSync(fd, chunk, 0, Math.min(chunk.length, budget - (at - from)), at);
+    if (n <= 0) return Buffer.concat(parts);
+    const nl = chunk.subarray(0, n).indexOf(0x0a);
+    if (nl >= 0) { parts.push(Buffer.from(chunk.subarray(0, nl))); return Buffer.concat(parts); }
+    parts.push(Buffer.from(chunk.subarray(0, n)));
+    at += n;
+  }
+  return null;
+}
+
 /**
  * The words out of one transcript row, whichever of the two shapes it is in.
  *  Content is a string on the plain ones and a list of blocks on the rest. */
@@ -278,11 +346,27 @@ function readTerminalThreads({ home, cutoff, max, skipIds = new Set() }) {
     try { when = fs.statSync(file).mtimeMs; } catch { continue; }
     if (when < cutoff) { skipped.old += 1; continue; }
     if (isSubagentPath(file.slice(root.length))) { skipped.subagent += 1; continue; }
+    if (isScratchProjectDir(path.relative(root, file).split(path.sep)[0], home)) { skipped.scratch += 1; continue; }
     recent.push({ file, when });
   }
   recent.sort((a, b) => b.when - a.when);
-  if (recent.length > max) skipped.unread = recent.length - max;
-  for (const { file, when } of recent.slice(0, max)) {
+  // THE CAP COUNTS WHAT IS KEPT, NOT WHAT IS OPENED (w-ec62ab6b38, 2026-09-28).
+  // On a busy machine the last seven days held 9,073 transcripts, the newest
+  // 1,200 were opened, and every one of those was started by agentbox itself,
+  // so a conversation started by hand was never looked at and the import card
+  // said there was nothing, as if the app were not looking in Claude Code at
+  // all. Somebody running dozens of agents fills this folder with ours. So it
+  // opens newest first until it has `max` of the person's own, or until
+  // READ_BUDGET_MS has gone, whichever is first. Reading all 9,073 heads took
+  // 5.0s there.
+  const started = Date.now();
+  let opened = 0;
+  for (const { file, when } of recent) {
+    if (out.length >= max || Date.now() - started > READ_BUDGET_MS) {
+      skipped.unread = recent.length - opened;
+      break;
+    }
+    opened += 1;
     const id = path.basename(file, '.jsonl');
     // THE DESKTOP APP WRITES A THREAD TWICE, once as a transcript here and once
     // as its own record, joined by `cliSessionId`. Measured 2026-08-29 on the

package/main/agent-updates.mjs

@@ -0,0 +1,116 @@
+// Release discovery is read-only. An updater is a dedicated PTY command,
+// started only by the app's Update now action, never by a poll or terminal open.
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import {execFile} from 'node:child_process';
+import {promisify} from 'node:util';
+import {TaskTerminals,terminalEnv} from './task-terminals.mjs';
+import {codexLaunchEnv} from './codex-launch-env.mjs';
+const exec=promisify(execFile);
+const valid=v=>typeof v==='string'&&/^\d+\.\d+\.\d+$/.test(v);
+export function newerVersion(installed,latest){
+ if(!valid(installed)||!valid(latest))return false;
+ const a=installed.split('.').map(Number),b=latest.split('.').map(Number);
+ for(let i=0;i<3;i++){if(b[i]!==a[i])return b[i]>a[i];}return false;
+}
+export function updatePlan({engine,bin,real,home=os.homedir(),channel='latest'}){
+ if(!['claude','codex'].includes(engine)||!path.isAbsolute(bin||'')||!real)return null;
+ const name=engine==='claude'?'Claude Code':'Codex';
+ const brew=real.match(/^(\/opt\/homebrew|\/usr\/local)\/Caskroom\/(claude-code(?:@latest)?|codex)\//);
+ if(brew&&((engine==='claude'&&brew[2].startsWith('claude-code'))||(engine==='codex'&&brew[2]==='codex')))
+  return {name,file:`${brew[1]}/bin/brew`,args:['upgrade','--cask',brew[2]],feed:`https://formulae.brew.sh/api/cask/${brew[2]}.json`,format:'brew'};
+ const pkg=engine==='claude'?'@anthropic-ai/claude-code':'@openai/codex';
+ const tail=`/lib/node_modules/${pkg}/`;
+ const at=real.indexOf(tail);
+ if(at>0){const prefix=real.slice(0,at);return {name,file:path.join(prefix,'bin/npm'),args:['install','--global','--prefix',prefix,`${pkg}@${channel}`],env:{PATH:`${prefix}/bin:${process.env.PATH||''}`},feed:`https://registry.npmjs.org/${pkg}/${channel}`,format:'npm'};}
+ if(engine==='claude'&&real.startsWith(path.join(home,'.local/share/claude/versions')+'/'))return {name,file:bin,args:['update'],feed:`https://downloads.claude.ai/claude-code-releases/${channel}`,format:'text'};
+ const standalone=real.match(/^(.*)\/packages\/standalone\/(?:releases|current)\//);
+ if(engine==='codex'&&standalone)return {name,file:'/bin/bash',args:['-o','pipefail','-c','/usr/bin/curl -fsSL --connect-timeout 10 --max-time 60 https://chatgpt.com/codex/install.sh | /bin/sh'],env:{CODEX_HOME:standalone[1],CODEX_INSTALL_DIR:path.dirname(bin)},feed:'https://releases.openai.com/codex/channels/latest',format:'codex'};
+ return null;
+}
+const json=file=>{try{return JSON.parse(fs.readFileSync(file,'utf8'))}catch{return {}}};
+export async function installedAgent(engine,config){
+ const bin=engine==='codex'?config.codexBin:config.claudeBin;
+ if(!bin)throw Error('This agent is not installed.');
+ const home=config.home||os.homedir();
+ const settings=engine==='claude'?json(path.join(process.env.CLAUDE_CONFIG_DIR||path.join(home,'.claude'),'settings.json')):{};
+ const cleanEnv=terminalEnv();
+ const env=engine==='codex'?codexLaunchEnv(bin,cleanEnv):cleanEnv;
+ // Version inspection must not itself auto-update anything.
+ const {stdout}=await exec(bin,['--version'],{timeout:8000,maxBuffer:16384,env:{...env,DISABLE_AUTOUPDATER:'1'}});
+ const version=stdout.match(/\b\d+\.\d+\.\d+(?:-[\w.-]+)?\b/)?.[0];
+ const channel=settings.autoUpdatesChannel==='stable'?'stable':'latest';
+ return {engine,bin,real:fs.realpathSync(bin),home,version,channel,disabled:settings.env?.DISABLE_UPDATES==='1'||process.env.DISABLE_UPDATES==='1'};
+}
+export async function latestRelease(plan){
+ const r=await fetch(plan.feed,{signal:AbortSignal.timeout(10000),headers:{Accept:plan.format==='text'?'text/plain':'application/json'}});
+ if(!r.ok)throw Error('Release check failed.');
+ const body=await r.text();if(body.length>2_000_000)throw Error('Release response too large.');
+ const data=plan.format==='text'?null:JSON.parse(body);
+ const version=plan.format==='text'?body.trim():plan.format==='codex'?String(data.version||data.tag_name||'').replace(/^(rust-v|v)/,''):data.version;
+ if(!valid(version))throw Error('Release version could not be read.');return version;
+}
+export class AgentUpdates{
+ constructor({installation,latest=latestRelease,refresh=async()=>{},terminals,now=()=>Date.now()}={}){
+  this.installation=installation;this.latest=latest;this.refresh=refresh;this.now=now;this.entries=new Map();this.checks=new Map();this.starts=new Map();this.finishes=new Map();this.plans=new Map();
+  this.terminals=terminals||new TaskTerminals({sweepMs:0});
+  this.terminals.resolve=engine=>{const p=this.plans.get(engine);if(!p)throw Error('Click Update now first.');return {cwd:p.home,command:{file:p.file,args:p.args,env:p.env},notice:`Updating ${p.name}.`}};
+ }
+ status(engine){return this.entries.get(engine)||{engine,state:'unknown'};}
+ check(engine,force=false){
+  if(!['claude','codex'].includes(engine))return Promise.reject(Error('Unknown agent.'));
+  if(this.starts.has(engine)||this.status(engine).state==='running')return Promise.resolve(this.status(engine));
+  if(this.checks.has(engine))return this.checks.get(engine);
+  const saved=this.status(engine);if(!force&&saved.checkedAt&&this.now()-saved.checkedAt<3600000)return Promise.resolve(saved);
+  const work=(async()=>{let result;try{
+   const install=await this.installation(engine);const plan=install.disabled?null:updatePlan(install);
+   if(!plan)result={engine,state:'unsupported',message:'Update this installation using its own installer.'};
+   else{const latest=await this.latest(plan);result={engine,state:newerVersion(install.version,latest)?'available':'current',installed:install.version,latest};if(!valid(install.version))throw Error('Installed version could not be read.');}
+  }catch{result={engine,state:'unknown',message:'Could not check for updates. Your current models are still available.'};}
+  result.checkedAt=this.now();if(this.starts.has(engine)||this.status(engine).state==='running')return this.status(engine);this.entries.set(engine,result);return result;})().finally(()=>this.checks.delete(engine));
+  this.checks.set(engine,work);return work;
+ }
+ start(engine){
+  if(this.starts.has(engine))return this.starts.get(engine);
+  if(this.status(engine).state==='running')return Promise.resolve(this.status(engine));
+  // Validate again at click time: an installation may have changed since
+  // the picker opened. Never trust a command or a release passed by the UI.
+  const work=(async()=>{
+   const install=await this.installation(engine);const plan=install.disabled?null:updatePlan(install);
+   if(!plan)throw Error('This installation must be updated using its own installer.');
+   const target=await this.latest(plan);
+   if(!valid(install.version))throw Error('Installed version could not be read.');
+   if(!newerVersion(install.version,target)){
+    await this.refresh(engine);const current={engine,state:'current',installed:install.version,latest:target,checkedAt:this.now(),message:'Up to date. Available models refreshed.'};this.entries.set(engine,current);return current;
+   }
+   this.plans.set(engine,{...plan,home:install.home});this.terminals.close(engine);
+   this.terminals.open(engine);
+   const running={engine,state:'running',installed:install.version,latest:target};this.entries.set(engine,running);
+   const finished=this.terminals.get(engine).exitPromise.then(async()=>{
+    try{
+     if(this.terminals.get(engine).exitCode!==0)throw Error('Update did not finish. You can retry.');
+     const after=await this.installation(engine);
+     if(!valid(after.version)||newerVersion(after.version,target))throw Error('The installed version is still older. Check the terminal output before retrying.');
+     await this.refresh(engine);
+     this.entries.set(engine,{engine,state:'current',installed:after.version,latest:target,checkedAt:this.now(),message:'Updated. Available models refreshed.'});
+    }catch(error){this.entries.set(engine,{...running,state:'failed',message:error.message});}
+   });this.finishes.set(engine,finished);return running;
+  })().catch(error=>{this.entries.set(engine,{engine,state:'failed',message:error.message});throw error;}).finally(()=>this.starts.delete(engine));
+  this.starts.set(engine,work);return work;
+ }
+ settled(engine){return this.finishes.get(engine)||Promise.resolve();}
+ terminal(engine,p){
+  // Opening the viewer is never an install action, including after it ended.
+  if(!this.plans.has(engine))throw Error('Click Update now first.');
+  switch(p.action){
+   case 'open':return this.terminals.read(engine,0);
+   case 'read':return this.terminals.read(engine,p.offset);
+   case 'write':return this.terminals.write(engine,p.data);
+   case 'resize':return this.terminals.resize(engine,p.cols,p.rows);
+   case 'close':return this.terminals.close(engine);
+   default:throw Error('Unknown terminal action.');
+  }
+ }
+ shutdown(){return this.terminals.shutdown();}
+}