agentbox-app 0.1.12 → 0.1.13

package/main/codex-session.mjs

@@ -519,9 +519,10 @@ export function createCodexWorker({
   // read loop, so anything the server packs in BEHIND the response is caught,
   // and a `ready` that somehow came in AHEAD of it would belong to no watched
   // thread and be dropped -- costing a healthy worker its run at the deadline.
-  // The resume road has no such window, because `resumeThread` watches before
-  // it sends. If a Codex release ever reorders that, this is the sentence that
-  // says where to look.
+  // The resume road watches before sending, but an already-loaded thread does
+  // not repeat startup notifications. On 2026-10-07, 11 resumes of one loaded
+  // thread died at this deadline. Check that thread's current MCP connection
+  // on resume as well as listening for startup changes.
   let storeIsUp = !requireMcpServer;
   let storeTrouble = '';
   const waiting = [];
@@ -581,6 +582,39 @@ export function createCodexWorker({
       const timer = setTimeout(() => done(false), mcpReadyMs);
       timer?.unref?.();
       waiting.push(done);
+      if (resumeThreadId) {
+        const checkExistingStore = async () => {
+          let cursor;
+          const seen = new Set();
+          do {
+            if (ended || settled || storeIsUp) return;
+            const inventory = await server.request('mcpServerStatus/list', {
+              threadId: worker.threadId,
+              serverName: requireMcpServer,
+              detail: 'toolsAndAuthOnly',
+              ...(cursor ? { cursor } : {}),
+            });
+            if (ended || settled || storeIsUp) return;
+            const store = inventory?.data?.find(s => s.name === requireMcpServer);
+            // Newer Codex reports connection state. Older versions only offer
+            // discovered tools; a configured name alone is never proof.
+            if (store?.runtimeStatus === 'connected'
+              || (store && store.runtimeStatus == null && Object.keys(store.tools ?? {}).length > 0)) {
+              readStoreStatus({ name: requireMcpServer, status: 'ready' });
+              return;
+            }
+            if (store?.runtimeStatus) storeTrouble = `its connection is ${store.runtimeStatus}`;
+            cursor = inventory?.nextCursor;
+            if (cursor && seen.has(cursor)) throw new Error('store inventory repeated its pagination cursor');
+            if (cursor) seen.add(cursor);
+          } while (cursor);
+        };
+        // The existing deadline still owns the wait, even if this RPC hangs.
+        // A startup notification can also settle it while inventory is read.
+        checkExistingStore().catch(err => {
+          if (!ended && !settled && !storeIsUp) storeTrouble = err?.message ?? String(err);
+        });
+      }
     });
   };
 
@@ -595,6 +629,7 @@ export function createCodexWorker({
   const end = (code, signal = null, how = null) => {
     if (ended) return;
     ended = true;
+    for (const wake of waiting.splice(0)) wake(false);
     if (worker.threadId) { try { server.unwatch(worker.threadId); } catch { /* already gone */ } }
     worker.emit('exit', code, signal, how);
   };

package/main/codex-threads.mjs

@@ -27,6 +27,7 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import { RECENT_DAYS, isScratchFolder, shortFolder, threadTitle } from './agent-sessions.mjs';
+import { codexDataDirs } from './agent-homes.mjs';
 import { WAS_SLUGS, nameSlug } from '../shared/product-name.mjs';
 
 export const CODEX_RECENT_DAYS = RECENT_DAYS;
@@ -252,12 +253,40 @@ export const isLive = (mtime, now = Date.now()) => Number(mtime) > 0 && now - Nu
 /**
  * THE USER'S CONVERSATIONS, newest first, in the shape the import card and the
  *  import row both read. One entry per thread a person typed into, in a real folder,
- *  touched in the last `days` days. */
-export function readCodexThreads({ home = os.homedir(), codexDir = codexHome(home), days = CODEX_RECENT_DAYS, now = Date.now() } = {}) {
-  const index = readCodexIndex(codexDir);
+ *  touched in the last `days` days.
+ *
+ *  EVERY CODEX FOLDER ON THE MACHINE, not only `~/.codex` (w-e46f2e9cea): a
+ *  second login under `~/.codex-<name>` or a `CODEX_HOME` holds conversations
+ *  the import never offered. `codexDirs` is the list main/agent-homes.mjs makes;
+ *  `codexDir` still names exactly one folder for a caller that means one. The
+ *  same conversation in two folders is one row.
+ *
+ *  WHICH COPY, AND WHICH NAME, decided apart (Codex's review of this change,
+ *  2026-10-11). The copy kept is the transcript file written last, judged by
+ *  the file alone: judging by `when`, which folds in the index's own date, let
+ *  a stale copy whose folder's index was touched later beat the copy still
+ *  being written. And the name Codex gave a conversation is read from every
+ *  folder's index, newest entry winning, so the copy kept still carries a name
+ *  that only another folder's index knew. */
+export function readCodexThreads({ home = os.homedir(), codexDir = null, codexDirs = null, days = CODEX_RECENT_DAYS, now = Date.now() } = {}) {
+  const dirs = codexDirs ?? (codexDir ? [codexDir] : codexDataDirs({ home }));
   const cutoff = now - Math.max(0, Number(days) || 0) * 86400 * 1000;
-  const out = [];
-  const skipped = { notHers: 0, scratch: 0, old: 0, empty: 0, unreadable: 0 };
+  const index = new Map();
+  for (const dir of dirs) {
+    for (const [id, entry] of readCodexIndex(dir)) {
+      const had = index.get(id);
+      if (!had || (entry.name && (!had.name || entry.updatedAt > had.updatedAt))) index.set(id, entry);
+    }
+  }
+  const byId = new Map();
+  const skipped = { notHers: 0, scratch: 0, old: 0, empty: 0, unreadable: 0, copy: 0 };
+  for (const dir of dirs) readOneCodexHome(dir, { home, days, now, cutoff, index, byId, skipped });
+  const out = [...byId.values()].map(({ fileTime, ...t }) => t);
+  out.sort((a, b) => b.when - a.when);
+  return { threads: out, skipped };
+}
+
+function readOneCodexHome(codexDir, { home, days, now, cutoff, index, byId, skipped }) {
   for (const file of listRolloutFiles(codexDir, { days, since: cutoff })) {
     const r = readRollout(file);
     if (!r) { skipped.unreadable += 1; continue; }
@@ -268,7 +297,13 @@ export function readCodexThreads({ home = os.homedir(), codexDir = codexHome(hom
     if (when < cutoff) { skipped.old += 1; continue; }
     const title = named?.name || threadTitle([r.prompt]);
     if (!title) { skipped.empty += 1; continue; }
-    out.push({
+    const had = byId.get(r.id);
+    if (had) {
+      skipped.copy += 1;
+      if (had.fileTime >= r.mtime) continue;
+    }
+    byId.set(r.id, {
+      fileTime: r.mtime,
       id: r.id,
       source: 'codex',
       folder: r.cwd,
@@ -286,6 +321,4 @@ export function readCodexThreads({ home = os.homedir(), codexDir = codexHome(hom
       live: isLive(r.mtime, now),
     });
   }
-  out.sort((a, b) => b.when - a.when);
-  return { threads: out, skipped };
 }

package/main/codex-watch.mjs

@@ -10,21 +10,85 @@
 // The founder, before launch: "after onboarding for both anthropic and openai
 // harnesses, it should only import on command, not continuously". Importing is
 // now the walk's last card and ⌘K import, for Claude Code and Codex alike.
+//
+// IT IS ALSO WHERE A CODEX AGENT IS NOTICED (w-1116fbb68a, 2026-10-08). It is
+// the one thing in the app that already knows a person's Codex conversations,
+// and it reads them on a timer rather than on the snapshot, which is what makes
+// it the right place: see `noticeCodexAgents` below.
 import { readCodexThreads } from './codex-threads.mjs';
 
 export const CODEX_POLL_MS = 60_000;
 
-export function scanCodex({ store, readThreads = readCodexThreads, now = Date.now() } = {}) {
+/**
+ * HOW LONG AFTER ITS LAST WRITE A CODEX THREAD IS STILL AN AGENT THAT WAS SEEN.
+ *
+ *  A Claude Code session is a process, so `agent_seen` catches one that has sat
+ *  open since earlier in the sitting (main/ipc.mjs, liveAgents). A Codex thread
+ *  leaves no process behind: `isLive` is two minutes of file mtime, so counting
+ *  only live threads would notice a Codex user ONLY when this watch's minute
+ *  happened to land while they were typing. An hour is one sitting, which is
+ *  the span the Claude read already covers without being asked to.
+ *
+ *  AND IT IS NOT A DAY. The reader hands over ten days of conversations, and
+ *  counting those would say every install with Codex on it had an agent up on
+ *  every day the app was opened, which is the opposite of the under-count this
+ *  was added to fix.
+ */
+export const CODEX_SEEN_MS = 60 * 60_000;
+
+/**
+ * "AN AGENT WAS SEEN", FOR CODEX TOO (w-1116fbb68a, 2026-10-08).
+ *
+ *  `agent_seen` listed Claude Code processes and nothing else, and about a
+ *  third of the people on this app are on Codex, so whether they had an agent
+ *  at all was read off proxies: a run this app started, or a reply. The threads
+ *  are already in hand once a minute for the mirror refresh, so this costs
+ *  nothing beyond the comparison.
+ *
+ *  NOTHING ABOUT A THREAD IS SENT. Not its folder, not its title, not its id,
+ *  which is only ever compared inside this process. `engine` is the whole of
+ *  the payload and it is one of two fixed words.
+ *
+ *  ONCE PER THREAD PER RUN OF THE APP, for the reason the Claude side keeps a
+ *  set: this reads the same conversations every minute, so without it one
+ *  conversation would send an event a minute all day.
+ */
+export function noticeCodexAgents(threads, { count = null, seen = null, now = Date.now() } = {}) {
+  if (typeof count !== 'function') return 0;
+  let sent = 0;
+  for (const t of threads ?? []) {
+    const id = String(t?.id ?? '');
+    if (!id) continue;
+    const at = Number(t.lastActive ?? 0);
+    if (!t.live && !(at > 0 && now - at < CODEX_SEEN_MS)) continue;
+    if (seen) {
+      if (seen.has(id)) continue;
+      seen.add(id);
+    }
+    // A count is never worth the watch: the mirror refresh below is what
+    // somebody actually sees, and it runs whatever the switch does.
+    try { count('agent_seen', { engine: 'codex' }); } catch { /* nothing */ }
+    sent += 1;
+  }
+  return sent;
+}
+
+export function scanCodex({ store, readThreads = readCodexThreads, now = Date.now(), count = null, seen = null } = {}) {
   let threads = [];
   try { ({ threads } = readThreads({ now })); } catch { return { refreshed: 0, retold: 0, threads: 0 }; }
+  noticeCodexAgents(threads, { count, seen, now });
   const refreshed = store.refreshCodexMirrors(threads, { now });
   const retold = store.refreshCodexAsks(threads, { now });
   return { refreshed, retold, threads: threads.length };
 }
 
-export function startCodexWatch({ store, readThreads = readCodexThreads, pollMs = CODEX_POLL_MS, firstDelayMs = 8_000 } = {}) {
+export function startCodexWatch({ store, readThreads = readCodexThreads, pollMs = CODEX_POLL_MS, firstDelayMs = 8_000, count = null } = {}) {
+  // Conversations this run has already counted. In memory on purpose, exactly
+  // as the Claude side's set is: a fresh launch seeing the same conversation
+  // again is a fresh fact about the app being used.
+  const seen = new Set();
   const run = () => {
-    try { scanCodex({ store, readThreads }); } catch (e) { console.warn('codex watch:', e?.message ?? e); }
+    try { scanCodex({ store, readThreads, count, seen }); } catch (e) { console.warn('codex watch:', e?.message ?? e); }
   };
   const first = setTimeout(run, firstDelayMs);
   const timer = setInterval(run, pollMs);

package/main/config.mjs

@@ -10,6 +10,7 @@ import path from 'node:path';
 import os from 'node:os';
 import crypto from 'node:crypto';
 import { resolveClaudeBin, candidatePaths } from './claude-bin.mjs';
+import { warmShellAnswers } from './engine-bin.mjs';
 import { resolveCodexBin } from './codex-bin.mjs';
 import { defaultStoreRoot } from './store/home.mjs';
 import { readPlans, slotsForPlans } from './claude-plan.mjs';
@@ -63,6 +64,11 @@ const DEFAULTS = {
   // many times "Something felt slow" has been pressed, and only ever subtracts.
   agentsAuto: true,
   agentsNudge: 0,
+  // THE NUMBER PICKED ON THE MENU, FOR THE WHOLE COMPUTER (w-ec27ff1a51). Null
+  // until somebody picks one. It replaced `maxConcurrentSessions` as the thing
+  // the menu writes, because that one was per login: two logins turned a 7 into
+  // 14 agents on a 16 GB Mac, which then ran out of memory.
+  agentsAtOnce: null,
   // HOLD HEAVY WORK WHEN MEMORY IS SHORT (w-3958c3753d). Off until somebody
   // turns it on from the Agents page. With it on, every shell command a worker
   // runs asks main/memory-gate-server.mjs first, and heavy ones wait their turn
@@ -205,6 +211,14 @@ export function loadConfig(appDir, { home = os.homedir() } = {}) {
   config.claudeBinConfigured = typeof overrides.claudeBin === 'string' && overrides.claudeBin
     ? overrides.claudeBin
     : null;
+  // ONE LOGIN SHELL FOR BOTH ENGINES, ASKED BEFORE EITHER SEARCH RUNS. This is
+  // on the boot path -- main/main.mjs calls loadConfig inside createWindow and
+  // before the window exists -- and a login shell costs about 0.7 s to start
+  // whether it is asked about one program or six. Measured on this Mac
+  // 2026-10-11, the two searches together took 1.4 s cold and the shell was all
+  // of it. It seeds only what it positively found, so a shell that will not
+  // start leaves both searches exactly as they were (main/engine-bin.mjs).
+  warmShellAnswers();
   const claude = resolveClaudeBin(config.claudeBinConfigured);
   config.claudeBin = claude.path ?? candidatePaths()[0];
   config.claudeFound = claude.found;
@@ -281,10 +295,18 @@ export function loadConfig(appDir, { home = os.homedir() } = {}) {
   // same thing said out loud and kept up to date. An explicit `agentsAuto`
   // outranks the guess, because turning Automatic back on after setting a number
   // has to be possible.
-  if (typeof overrides.agentsAuto !== 'boolean') {
-    config.agentsAuto = typeof overrides.maxConcurrentSessions !== 'number';
-  }
-  if (typeof overrides.maxConcurrentSessions !== 'number') {
+  //
+  // ONLY A NUMBER FOR THE WHOLE COMPUTER IS A CHOICE (w-ec27ff1a51). A
+  // `maxConcurrentSessions` in the file was written per login, by the stepper
+  // that was here before 5 Oct, and reading it as "you set this" is what ran
+  // 14 agents on a Mac Automatic would have run 6 on, with nobody having picked
+  // 14. So that install goes back to Automatic, even with `agentsAuto: false`
+  // written beside it, and a number picked on today's menu (`agentsAtOnce`)
+  // is kept as picked unless Automatic was chosen after it.
+  config.agentsAuto = typeof overrides.agentsAtOnce !== 'number' || overrides.agentsAuto === true;
+  // And the plan is read whenever the number is Automatic's, old per-login
+  // number or not, so a plan that allows one at a time still says so.
+  if (typeof overrides.agentsAtOnce !== 'number') {
     const plans = readPlans(effectiveProfiles(config.authProfiles, { home }), { home });
     const slots = slotsForPlans(plans, config.machineSlots);
     config.maxConcurrentSessions = slots;