agentbox-app 0.1.11 → 0.1.13

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,8 +10,9 @@ 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 { Name } from '../shared/product-name.mjs';
+import { defaultStoreRoot } from './store/home.mjs';
 import { readPlans, slotsForPlans } from './claude-plan.mjs';
 import { machineSlots } from './machine.mjs';
 import { effectiveProfiles } from './account-discovery.mjs';
@@ -34,14 +35,6 @@ const CONFIG_NAME = 'zero.config.json';
 export const DEFAULT_SESSIONS_AT_ONCE = 3;
 
 const DEFAULTS = {
-  // Where the inbox's own files live. WHICH FOLDER THIS SHOULD BE ON A
-  // STRANGER'S MAC IS NOT DECIDED HERE: it is the open question on.
-  //
-  // IT IS THE APP'S OWN NAME SINCE 2026-09-22, where it used to be an older
-  // product's. A real store is always named in the config, so this default is
-  // only ever the answer for an install carrying none, and renaming it moved
-  // no files: the folder it used to point at is untouched and still on disk.
-  storeRoot: path.join(os.homedir(), Name),
   // ONE ACCOUNT FOLDER PER INSTALL, AND NOBODY ELSE'S.
   //
   // This was a literal id for most of the app's life, which meant every copy
@@ -71,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
@@ -160,6 +158,19 @@ export function loadConfig(appDir, { home = os.homedir() } = {}) {
     else console.warn(`zero: could not read ${file}: ${err.message}`);
   }
   const config = { ...DEFAULTS, ...overrides, freshInstall: fresh };
+  // Where the inbox's own files live, when the file names no store. A path in
+  // the file always wins, including on Linux. The default is computed here, not
+  // at import: on Linux it is the XDG data directory, and on macOS a folder of
+  // the app's name. An import-time path cannot see the `home` a test passes,
+  // and it cannot see a blanked XDG_DATA_HOME.
+  //
+  // A stand-in home does not inherit this machine's XDG_DATA_HOME. That
+  // variable is an absolute path in the real home, and a throwaway asked with
+  // `{ home }` would otherwise open the real store.
+  if (typeof overrides.storeRoot !== 'string' || !overrides.storeRoot.trim()) {
+    const real = path.resolve(home) === path.resolve(os.homedir());
+    config.storeRoot = defaultStoreRoot({ home, env: real ? process.env : {} });
+  }
   // An older alias for `storeRoot` was read here until 2026-09-22. A config
   // still carrying only the old key falls through to the default now, which is
   // why the key was renamed in zero.config.json in the same step and not after
@@ -200,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;
@@ -276,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;