agentbox-app 0.1.7 → 0.1.12

package/main/codex-launch-env.mjs

@@ -0,0 +1,31 @@
+// An npm Codex executable starts with `#!/usr/bin/env node`. Finding that
+// executable does not put its Node on a desktop app's launchd PATH.
+// Resolve from disk, without running shell profiles or changing the app's env.
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { candidatePaths, versionedPaths } from './codex-bin.mjs';
+
+function executable(file) {
+  try {
+    fs.accessSync(file, fs.constants.X_OK);
+    return fs.statSync(file).isFile();
+  } catch { return false; }
+}
+
+export function codexLaunchEnv(bin, source = process.env, {
+  home = source.HOME || os.homedir(), exists = executable, readdir,
+} = {}) {
+  if (!bin) return { ...source };
+  const binDir = path.dirname(bin);
+  const inherited = (source.PATH || '').split(path.delimiter).filter(Boolean);
+  // Prefer the Node beside this Codex, then the user's existing PATH. A custom
+  // npm prefix can hold Codex while its Node lives under nvm, fnm, or asdf.
+  const directories = [...new Set([
+    binDir, ...inherited,
+    ...candidatePaths(home).map(path.dirname),
+    ...versionedPaths(home, readdir).map(path.dirname),
+  ])];
+  const nodeDir = directories.find(dir => exists(path.join(dir, 'node')));
+  return { ...source, PATH: [...new Set([binDir, ...(nodeDir ? [nodeDir] : []), ...inherited])].join(path.delimiter) };
+}

package/main/codex-memory-gate.mjs

@@ -0,0 +1,260 @@
+// HOW A CODEX WORKER'S COMMANDS COME TO ASK ABOUT MEMORY — w-e5225b62ba.
+//
+// w-3958c3753d built the whole of the decision (main/memory-gate.mjs), the
+// coordinator (main/memory-gate-server.mjs) and the hook a worker runs
+// (scripts/memory-gate-hook.sh) for Claude Code, and said plainly that Codex
+// workers were not covered. This file is the Codex half, and it is small on
+// purpose: everything measured below says Codex 0.160 presents a PreToolUse
+// hook the way Claude Code does, so the script, the deny and the coordinator
+// are carried over rather than rewritten.
+//
+// MEASURED ON THIS MAC, codex-cli 0.160.0, a real `codex app-server` and real
+// turns, 2026-10-04. Read none of this as documentation; it was all run.
+//
+//   THE PAYLOAD IS CLAUDE CODE'S, FIELD FOR FIELD:
+//     { session_id, turn_id, transcript_path, cwd, hook_event_name: "PreToolUse",
+//       model, permission_mode, tool_name: "Bash",
+//       tool_input: { command }, tool_use_id }
+//   and the deny it reads is the same `hookSpecificOutput.permissionDecision`
+//   object `denyOutput` already prints. A deny blocked the command and our
+//   sentence reached the model verbatim. A hook that slept eight seconds made
+//   the command wait and then run.
+//
+//   THE MATCHER IS "Bash". A group with matcher "shell" listed as trusted and
+//   enabled and never fired once; with no matcher it fired and said its
+//   tool_name was "Bash". That one word was the difference between this working
+//   and silently doing nothing.
+//
+//   THE FILE IS `hooks.json` IN THE CODEX HOME, `{ description?, hooks: {...} }`,
+//   whose event keys are PascalCase (`PreToolUse`) even though Codex's own
+//   errors name them in snake_case. An unknown event key is dropped in silence,
+//   which is why the key is pinned by a test rather than trusted to a comment.
+//
+//   A HOOK ONLY RUNS ONCE TRUSTED, AND TRUST IS PER HOOK. `hooks/list` reports
+//   every hook with a `key`, a `currentHash` and a `trustStatus` of managed /
+//   untrusted / trusted / modified. Writing
+//   `hooks.state."<key>".trusted_hash = <currentHash>` through the app-server's
+//   own `config/batchWrite` turned OURS trusted and left a second hook in the
+//   same file untrusted, with an unrelated `[projects."..."]` table in
+//   config.toml untouched. That is the whole of "do not switch off hook trust
+//   for anyone's other hooks": we never touch the requirement, we satisfy it for
+//   one key. Editing our own command afterwards turned ours "modified" rather
+//   than leaving it trusted, so a hook somebody swapped under us does not
+//   inherit what we wrote.
+//
+// WHY THE ITEM IS NOT IN THE ENVIRONMENT, which is the one real difference from
+// the Claude side. A Claude worker is a process per work item, so `memoryGateEnv`
+// puts the item on it. ONE app-server serves every Codex thread of a login, so
+// there is one environment for all of them and an item id on it would label
+// every thread as whichever row started first. The thread names itself instead:
+// `session_id` in the payload is the app-server's own `thread.id`, which
+// main/codex.mjs already keeps as `session.sessionId`. The lookup lives in
+// main/memory-gate-server.mjs (`ownerOf`).
+
+import fsNode from 'node:fs';
+import path from 'node:path';
+
+/** What Codex calls the tool that runs a shell command. Measured, not guessed. */
+export const CODEX_MATCHER = 'Bash';
+
+/** The file in a Codex home that holds its hooks. */
+export const HOOKS_FILE = 'hooks.json';
+
+/** The two events Codex has that we want. There is no PostToolUseFailure. */
+export const CODEX_EVENTS = ['PreToolUse', 'PostToolUse'];
+
+/** How we know a hook in somebody's file is one of ours. */
+const OUR_SCRIPT = 'memory-gate-hook.sh';
+
+/**
+ * Whether a hook's command is one we wrote. It has to be the script ITSELF and
+ * not a file whose name merely starts the same way, or turning the switch off
+ * would delete `memory-gate-hook.sh.backup` out of somebody's config.
+ */
+export function hookIsOurs(command) {
+  if (typeof command !== 'string') return false;
+  return new RegExp(`${OUR_SCRIPT}'?\\s+(pre|post)\\s*$`).test(command.trim());
+}
+
+/** A path inside a single-quoted shell word, app bundles and apostrophes included. */
+function quoted(scriptPath) {
+  return `'${String(scriptPath).replace(/'/g, `'\\''`)}'`;
+}
+
+/**
+ * Our matcher groups, one per event.
+ *
+ * The pre hook's limit sits above the longest wait the gate will ever impose,
+ * for the reason the Claude side gives: a hook that times out lets its command
+ * run, so the app's own refusal has to arrive first. Codex counts it in seconds.
+ */
+export function ourHookGroups(scriptPath, { maxWaitSec = 20 * 60 } = {}) {
+  const group = (mode, timeout) => ([{
+    matcher: CODEX_MATCHER,
+    hooks: [{ type: 'command', command: `${quoted(scriptPath)} ${mode}`, timeout }],
+  }]);
+  return {
+    PreToolUse: group('pre', maxWaitSec + 600),
+    PostToolUse: group('post', 10),
+  };
+}
+
+/** A hooks.json object, whatever shape the file on disk turned out to be. */
+function asFile(file) {
+  const base = file && typeof file === 'object' && !Array.isArray(file) ? { ...file } : {};
+  base.hooks = base.hooks && typeof base.hooks === 'object' && !Array.isArray(base.hooks) ? { ...base.hooks } : {};
+  return base;
+}
+
+/** Every group in `list` that is not one of ours, in the order it was written. */
+function withoutOurGroups(list) {
+  if (!Array.isArray(list)) return [];
+  return list.filter((g) => !(g?.hooks ?? []).some?.((h) => hookIsOurs(h?.command)));
+}
+
+/**
+ * The same hooks.json with our two hooks in it and everything else where it was.
+ *
+ * Ours go LAST so a hook somebody already had keeps running first, and any older
+ * entry of ours is replaced rather than kept beside the new one: the app moves
+ * between versions and a stale absolute path is a worker asking a script that is
+ * not there. Running this twice gives the same file, so turning the switch on
+ * again adds nothing.
+ */
+export function withOurHooks(file, scriptPath, options) {
+  const out = asFile(file);
+  const ours = ourHookGroups(scriptPath, options);
+  for (const event of CODEX_EVENTS) {
+    out.hooks[event] = [...withoutOurGroups(out.hooks[event]), ...ours[event]];
+  }
+  return out;
+}
+
+/**
+ * The same hooks.json with ours taken out, for when the switch goes off. An
+ * event left with nothing in it loses its key entirely, so a file that was only
+ * ever ours reads as a file with no hooks rather than as empty lists.
+ */
+export function withoutOurHooks(file) {
+  const out = asFile(file);
+  for (const event of Object.keys(out.hooks)) {
+    const kept = withoutOurGroups(out.hooks[event]);
+    if (kept.length) out.hooks[event] = kept;
+    else delete out.hooks[event];
+  }
+  return out;
+}
+
+/** A TOML key as `config/batchWrite` wants it: one quoted segment, escaped. */
+function tomlKey(key) {
+  return JSON.stringify(String(key));
+}
+
+/**
+ * The `config/batchWrite` edits that trust our hooks and nothing else.
+ *
+ * Takes either a flat list of hook entries or a whole `hooks/list` answer
+ * (one record per cwd), because the same hook is reported once per cwd and must
+ * be asked for once. A hook already trusted needs nothing; a `managed` one is an
+ * admin's decision and is left alone; a `modified` one is ours whose script
+ * changed with the app, and re-trusting it is the whole reason this runs at every
+ * start rather than once at install.
+ */
+export function ourTrustEdits(answer) {
+  const entries = [];
+  for (const row of Array.isArray(answer) ? answer : []) {
+    if (Array.isArray(row?.hooks)) entries.push(...row.hooks);
+    else if (row?.key) entries.push(row);
+  }
+  const edits = new Map();
+  for (const h of entries) {
+    if (!h?.key || !h?.currentHash) continue;
+    if (!hookIsOurs(h.command)) continue;
+    if (h.trustStatus === 'trusted' || h.trustStatus === 'managed') continue;
+    edits.set(h.key, { keyPath: `hooks.state.${tomlKey(h.key)}.trusted_hash`, mergeStrategy: 'upsert', value: h.currentHash });
+  }
+  return [...edits.values()];
+}
+
+/**
+ * PUT OUR HOOK IN A CODEX HOME, OR TAKE IT OUT, AND TRUST ONLY OUR OWN.
+ *
+ * Runs at every app start while the switch is on, not once at install, because
+ * three things change underneath it: the app's path (a new version moves the
+ * script, and Codex then calls our hook "modified" and stops running it), the
+ * user's own hooks.json (they may add or remove their own entries at any time),
+ * and the home itself (a second Codex login is a second home).
+ *
+ * NOTHING HERE WRITES config.toml. The trust goes through `config/batchWrite`,
+ * which is the call the Codex TUI itself uses, so Codex edits its own file and
+ * every other setting and every other hook's trust survives untouched. Measured
+ * on this Mac: an unrelated `[projects."..."]` table was still there afterwards,
+ * and a second hook in the same hooks.json was still `untrusted`.
+ *
+ * It is all best-effort. A Codex home we cannot write, an app-server that will
+ * not answer, a refused config write: each one means Codex workers run ungated,
+ * which is exactly where they were before this existed. It must never be a
+ * reason the app fails to start.
+ *
+ * @param {object} how
+ * @param {string} how.home The CODEX_HOME to write in.
+ * @param {string} how.scriptPath scripts/memory-gate-hook.sh, unpacked.
+ * @param {boolean} how.on Whether the memory check is on.
+ * @param {(method: string, params: object) => Promise<any>} [how.request] The
+ *   app-server call. Omitted means "write the file, do not try to trust it".
+ * @param {string[]} [how.cwds] Folders to ask `hooks/list` about. A hook in the
+ *   home is listed for any cwd, so one is enough; the app's own folder is used.
+ * @param {object} [how.fs] Injected for tests.
+ * @param {(line: string) => void} [how.log]
+ * @returns {Promise<{wrote: boolean, trusted: number, error: string|null}>}
+ */
+export async function syncCodexMemoryGate({ home, scriptPath, on, request = null, cwds = [], fs = fsNode, log = () => {} }) {
+  const out = { wrote: false, trusted: 0, error: null };
+  if (!home || (on && !scriptPath)) { out.error = 'no codex home'; return out; }
+  const file = path.join(home, HOOKS_FILE);
+
+  // THEIR FILE IS READ BEFORE IT IS WRITTEN, AND A FILE WE CANNOT UNDERSTAND IS
+  // LEFT ALONE. A hooks.json that exists and is not JSON is somebody's own,
+  // broken or newer than us; replacing it to install ours would throw their work
+  // away. Codex workers then run ungated, which is where they already were.
+  let raw = null;
+  try { raw = fs.readFileSync(file, 'utf8'); } catch { raw = null; }
+  let before = null;
+  if (raw !== null && raw.trim()) {
+    try { before = JSON.parse(raw); } catch {
+      out.error = `${file} is not readable JSON, so it was left alone`;
+      log(`memory gate: ${out.error}`);
+      return out;
+    }
+  }
+  // Off, and we were never in it: nothing to do, and no file to create.
+  if (!on && before === null) return out;
+
+  const wanted = `${JSON.stringify(on ? withOurHooks(before, scriptPath) : withoutOurHooks(before), null, 2)}\n`;
+  if (raw !== wanted) {
+    try {
+      fs.mkdirSync(home, { recursive: true });
+      const tmp = `${file}.${process.pid}.tmp`;
+      fs.writeFileSync(tmp, wanted);
+      fs.renameSync(tmp, file);
+      out.wrote = true;
+    } catch (err) {
+      out.error = `could not write ${file}: ${err.message}`;
+      log(`memory gate: ${out.error}`);
+      return out;
+    }
+  }
+  if (!on || typeof request !== 'function') return out;
+
+  // Trust ours. `hooks/list` is what reports the key and the hash Codex computed,
+  // and neither can be worked out from here: the hash is not of the command text.
+  try {
+    const listed = await request('hooks/list', { cwds });
+    const edits = ourTrustEdits(listed?.data ?? listed);
+    if (!edits.length) return out;
+    await request('config/batchWrite', { edits, reloadUserConfig: true });
+    out.trusted = edits.length;
+    log(`memory gate: trusted ${edits.length} Codex hook${edits.length === 1 ? '' : 's'} in ${home}`);
+  } catch (err) { out.error = `could not trust the Codex hook: ${err.message}`; log(`memory gate: ${out.error}`); }
+  return out;
+}

package/main/codex-models.mjs

@@ -27,10 +27,9 @@
 // models (checked against 0.148.0), and even if it did, a picker must never be
 // the reason a login shell is spawned while she is typing.
 //
-// AND NOTHING HERE IS CACHED IN MEMORY, for the reason main/codex-bin.mjs
-// gives about its own stat calls: caching a cheap read is how a screen ends up
-// still saying the old answer after the thing changed underneath it. The CLI
-// rewrites this file whenever its etag moves, and a spawn is not a hot path.
+// A successful model/list refresh now keeps an account-scoped live catalog in
+// memory. Startup and hourly refreshes replace it; before the first success,
+// the CLI-maintained disk cache remains the fallback.
 //
 // ---------------------------------------------------------------------------
 // TWO QUESTIONS, NOT ONE, AND THE 2026-08-26 ORIGINAL ONLY ASKED THE FIRST.
@@ -60,6 +59,12 @@
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
+const liveCatalogs=new Map();
+export function rememberCodexModels(home,models){
+ const rows=models.filter(m=>typeof m.model==='string'&&m.model).map((m,i)=>({slug:m.model,display_name:m.displayName,visibility:m.hidden?'hide':'list',priority:i,default_reasoning_level:m.defaultReasoningEffort,supported_reasoning_levels:(m.supportedReasoningEfforts||[]).map(l=>({effort:l.reasoningEffort,description:l.description}))}));
+ if(rows.length)liveCatalogs.set(home,rows);
+}
+const catalogRows=(home,read)=>liveCatalogs.get(home)??modelRows(read(path.join(home,'models_cache.json')));
 
 /**
  * WHICH CODEX HOME. Her own setting first, then the environment, then the
@@ -93,7 +98,7 @@ export function codexHome({ configured = null, env = process.env, home = os.home
  * supervisor's refusal is built to need a list before it refuses anything.
  */
 export function codexModels({ home = codexHome(), read = readJson } = {}) {
-  return modelRows(read(path.join(home, 'models_cache.json')))
+  return catalogRows(home,read)
     .filter((m) => m.visibility === 'list')
     .sort((a, b) => priorityOf(a) - priorityOf(b))
     .map((m) => ({
@@ -112,7 +117,7 @@ export function codexModels({ home = codexHome(), read = readJson } = {}) {
  * were handed the word, which is a different question from what she may pick.
  */
 export function codexKnownSlugs({ home = codexHome(), read = readJson } = {}) {
-  return new Set(modelRows(read(path.join(home, 'models_cache.json'))).map((m) => String(m.slug)));
+  return new Set(catalogRows(home,read).map((m) => String(m.slug)));
 }
 
 /**
@@ -126,7 +131,7 @@ export function codexKnownSlugs({ home = codexHome(), read = readJson } = {}) {
  * `codexModels`, asked about the other field.
  */
 export function codexModelLevels(slug, { home = codexHome(), read = readJson } = {}) {
-  const cache = read(path.join(home, 'models_cache.json'));
+  const cache = liveCatalogs.has(home)?{models:liveCatalogs.get(home)}:read(path.join(home, 'models_cache.json'));
   if (!cache) return null;
   const row = modelRows(cache).find((m) => m.slug === slug);
   if (!row) return null;

package/main/codex-threads.mjs

@@ -14,11 +14,11 @@
 //                                       events, of which `user_message` and
 //                                       `agent_message` are the two this reads.
 //
-// WHICH THREADS ARE HERS. `thread_source` is `user` for one she typed into,
-// `guardian_review` for Codex's own reviewer of a turn, and `subagent` for a
-// helper a thread spawned. 247 transcripts were touched in the seven days to
-// 09-14; 158 of them were guardians. Without this filter the inbox would offer
-// her four rows for every conversation she had.
+// WHICH THREADS ARE THE USER'S. `thread_source` is `user` for one a person typed
+// into, `guardian_review` for Codex's own reviewer of a turn, and `subagent` for
+// a helper a thread spawned. Guardians are the majority of transcripts, so
+// without this filter the inbox would offer several rows for every real
+// conversation.
 //
 // There is also `~/.codex/state_5.sqlite`, which has everything above in one
 // table. It is not read: Electron ships no sqlite, the file is written live
@@ -26,9 +26,12 @@
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
-import { isScratchFolder, shortFolder, threadTitle } from './agent-sessions.mjs';
+import { RECENT_DAYS, isScratchFolder, shortFolder, threadTitle } from './agent-sessions.mjs';
+import { WAS_SLUGS, nameSlug } from '../shared/product-name.mjs';
 
-export const CODEX_RECENT_DAYS = 7;
+export const CODEX_RECENT_DAYS = RECENT_DAYS;
+/** The originator Codex records for a run this app started (CLIENT_INFO.name), now and before. */
+const OUR_ORIGINATORS = new Set([nameSlug, ...WAS_SLUGS]);
 /** How many day folders the walk opens at most, whatever `days` says. */
 const MAX_DAY_FOLDERS = 40;
 /**
@@ -62,22 +65,38 @@ const numericDesc = (dir) => {
   return names.filter((n) => /^\d+$/.test(n)).sort((a, b) => Number(b) - Number(a));
 };
 
-/** Every transcript in the newest `days` day folders, newest folder first. */
-export function listRolloutFiles(codexDir = codexHome(), { days = CODEX_RECENT_DAYS } = {}) {
+/**
+ * Every transcript in the newest `days` day folders, newest folder first.
+ *
+ *  AND, WITH `since`, EVERY OLDER ONE WRITTEN TO SINCE THEN. Codex files a
+ *  conversation under the day it STARTED, so a thread begun two weeks ago and
+ *  worked in yesterday sits in a folder the newest-`days` walk never opens
+ *  (w-db6f5e331e). Past those folders only a stat is paid per file, and the
+ *  walk still stops at MAX_DAY_FOLDERS. */
+export function listRolloutFiles(codexDir = codexHome(), { days = CODEX_RECENT_DAYS, since = null } = {}) {
   const root = path.join(codexDir, 'sessions');
   const out = [];
   let looked = 0;
   const limit = Math.min(Math.max(1, Number(days) || 1), MAX_DAY_FOLDERS);
+  const reach = since == null ? limit : MAX_DAY_FOLDERS;
   for (const year of numericDesc(root)) {
     for (const month of numericDesc(path.join(root, year))) {
       for (const day of numericDesc(path.join(root, year, month))) {
-        if (looked >= limit) return out;
+        if (looked >= reach) return out;
+        const older = looked >= limit;
         looked += 1;
         const dir = path.join(root, year, month, day);
         let names = [];
         try { names = fs.readdirSync(dir); } catch { names = []; }
         for (const name of names) {
-          if (/^rollout-.*\.jsonl$/.test(name)) out.push(path.join(dir, name));
+          if (!/^rollout-.*\.jsonl$/.test(name)) continue;
+          const file = path.join(dir, name);
+          if (older) {
+            let mtime = 0;
+            try { mtime = fs.statSync(file).mtimeMs; } catch { continue; }
+            if (mtime < since) continue;
+          }
+          out.push(file);
         }
       }
     }
@@ -103,17 +122,17 @@ export function cleanPrompt(text) {
  * WHAT CODEX PUTS IN HER MOUTH. In paginated history mode the user turn is a
  * `response_item` with several `<recommended_plugins>…`,
  * `<environment_context>…`, `<user_instructions>…`. Every one of those opens
- * with an angle-bracket tag on its first line, and nothing she types does.
- * Measured on the thread she screenshotted (2026-09-15): three parts, the
+ * with an angle-bracket tag on its first line, and nothing a person types does.
+ * Measured on a real thread: three parts, the
  * first two injected. */
 export function isInjected(text) {
   const t = String(text ?? '').trimStart();
   const first = t.split('\n')[0] ?? '';
   if (/^<[a-z_]+[^>]*>/i.test(first)) return true;
   // The folder's AGENTS.md, pasted in as "# AGENTS.md instructions for
-  // /path" followed by an <INSTRUCTIONS> block. Measured on the thread she
-  // screenshotted (2026-09-15): it was the second part of her first turn, and
-  // the first read of it printed it as what she asked.
+  // /path" followed by an <INSTRUCTIONS> block. Measured on a real thread: it
+  // was the second part of the first turn, and the first read of it printed it
+  // as what the user asked.
   if (/^#\s*AGENTS\.md instructions/i.test(first)) return true;
   return /^\s*<INSTRUCTIONS>/i.test(t.slice(first.length, first.length + 200));
 }
@@ -142,9 +161,8 @@ const partsOf = (payload) => (Array.isArray(payload?.content) ? payload.content
  *  lines of type `user_message` / `agent_message` with a `message` string.
  *  Paginated writes none of those: the turns are `response_item` lines of type
  *  `message` with a `role` and a `content` array of `input_text`, `input_image`
- *  and `output_text` parts. Measured 2026-09-15 across the seven days before:
- *  all 61 of her own threads were paginated, and the first build read only
- *  legacy, which is why her row said "Codex has not answered yet." */
+ *  and `output_text` parts. Current Codex threads are paginated, and a build
+ *  that read only legacy showed "Codex has not answered yet." on every row. */
 export function readRollout(file) {
   let text = '';
   try {
@@ -177,7 +195,12 @@ export function readRollout(file) {
       meta = {
         id: String(p.session_id ?? p.id ?? '').trim(),
         cwd: String(p.cwd ?? '').trim(),
-        threadSource: typeof p.thread_source === 'string' ? p.thread_source : (typeof p.source === 'string' ? 'user' : 'other'),
+        // A RUN THIS APP STARTED IS NOT HERS TO IMPORT (w-db6f5e331e). Codex
+        // 0.160.0 writes no thread_source, so the line after this would call
+        // every run a person's; its originator is the clientInfo name we hand
+        // Codex, under this name or one the app had before.
+        threadSource: OUR_ORIGINATORS.has(String(p.originator ?? '').toLowerCase()) ? 'agentbox'
+          : typeof p.thread_source === 'string' ? p.thread_source : (typeof p.source === 'string' ? 'user' : 'other'),
         startedAt: Number.isFinite(startedAt) ? startedAt : 0,
       };
       continue;
@@ -227,15 +250,15 @@ export const LIVE_MS = 2 * 60_000;
 export const isLive = (mtime, now = Date.now()) => Number(mtime) > 0 && now - Number(mtime) < LIVE_MS;
 
 /**
- * HER CONVERSATIONS, newest first, in the shape the import card and the
- *  import row both read. One entry per thread she typed into, in a real folder,
+ * 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);
   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 };
-  for (const file of listRolloutFiles(codexDir, { days })) {
+  for (const file of listRolloutFiles(codexDir, { days, since: cutoff })) {
     const r = readRollout(file);
     if (!r) { skipped.unreadable += 1; continue; }
     if (r.threadSource !== 'user') { skipped.notHers += 1; continue; }

package/main/codex-usage-file.mjs

@@ -4,17 +4,17 @@
 // and it is a good one: never spawn anything and never ask OpenAI anything to
 // draw a picture. Codex's figures ride the app-server the fleet is already
 // running and arrive unprompted during a turn. The unstated cost of that rule is
-// that the app only ever learns a number for work POWERUP ITSELF RAN. She runs
-// Codex in its own app all day, so on her Mac the push had never arrived and the
-// panel was empty while her weekly limit sat at 100% used.
+// that the app only ever learns a number for work POWERUP ITSELF RAN. Someone
+// who runs Codex in its own app all day never gets the push, so the panel sits
+// empty while their weekly limit is at 100% used.
 //
 // SO THERE IS A THIRD SOURCE, AND IT BREAKS NEITHER HALF OF THAT RULE. Codex
 // writes every rate-limit report it receives into its own session log under
 // CODEX_HOME, as a `rate_limits` object on the `token_count` events. Reading it
 // starts no process, sends nothing anywhere, and touches no credential: it is a
-// file on her disk that Codex put there. Measured on her Mac 2026-09-18: 1,140
-// such records across her twenty-five most recent sessions, the newest written
-// the same minute she filed the row.
+// file on the disk that Codex put there. A busy Codex home holds hundreds of
+// such records across its most recent sessions, the newest written within
+// the minute.
 //
 // THE PUSH STILL WINS. A live notification is this second's truth and a log is
 // the last thing anybody wrote down, so main/codex-usage.mjs reads this only when
@@ -111,7 +111,7 @@ function tail(file, bytes = TAIL_BYTES) {
  *
  * Lines are walked backwards because the last report is the one that is true. A
  * report carrying no usable window is skipped rather than accepted: Codex emits
- * an all-null snapshot for limit families that do not apply to the account (her
+ * an all-null snapshot for limit families that do not apply to the account (a
  * `premium` family, every field null), and taking one of those would blank a
  * panel that had a real figure a moment earlier.
  */

package/main/codex-usage.mjs

@@ -11,7 +11,7 @@
 // Codex's figures ride the `codex app-server` THE FLEET IS ALREADY RUNNING:
 // they arrive unprompted as `account/rateLimits/updated` during a turn.
 //
-// AND NEVER ASK FOR ONE EITHER (the founder, 2026-09-05). This reader briefly
+// AND NEVER ASK FOR ONE EITHER. This reader briefly
 // also sent an explicit rate-limits read down that pipe whenever its figure
 // went stale. It is deliberately gone, and this paragraph is here so the next
 // reader does not put it back as an obvious improvement.
@@ -96,9 +96,9 @@ export class CodexUsage {
     const limits = codexLimits(this._snapshot);
     if (limits.length) return { limits, at: this._at };
     // NOTHING HAS PUSHED, SO ASK WHAT CODEX ALREADY WROTE DOWN. This is the
-    // whole of: the push only ever arrives for work the app itself ran, and she
-    // runs Codex in its own app, so on her Mac the panel stayed empty while her
-    // weekly limit was full. main/codex-usage-file.mjs is a read of a file
+    // whole of: the push only ever arrives for work the app itself ran, and a
+    // person who runs Codex in its own app would see the panel stay empty
+    // while their weekly limit was full. main/codex-usage-file.mjs is a read of a file
     // under this same CODEX_HOME. It starts no process and sends nothing
     // anywhere, so neither rule above is bent.
     return this._logged();

package/main/codex-watch.mjs

@@ -1,25 +1,25 @@
-// THE WATCH THAT NOTICES A CODEX CONVERSATION AND ASKS.
+// THE WATCH THAT KEEPS AN IMPORTED CODEX CONVERSATION CURRENT.
 //
-// Her pick on 19:53: "ask first". So every minute this reads the conversations
-// she had in Codex this week, and for each one that runs in a folder one of her
-// projects points at and has no row anywhere yet, it files the asking row in
-// that project. It also keeps the rows she said yes to current: when Codex
-// writes another answer, the row's result follows it.
+// Every minute this reads the user's recent Codex conversations and, for each
+// one they already brought in, makes the row follow Codex: when Codex writes
+// another answer, the row's result follows it. An asking row filed before this
+// change is kept true the same way.
 //
-// A conversation in a folder no project points at gets no row here. It is
-// still on the ⌘K import card, under a section that makes the project on the
-// press, which is the card's own way of handling a new folder.
+// IT NO LONGER ASKS ABOUT NEW ONES (w-db6f5e331e, 2026-10-05). It used to file
+// an "Import into ...?" row for every new conversation in a project's folder.
+// 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.
 import { readCodexThreads } from './codex-threads.mjs';
 
 export const CODEX_POLL_MS = 60_000;
 
 export function scanCodex({ store, readThreads = readCodexThreads, now = Date.now() } = {}) {
   let threads = [];
-  try { ({ threads } = readThreads({ now })); } catch { return { asked: 0, refreshed: 0, retold: 0, threads: 0 }; }
-  const asked = store.askAboutCodexThreads(threads, { now });
+  try { ({ threads } = readThreads({ now })); } catch { return { refreshed: 0, retold: 0, threads: 0 }; }
   const refreshed = store.refreshCodexMirrors(threads, { now });
   const retold = store.refreshCodexAsks(threads, { now });
-  return { asked, refreshed, retold, threads: threads.length };
+  return { refreshed, retold, threads: threads.length };
 }
 
 export function startCodexWatch({ store, readThreads = readCodexThreads, pollMs = CODEX_POLL_MS, firstDelayMs = 8_000 } = {}) {