agentbox-app 0.1.11 → 0.1.13

package/main/settings.mjs

@@ -13,18 +13,20 @@
 // the project they belong to instead of in a text editor.
 
 import fs from 'node:fs';
+import { harnessFor } from './harnesses.mjs';
 import os from 'node:os';
 import path from 'node:path';
 import { codexChoiceToOpen, saveConfig } from './config.mjs';
-import { resolveClaudeBin, forgetClaudeBin, INSTALL_URL } from './claude-bin.mjs';
+import { forgetClaudeBin, INSTALL_URL } from './claude-bin.mjs';
 import { AGENT_MODES } from '../shared/agents.mjs';
 import { analyticsKey, diagnosticsOn } from './analytics.mjs';
 import { CLAUDE_PERMISSION_MODES } from '../shared/work-items.mjs';
-import { accountSentence, engineTroubleNote } from '../shared/spawn-trouble.mjs';
+import { accountSentence, engineTroubleNote, refineCause } from '../shared/spawn-trouble.mjs';
 import { readPlan } from './claude-plan.mjs';
 import { effectiveProfiles } from './account-discovery.mjs';
 import { machineSlots, machineNote, autoAgents, MAX_SLOTS } from './machine.mjs';
-import { NAME } from '../shared/product-name.mjs';
+import { shortPath } from './agent-files.mjs';
+import { NAME, Name } from '../shared/product-name.mjs';
 import { autoSlots } from './memory-gate.mjs';
 import { accountIdentity, claudeLoginCommand, duplicateAccountNote, linkAccountTooling, makeClaudeHome } from './account-tooling.mjs';
 import { isEngine } from '../shared/engines.mjs';
@@ -32,7 +34,7 @@ import { codexAccount, codexLoginCommand, makeCodexHome } from './codex-account.
 import { codexDefaultModel, codexModels } from './codex-models.mjs';
 import { CODEX_DEFAULT_MODE, isCodexMode } from '../shared/codex-modes.mjs';
 import { claudeModels } from './claude-models.mjs';
-import { resolveCodexBin, forgetCodexBin, INSTALL_URL as CODEX_INSTALL_URL } from './codex-bin.mjs';
+import { forgetCodexBin, INSTALL_URL as CODEX_INSTALL_URL } from './codex-bin.mjs';
 
 // Her Claude Code sessions in her inbox: all of them, only the ones stopped on
 // a question, or none. One reader, here, so the settings screen and the
@@ -248,13 +250,18 @@ const lineCount = (text) => (text.trim() ? text.trim().split('\n').length : 0);
 // Claude Code: the path, whether it is really there, and where to get it when
 // it is not. One reader, here, so the screen and the config cannot disagree.
 export function claudeState(config) {
-  const found = resolveClaudeBin(config.claudeBinConfigured ?? null);
+  const found = harnessFor('claude').discover(config.claudeBinConfigured ?? null);
   return {
     claudeBin: found.path ?? config.claudeBin,
     claudeFound: found.found,
     // Whether the search got an answer at all.
     claudeCertain: found.certain !== false,
     claudeInstallUrl: INSTALL_URL,
+    // WHETHER SOMEBODY POINTED AT THIS FILE THEMSELVES, which is the one thing
+    // the card cannot work out from the path alone. A chosen path is never
+    // searched around, so the row that offers the search back has to know
+    // (`pointAtEngineBin` below).
+    claudeChosen: found.from === 'settings',
   };
 }
 
@@ -310,7 +317,7 @@ export function recheckClaude(config) {
  * whose unsure state is not checked. Nothing in the app passes it.
  */
 export function codexState(config, where = {}) {
-  const found = resolveCodexBin(config.codexBinConfigured ?? null, where);
+  const found = harnessFor('codex').discover(config.codexBinConfigured ?? null, where);
   return {
     // Empty rather than a path when there is nothing there, which is the same
     // asymmetry `config.codexBin` already keeps (main/config.mjs): a configured
@@ -322,6 +329,8 @@ export function codexState(config, where = {}) {
     // Whether the search got an answer at all.
     certain: found.certain !== false,
     url: CODEX_INSTALL_URL,
+    // Whether somebody pointed at this file themselves. See `claudeState`.
+    chosen: found.from === 'settings',
   };
 }
 
@@ -348,6 +357,87 @@ export function recheckCodex(config) {
   return state;
 }
 
+/* ------------------- POINTING AT IT YOURSELF, AND BACK -------------------- */
+/**
+ * THE WAY OUT OF A SEARCH THAT MISSED, AND IT IS NOT A RELEASE (w-ce8c1a9275).
+ *
+ * The note this came from: "It has a really hard time finding the install on the
+ * person's computer, and we keep having bug reports and then patching that
+ * specific case." Asking the login shell first (main/engine-bin.mjs) covers
+ * every installer a person's own PATH knows about, which is most of them. It
+ * cannot cover a wrapper script somewhere nobody would guess, a tool on a
+ * volume, or a machine whose login shell will not start at all -- and for those,
+ * every fix used to be a path WE ship and a release THEY wait for.
+ *
+ * `claudeBin` in zero.config.json already won over the search and always has.
+ * What was missing is that nobody is told about that file and the app gave no
+ * way to edit it. These two functions are that door, and the second one matters
+ * as much as the first: a wrong choice that could only be undone by hand-editing
+ * a file nobody has heard of is not a door, it is a trap.
+ *
+ * THE REFUSALS ARE MOST OF THE WORK. Each thing refused here was possible by
+ * hand before and each one becomes a spawn that fails once per row, naming a
+ * file nobody meant to name. The sentence comes back to the screen instead.
+ *
+ * NO PATH FROM THE WINDOW IS EVER TRUSTED: main/ipc.mjs opens the picker and
+ * calls this in the same trip, so the only path that reaches here is one the
+ * open panel itself produced. The sibling rule is
+ * tests/where-codex-runs-from-is-not-a-file-a-worker-can-write.test.mjs.
+ */
+const BIN_KEY = { claude: 'claudeBin', codex: 'codexBin' };
+
+/** The sentence, or null when the file really is one we could run. */
+function whyNotAnAgent(chosen) {
+  if (typeof chosen !== 'string' || !path.isAbsolute(chosen)) {
+    return `${Name} needs the file itself, picked from your computer.`;
+  }
+  let stat;
+  try { stat = fs.statSync(chosen); } catch { stat = null; }
+  if (!stat) return `${Name} could not find anything there. It may have moved since.`;
+  if (stat.isDirectory()) return 'That is a folder. Open it and pick the file inside.';
+  try { fs.accessSync(chosen, fs.constants.X_OK); } catch {
+    return 'That file cannot be run, so it is not the one.';
+  }
+  return null;
+}
+
+/**
+ * Take a file somebody picked for one coding agent.
+ *
+ * Written to zero.config.json so it survives a restart AND set on the live
+ * config, because every consumer reads `config.*` per call and a setting that
+ * waits for a relaunch is the same failure as a fix that is not running. The
+ * recheck afterwards is what puts the path the fleet spawns from in step with
+ * it, the same way the Check again button does.
+ */
+export function pointAtEngineBin(config, engine, chosen) {
+  const key = BIN_KEY[engine];
+  if (!key) return { ok: false, say: `${Name} does not know a coding agent called that.` };
+  const why = whyNotAnAgent(chosen);
+  if (why) return { ok: false, say: why };
+  if (!config.appDir) return { ok: false, say: `${Name} has nowhere to save that.` };
+  saveConfig(config, { [key]: chosen });
+  config[`${engine}BinConfigured`] = chosen;
+  const state = engine === 'claude' ? recheckClaude(config) : recheckCodex(config);
+  return { ok: true, state };
+}
+
+/**
+ * Give the choice back, so the search is in charge again. The key is REMOVED
+ * from the file rather than emptied: `saveConfig` reads an explicit undefined as
+ * a deletion, and an empty string left behind would read as a setting that means
+ * something else (main/config.mjs only treats a non-empty string as chosen).
+ */
+export function searchForEngineBin(config, engine) {
+  const key = BIN_KEY[engine];
+  if (!key) return { ok: false, say: `${Name} does not know a coding agent called that.` };
+  if (!config.appDir) return { ok: false, say: `${Name} has nowhere to save that.` };
+  saveConfig(config, { [key]: undefined });
+  config[`${engine}BinConfigured`] = null;
+  const state = engine === 'claude' ? recheckClaude(config) : recheckCodex(config);
+  return { ok: true, state };
+}
+
 export function readSettings({ config, supervisor, store }) {
   const products = store.listProducts();
   const status = supervisor.status();
@@ -379,7 +469,11 @@ export function readSettings({ config, supervisor, store }) {
   // waiting, because a page she chose to open interrupts nobody.
   const troubles = status.accountTrouble ?? {};
   const accounts = (profiles.length ? profiles : ['default']).map((profile) => {
-    const trouble = troubles[profile] ?? null;
+    const plan = readPlan(profile);
+    // A reason filed before an ended subscription had its own name still reads
+    // as an admin's block; the login's file says which it is.
+    const filed = troubles[profile] ?? null;
+    const trouble = filed ? { ...filed, cause: refineCause(filed.cause, plan) } : null;
     const resting = (supervisor._profileCooldown?.[profile] ?? 0) >= now;
     // WHOSE SUBSCRIPTION THIS ROW IS, not merely which folder it lives in.
     // The page named its rows after folders, so nothing on it could tell a
@@ -421,7 +515,7 @@ export function readSettings({ config, supervisor, store }) {
       // Read here rather than kept, because Claude Code refreshes its own
       // profile as it runs and this page is opened by hand a few times a day.
       // `null` when the file cannot be read, and then no screen says anything.
-      plan: (() => { const p = readPlan(profile); return p.known ? { label: p.label, max: p.max } : null; })(),
+      plan: plan.known ? { label: plan.label, max: plan.max } : null,
     };
   });
 
@@ -449,6 +543,10 @@ export function readSettings({ config, supervisor, store }) {
       permission: override ? permissionMode(override) : 'workspace',
       permissionArgs: override ?? null,
       codexMode: config.projectCodexMode?.[product.slug] ?? 'workspace',
+      // THE SUPERVISOR IS ASKED RATHER THAN THE CONFIG FILE, so the page shows
+      // what will actually happen: a tie naming a login that has been signed out
+      // is ignored when work is handed out, and reads 'any' here too.
+      account: supervisor._projectProfile?.(product.slug) ?? 'any',
       instructions,
       running: sessions.filter((s) => s.product === product.slug).length,
     };
@@ -467,7 +565,9 @@ export function readSettings({ config, supervisor, store }) {
     archivedProjects,
     workspace: {
       agentsRunning: !supervisor.paused,
-      sessionsAtOnce: config.maxConcurrentSessions,
+      // The number picked on the menu, for the whole computer, or what is
+      // running as the limit now when nothing was picked.
+      sessionsAtOnce: typeof config.agentsAtOnce === 'number' ? config.agentsAtOnce : status.capacity,
       // AUTOMATIC, AND WHAT IT WORKS OUT TO (w-e5225b62ba). `agentsAuto` is who
       // is deciding; `agentsTotal` is what the whole Mac is running at once,
       // which is the number the page shows, because the per-account one is
@@ -495,6 +595,7 @@ export function readSettings({ config, supervisor, store }) {
       machineNote: machineNote(slotsHere, config.maxConcurrentSessions),
       memoryGate: memoryGateSettings({ config, supervisor }),
       leftovers: leftoverSettings({ config, supervisor }),
+      strayFolders: strayFolderSettings({ supervisor }),
       capacity: status.capacity,
       running: sessions.length,
       model: parseSessionArgs(workspaceArgs).model,
@@ -522,6 +623,9 @@ export function readSettings({ config, supervisor, store }) {
       // ADHD mode: whether the ADHD rules ride under hers (w-5737fe67cf). Off
       // unless she turned it on, so only `true` means on.
       adhdMode: config.adhdMode === true,
+      // The corner tag over other apps (w-dafae58a23). On unless she turned it
+      // off here, which is the only place it turns off for good.
+      cornerTag: config.cornerTag !== false,
       // How much of her own Claude Code goes in her inbox: all / waiting / off.
       // All by default, because the machine nobody has opened this page on is
       // the one with thirteen forgotten sessions on it.
@@ -727,6 +831,24 @@ export function setProjectSetting({ config, supervisor }, { product, key, value
       saveConfig(config, { projectCodexMode: Object.keys(map).length ? map : undefined });
       break;
     }
+    // WHICH CLAUDE LOGIN THIS PROJECT'S AGENTS RUN ON. 'any' is the absence of
+    // an opinion, like 'workspace' above, and it deletes the entry rather than
+    // writing a word: a config file with no `projectAccounts` is the file every
+    // Mac had before this existed.
+    //
+    // AND A NAME THIS MAC CANNOT HONOUR IS REFUSED AT THE DOOR rather than
+    // written and ignored later. The supervisor does ignore one (`_projectProfile`),
+    // because an account can be signed out after the fact, but a pick made
+    // against a list we just read has no excuse to be wrong.
+    case 'account': {
+      const known = effectiveProfiles(config.authProfiles, { home: config.home });
+      if (value !== 'any' && !known.includes(value)) throw new Error(`unknown Claude account: ${value}`);
+      const map = { ...(config.projectAccounts ?? {}) };
+      if (value === 'any') delete map[product];
+      else map[product] = value;
+      saveConfig(config, { projectAccounts: Object.keys(map).length ? map : undefined });
+      break;
+    }
     default:
       throw new Error(`unknown project setting: ${key}`);
   }
@@ -842,7 +964,7 @@ export function memoryGateSettings({ config, supervisor }) {
   if (on) {
     let s = null;
     try { s = supervisor.memoryGateStatus?.() ?? null; } catch {}
-    if (s?.role === 'standby') now = `Another ${NAME} on this Mac is coordinating.`;
+    if (s?.role === 'standby') now = `Another ${NAME} on this computer is coordinating.`;
     else if (s) {
       const heavy = (s.running ?? []).filter((r) => r.holdsSlot).length;
       const waiting = (s.waiting ?? []).length;
@@ -869,6 +991,9 @@ export function memoryGateSettings({ config, supervisor }) {
 export function memoryReading({ config, supervisor }) {
   const out = { heavy: null, waiting: null, pressure: null, usedPct: null, asked: null, waited: null, refused: null };
   if (!config.memoryGate) return out;
+  // The supervisor's own hold on new agents (main/start-hold.mjs), which does
+  // not depend on which copy of the app is coordinating the command queue.
+  try { out.holding = !!supervisor.startHoldStatus?.()?.holding; } catch { out.holding = false; }
   let s = null;
   try { s = supervisor.memoryGateStatus?.() ?? null; } catch { return out; }
   if (!s || s.role === 'standby') return out;
@@ -924,6 +1049,34 @@ export function leftoverSettings({ config, supervisor }) {
   return { on, now };
 }
 
+/**
+ * COPIES OF A PROJECT THE APP DID NOT MAKE, SAID OUT LOUD (w-330eea6c66).
+ *
+ * MEASURED 2026-10-07: thirteen worktrees of one repository sat outside the
+ * folder the app keeps its own in, about 740 MB, and nothing in the app could
+ * list, show or sweep one. That is the same invisibility that stranded 26 GB on
+ * 2026-09-22, and the half that fixes it for a person is being told.
+ *
+ * NO BUTTON, DELIBERATELY. A folder the app did not make is not the app's to
+ * remove: it is the only copy of whatever is uncommitted inside it, and somebody
+ * made it on purpose. So this is a sentence and nothing else, and it is absent
+ * entirely when there is nothing to say, because a row that is usually quiet
+ * trains the reaction it exists to prevent.
+ */
+export function strayFolderSettings({ supervisor }, home = os.homedir()) {
+  let list = [];
+  try { list = supervisor?.strayFolders?.() ?? []; } catch { list = []; }
+  if (!list.length) return null;
+  const count = list.length;
+  const one = count === 1;
+  const projects = [...new Set(list.map((w) => w.project).filter(Boolean))];
+  const named = list.slice(0, 3).map((w) => shortPath(w.path, home));
+  const rest = count - named.length;
+  const of = projects.length ? ` of ${projects.slice(0, 2).join(' and ')}${projects.length > 2 ? ' and other projects' : ''}` : '';
+  const now = `${count} ${one ? 'copy' : 'copies'}${of} ${one ? 'was' : 'were'} made by hand outside the folder ${NAME} keeps its own in, and ${one ? 'is' : 'are'} holding disk until you remove ${one ? 'it' : 'them'}: ${named.join(', ')}${rest > 0 ? ` and ${rest} more` : ''}. ${NAME} never removes a folder it did not make.`;
+  return { count, now };
+}
+
 export function setWorkspaceSetting({ config, supervisor }, { key, value }) {
   switch (key) {
     case 'agentsRunning':
@@ -957,7 +1110,9 @@ export function setWorkspaceSetting({ config, supervisor }, { key, value }) {
       const n = Math.max(1, Math.min(MAX_SLOTS, Math.round(Number(value) || 1)));
       // Setting a number by hand IS taking the decision back, so the page never
       // shows a stepper that the supervisor is quietly ignoring.
-      saveConfig(config, { maxConcurrentSessions: n, agentsAuto: false });
+      // FOR THE WHOLE COMPUTER (w-ec27ff1a51), under its own key, so a number
+      // written per login before 5 Oct can never be read as this choice.
+      saveConfig(config, { agentsAtOnce: n, agentsAuto: false });
       // An explicit choice replaces the startup plan suggestion for BOTH
       // engines. Leaving this marker set makes Codex ignore the new number
       // until loadConfig runs again at restart. It is derived, not persisted.
@@ -1007,6 +1162,11 @@ export function setWorkspaceSetting({ config, supervisor }, { key, value }) {
     case 'adhdMode':
       saveConfig(config, { adhdMode: !!value });
       break;
+    // THE CORNER TAG (w-dafae58a23). Turning it back on also ends any hide, so
+    // the switch does what it says the moment she flips it.
+    case 'cornerTag':
+      saveConfig(config, value ? { cornerTag: true, cornerTagHiddenUntil: 0 } : { cornerTag: false });
+      break;
     // WHICH ACCOUNT HER WORK RUNS ON.
     //
     // ONE KEY HOLDS BOTH ENGINES, because a profile word means different things

package/main/shell-path.mjs

@@ -0,0 +1,86 @@
+// Finder launches inherit launchd's PATH rather than the user's shell tools.
+// Read only PATH: importing a profile's whole environment would import keys
+// and login overrides too. Workers still pass through their billing scrub.
+import { execFile } from 'node:child_process';
+import path from 'node:path';
+
+const MARKER = '\0agentbox-path\0';
+function runShell(file, args, options) {
+  return new Promise((resolve, reject) => {
+    const child = execFile(file, args, options, (error, stdout) => error ? reject(error) : resolve(stdout));
+    child.stdin?.end();
+  });
+}
+
+/**
+ * WHERE THE SHELL SAYS CLAUDE CODE AND CODEX KEEP THEIR SESSIONS (w-e46f2e9cea).
+ *
+ *  An app opened from the Dock, or from a Linux launcher entry, never sees what
+ *  a shell profile exports, so a CLAUDE_CONFIG_DIR or CODEX_HOME set there was
+ *  invisible to the import unless the folder happened to be named
+ *  ~/.claude-<name>. These two names and nothing else are read, the same way
+ *  PATH is above, and they are handed to the session finder rather than put
+ *  into the app's environment: CLAUDE_CONFIG_DIR there would change which
+ *  account every worker runs on.
+ *
+ *  Only an absolute path is kept. A quoted `~` the shell did not expand is
+ *  expanded here; anything else, or no answer at all, is left out. */
+const DIRS_MARKER = '\0agentbox-dirs\0';
+export async function readShellDataDirs({ env = process.env, platform = process.platform, run = runShell } = {}) {
+  if (platform !== 'darwin' && platform !== 'linux') return {};
+  const shell = env.SHELL || (platform === 'darwin' ? '/bin/zsh' : '/bin/sh');
+  try {
+    const stdout = String(await run(shell, ['-ilc', `printf '\\0agentbox-dirs\\0%s\\0%s\\0' "$CLAUDE_CONFIG_DIR" "$CODEX_HOME"`], {
+      env: { ...env }, encoding: 'utf8', timeout: 5000, maxBuffer: 64 * 1024,
+    }));
+    const start = stdout.lastIndexOf(DIRS_MARKER);
+    if (start < 0) return {};
+    const [claude = '', codex = ''] = stdout.slice(start + DIRS_MARKER.length).split('\0');
+    const out = {};
+    const keep = (name, raw) => {
+      let v = String(raw ?? '').trim();
+      if (!v || /[\r\n]/.test(v)) return;
+      if (v === '~' || v.startsWith('~/')) {
+        if (!env.HOME) return;
+        v = path.join(env.HOME, v.slice(1));
+      }
+      if (path.isAbsolute(v)) out[name] = v;
+    };
+    keep('CLAUDE_CONFIG_DIR', claude);
+    keep('CODEX_HOME', codex);
+    return out;
+  } catch {
+    return {};
+  }
+}
+
+/**
+ * What the shell answered, kept for the life of the app. Empty until it
+ *  answers, which is long before setup reaches its last card. */
+let shellDataEnv = {};
+export const shellDataDirsNow = () => shellDataEnv;
+export function learnShellDataDirs(opts) {
+  return readShellDataDirs(opts).then((found) => { shellDataEnv = found; return found; });
+}
+
+export async function recoverShellPath({ env = process.env, platform = process.platform, run = runShell } = {}) {
+  const original = env.PATH || '';
+  if (platform !== 'darwin') return { path: original, error: null };
+  const shell = env.SHELL || '/bin/zsh';
+  const value = path.basename(shell) === 'fish' ? '(string join : $PATH)' : '"$PATH"';
+  try {
+    // NUL framing keeps messages printed by .zshrc out of the returned PATH.
+    const stdout = String(await run(shell, ['-ilc', `printf '\\0agentbox-path\\0%s\\0' ${value}`], {
+      env: { ...env }, encoding: 'utf8', timeout: 5000, maxBuffer: 64 * 1024,
+    }));
+    const start = stdout.lastIndexOf(MARKER);
+    const end = start < 0 ? -1 : stdout.indexOf('\0', start + MARKER.length);
+    const recovered = end < 0 ? '' : stdout.slice(start + MARKER.length, end);
+    if (!recovered || /[\r\n]/.test(recovered)) throw Error('Your shell did not return its command search path.');
+    const entries = [...new Set([...recovered.split(':'), ...original.split(':')].filter(Boolean))];
+    if (!entries.length) throw Error('Your shell returned an empty command search path.');
+    return { path: entries.join(':'), error: null };
+  } catch (error) {
+    return { path: original, error: String(error?.message || error) };
+  }
+}

package/main/ship-queue.mjs

@@ -77,15 +77,17 @@ export const wantsShipping = (item) => labelsOf(item).includes(SHIP_LABEL);
 export const withoutShipLabel = (item) => labelsOf(item).filter((l) => l !== SHIP_LABEL);
 
 /**
- * The next task to ship, oldest ask first, or null.
+ * Every task this queue still owes a ship, whether or not a session is on it.
  *
- * Only a row of a project that ships, marked `ship`, with no session on it
- * (an agent still working may yet commit), and with a task folder to ship from.
+ * A row of a project that ships, marked `ship`, not yet handled for that
+ * marking, and with a task folder to ship from. THE WINDOW READS THIS TOO
+ * (w-0c1ba766eb): a row on this list is waiting on the app, not on a person,
+ * so it is In progress and not Needs you until the queue has dealt with it.
  */
-export function nextToShip(items, products, settings, { isLive = () => false, folderFor, handled = {} }) {
+export function waitingToShip(items, products, settings, { folderFor, handled = {} }) {
   const bySlug = new Map(products.map((p) => [p.slug, p]));
-  const ready = items
-    .filter((i) => wantsShipping(i) && i.status !== 'done' && !isLive(i) && !(markedAt(i) <= (handled[keyOf(i)] ?? -1)))
+  return items
+    .filter((i) => wantsShipping(i) && i.status !== 'done' && !(markedAt(i) <= (handled[keyOf(i)] ?? -1)))
     .map((item) => {
       const product = bySlug.get(item.product);
       const script = product ? shipScriptFor(product, settings) : null;
@@ -93,6 +95,14 @@ export function nextToShip(items, products, settings, { isLive = () => false, fo
       return script && cwd && fs.existsSync(cwd) ? { item, product, script, cwd } : null;
     })
     .filter(Boolean);
+}
+
+/**
+ * The next task to ship, oldest ask first, or null: one the queue owes, with
+ * no session on it (an agent still working may yet commit).
+ */
+export function nextToShip(items, products, settings, { isLive = () => false, folderFor, handled = {} }) {
+  const ready = waitingToShip(items, products, settings, { folderFor, handled }).filter(({ item }) => !isLive(item));
   ready.sort((a, b) => markedAt(a.item) - markedAt(b.item));
   return ready[0] ?? null;
 }
@@ -188,7 +198,7 @@ export function failureReply(output) {
     ...(died ? [
       '',
       'Its test run DIED rather than going red: nothing it printed names a failing',
-      'test. Look for what killed the run. This Mac runs a dozen agents at once, so',
+      'test. Look for what killed the run. This computer runs a dozen agents at once, so',
       'a worker that was starved or timed out is likelier than a bug in your change.',
       'Run the tests for your change again before you go looking for one.',
     ] : []),
@@ -255,6 +265,14 @@ export class ShipQueue {
     return this.busy;
   }
 
+  /** The ids of the rows still waiting on this queue, for the window. */
+  waitingIds(items, products) {
+    const settings = readShipSettings(this.userDir);
+    if (!Object.keys(settings).length) return [];
+    return waitingToShip(items, products, settings, { folderFor: this.folderFor, handled: readHandled(this.userDir) })
+      .map(({ item }) => item.id);
+  }
+
   async ship({ item, product, script, cwd }) {
     this.log.info?.(`zero: shipping ${item.id} from ${cwd}`);
     const { code, out } = await this.run(script, cwd);

package/main/sign-in-files.mjs

@@ -1,3 +1,4 @@
+import { harnessFor } from './harnesses.mjs';
 // THE FILES A LOGIN WRITES, SO THE APP CAN SEE ONE LAND.
 //
 // A signed-out account used to sit out a fixed half hour, and nothing but a
@@ -11,7 +12,7 @@
 // A moved time is a reason to TRY again, not proof; the try is the proof.
 
 import fs from 'node:fs';
-import path from 'node:path';
+
 
 /**
  * Where one account's login is written.
@@ -21,12 +22,7 @@ import path from 'node:path';
  *  - Codex: `auth.json` inside its CODEX_HOME.
  */
 export function signInFiles({ engine = 'claude', folder = null, home }) {
-  if (engine === 'codex') return folder ? [path.join(folder, 'auth.json')] : [];
-  if (!folder) {
-    const dir = path.join(home, '.claude');
-    return [path.join(home, '.claude.json'), path.join(dir, '.claude.json'), path.join(dir, '.credentials.json')];
-  }
-  return [path.join(folder, '.claude.json'), path.join(folder, '.credentials.json')];
+  return harnessFor(engine).signInFiles({ folder, home });
 }
 
 /** The newest modification time among them, or 0 when none can be read. */

package/main/source-updater.mjs

@@ -55,7 +55,13 @@ const SAY = {
 // on this Mac, and the restart below runs that build. Counted as her changes,
 // they made every update after the first say "changes of your own" for good
 // (tests/a-build-does-not-stop-the-next-update.test.mjs).
-const isBuildOutput = (file) => /^shared\/[^/]+\.generated\.[cm]?[jt]s$/.test(file);
+//
+// THE LOCKFILE IS NPM'S, TOO (2026-10-07). The restart's `npm install` rewrote
+// package-lock.json (this npm drops its `libc` lines), and the card never came
+// back while main ran 21 commits ahead. An edit to the dependencies themselves
+// is in package.json, which still blocks
+// (tests/a-package-install-does-not-stop-the-next-update.test.mjs).
+const isBuildOutput = (file) => file === 'package-lock.json' || /^shared\/[^/]+\.generated\.[cm]?[jt]s$/.test(file);
 // The status code is one or two letters and `gitIn` trims the output, which
 // takes the leading space off the first line, so it is matched, not sliced.
 const changedPaths = (porcelain) => String(porcelain ?? '').split('\n').filter(Boolean).map((l) => l.replace(/^[ MADRCUT?!]{1,2} /, '').replace(/^"|"$/g, ''));
@@ -128,6 +134,18 @@ export function createSourceUpdater({
   log = console,
   onChanged = () => {},
   npm = defaultNpm(appDir),
+  // THE STEP `npm start` DOES AND THIS DID NOT. A from-source run gets its
+  // name, icon and bundle id from scripts/brand-electron.mjs, which npm runs
+  // before Electron. An update does not go through npm: it builds and calls
+  // app.relaunch(), which re-executes the same binary. So the branding had
+  // never once run on a self-restart, and a fix to it could sit on disk for
+  // days without reaching the bundle (measured 2026-10-09, with the
+  // Info.plist four days older than the fix meant to change it).
+  // Imported here and not at the top of the file: scripts/ is deliberately not
+  // in the downloadable build (`build.files`, and a test holds it there), and
+  // a static import would stop that build booting at all. This path only ever
+  // runs from source, where the script is on disk.
+  brand = async () => (await import('../scripts/brand-electron.mjs')).brandElectron(),
   relaunch = () => { app?.relaunch(); app?.quit(); },
 } = {}) {
   const git = gitIn(appDir);
@@ -251,12 +269,20 @@ export function createSourceUpdater({
         set({ phase: 'ready', error: `The new packages would not install: ${failureLine(installed.out)}` });
         return;
       }
+      // What the install rewrote goes back, so the folder is left as main has
+      // it and anything else that fast-forwards it cannot trip on the file.
+      await git(['checkout', '--', 'package-lock.json']);
     }
     const built = await npm(['run', 'build']);
     if (built.code !== 0) {
       set({ phase: 'ready', error: `The new code would not build: ${failureLine(built.out)}` });
       return;
     }
+    // Before the relaunch, never after: the next launch is the one that reads
+    // the Info.plist. And never fatally, for the reason brand-electron.mjs
+    // opens with about itself — an app that does not come back up is worse
+    // than one wearing the wrong icon.
+    try { await brand(); } catch (e) { log.warn?.('[source-updater] could not rebrand the bundle:', e?.message ?? e); }
     log.info?.('[source-updater] built', state.newVersion, '- relaunching');
     relaunch();
   }

package/main/start-hold.mjs

@@ -0,0 +1,73 @@
+// NO NEW AGENT STARTS WHILE MEMORY IS SHORT (w-ec27ff1a51).
+//
+// 2026-10-11, a 16 GB Mac ran out of application memory with Agentbox at
+// 22 GB and six agents running. The memory check (main/memory-gate.mjs) held
+// tests and builds back, but nothing asked memory before STARTING an agent, so
+// the fleet filled every slot it had into a Mac that was already short.
+//
+// So while the memory switch is on and the Mac reads tight or very short, a new
+// agent waits. That is the whole rule. Everything else here is a way out of it,
+// because the founder's condition was that urgent work still comes first and
+// that nothing sits stuck for long on a misread:
+//
+//   - NOTHING RUNNING, ONE STARTS. Whatever is filling memory then is not us,
+//     and an app with no agent running at all is broken rather than careful.
+//   - AN URGENT ROW, OR ONE SHE ASKED FOR BY NAME, starts while tight and waits
+//     only while very short: the command gate's rule for urgent commands.
+//   - A SWAP IS NOT A NEW AGENT. A row something was paused for (an Urgent row
+//     taking a lesser session's slot, or Run now) always starts, so urgent work
+//     still takes over while memory is very short, by replacing, not adding.
+//   - A READING THAT IS MISSING, UNREADABLE OR OLDER THAN A MINUTE IS NOT A
+//     REASON TO HOLD. The hold acts only on a reading it actually has.
+//   - TEN MINUTES HELD, ONE STARTS ANYWAY, and the ten minutes start again from
+//     it. A reading stuck on "tight" by mistake costs a slow queue, never a
+//     stopped one.
+//
+// Pure, so every one of those is a test (tests/no-new-agent-starts-while-memory-is-short).
+
+import { execFileSync } from 'node:child_process';
+import { pressureFrom } from './memory-gate.mjs';
+
+/** One reading, synchronously, for the moment before a restart brings the
+ *  fleet back. Nulls (so no hold) when it cannot be read. */
+export function readMacPressureNow() {
+  let level = null;
+  let freePct = null;
+  try {
+    const out = execFileSync('/usr/sbin/sysctl', ['-n', 'kern.memorystatus_vm_pressure_level', 'kern.memorystatus_level'],
+      { timeout: 2_000, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
+    [level, freePct] = out.trim().split(/\s+/).map(Number);
+  } catch { /* not a Mac, or sysctl did not answer */ }
+  return { level: Number.isFinite(level) ? level : null, freePct: Number.isFinite(freePct) ? freePct : null, at: Date.now() };
+}
+
+/** A reading older than this is not acted on. */
+export const STALE_MS = 60_000;
+/** The longest new work waits on memory before one agent starts anyway. */
+export const MAX_HOLD_MS = 10 * 60_000;
+
+/**
+ * Whether one more agent may start now, and why. `reading` is
+ * `{ level, freePct, at }` from `readMacPressure`, stamped when it arrived.
+ * `heldSince` is when the current hold began (null when nothing is held);
+ * `lastStartAt` is when an agent last started.
+ */
+export function startDecision({
+  on, reading, now, running,
+  urgent = false, asked = false, swap = false,
+  lastStartAt = 0, heldSince = null,
+  staleMs = STALE_MS, maxHoldMs = MAX_HOLD_MS,
+}) {
+  if (!on) return { start: true, why: 'off' };
+  if (!(running > 0)) return { start: true, why: 'nothing-running' };
+  if (swap) return { start: true, why: 'swap' };
+  const at = Number(reading?.at);
+  const known = reading && (Number.isFinite(reading.level) || Number.isFinite(reading.freePct));
+  if (!known || !Number.isFinite(at) || Math.abs(now - at) > staleMs) return { start: true, why: 'no-reading' };
+  const pressure = pressureFrom(reading);
+  if (pressure === 'normal') return { start: true, why: 'normal' };
+  if (pressure === 'tight' && (urgent || asked)) return { start: true, why: 'urgent' };
+  const waitingSince = Math.max(heldSince ?? now, Number(lastStartAt) || 0);
+  if (now - waitingSince >= maxHoldMs) return { start: true, why: 'overdue' };
+  return { start: false, why: pressure };
+}