agentbox-app 0.1.11 → 0.1.12

package/README.md

@@ -39,11 +39,17 @@ There are two ways to run it: in the browser, or as a Mac app. Both need Node 22
 npx agentbox-app
 ```
 
-It starts on your machine and opens a tab. Nothing is hosted: it listens only
-on your own computer, and the address carries a key that is new every run. Add
-`--help` to see the options.
+It starts on your machine and opens a tab. On Linux that open goes through `xdg-open`. Nothing is hosted: it listens only on `127.0.0.1`, and the address carries a key that is new every run. Add `--help` to see the options. `--no-open` prints the address and leaves the browser to you.
 
-**As a Mac app.** Build it from this repo:
+From a checkout, build the screen once, then start it the same way:
+
+```
+npm install
+npm run build
+npx agentbox-app
+```
+
+**As a desktop app.** Build it from this repo. `npm start` is the desktop command on Omarchy and on a Mac:
 
 ```
 git clone https://github.com/savannahfeder/agentbox.git
@@ -52,11 +58,11 @@ npm install
 npm start
 ```
 
-`npm start` builds the app and opens it. On first run it walks you through
-connecting Claude Code or Codex and choosing a folder to work in.
+On Linux, `npm install` puts `agentbox` on `~/.local/bin` and adds the app to the launcher. The entry is `$XDG_DATA_HOME/applications/agentbox.desktop` (`~/.local/share/applications` when that variable is unset), and it runs `agentbox`. That command starts this checkout. Open the app from the launcher.
+
+`npm start` builds the app and opens it. On first run it walks you through connecting Claude Code or Codex and choosing a folder to work in.
 
-macOS may ask to let Terminal find devices on your local network. Agentbox
-does not need that, so Don't Allow is fine.
+On macOS, the system may ask to let Terminal find devices on your local network. Agentbox does not need that, so Don't Allow is fine.
 
 ## The chat window is the bottleneck
 
@@ -130,7 +136,7 @@ asked. Code changes open right beside the row.
 Twenty agents means twenty things competing for your attention and for a limited
 number of running sessions. Agentbox keeps one order and uses it for both.
 
-- **Tag a task** Urgent, High, Medium or Low, when you file it or later from `⌘K`.
+- **Tag a task** Urgent, High, Medium or Low, when you file it or later from `⌘K` or `Ctrl+K`.
 - **Rank your projects** once by dragging them into order. A project's place
   counts for more than any single task's tag, so your most important project
   never waits behind a side one.
@@ -146,7 +152,7 @@ number of running sessions. Agentbox keeps one order and uses it for both.
 
 <p align="center">
   <img src="docs/readme/priority-palette.png" alt="The command palette showing Priority Urgent, High, Medium and Low for the selected row" width="60%"><br>
-  <sub>Any row's priority is a <code>⌘K</code> away.</sub>
+  <sub>Any row's priority is a <code>⌘K</code> or <code>Ctrl+K</code> away.</sub>
 </p>
 
 ## Built for the keyboard
@@ -164,10 +170,10 @@ number of running sessions. Agentbox keeps one order and uses it for both.
 | `L` | Later: put a task off until a time you pick |
 | `S` | Show or hide the summary, in an open task |
 | `Z` | Undo |
-| `⌘K` | Everything else |
+| `⌘K` or `Ctrl+K` | Everything else |
 
 Fifteen skins, each in light and dark, from plain slate to woodblock and riso
-prints. Press `⌘K` and type "theme".
+prints. Press `⌘K` or `Ctrl+K` and type "theme". `Ctrl+K` is the same palette on Linux, where there is no Command key.
 
 ## Runs on the plan you already have
 
@@ -191,8 +197,10 @@ nothing new to pay for.
 default works unset and they all live in `main/config.mjs`. The ones that
 matter:
 
-- `storeRoot`: where the store lives. Defaults to a folder named after the app
-  in your home directory.
+- `storeRoot`: where the store lives. On macOS this defaults to a folder
+  named after the app in your home directory. On Linux it defaults to
+  `$XDG_DATA_HOME/agentbox`, which is `~/.local/share/agentbox` when that
+  variable is unset.
 - `claudeBin`: the binary to run. The app finds `claude` itself if you leave
   this alone.
 - `maxConcurrentSessions`: how many agents run at once. The queue absorbs the
@@ -311,8 +319,8 @@ picks which coding agents the fixture Mac has, where nothing is one agent,
 or `?engines=codex` give two.
 
 To open the app as somebody who has never seen it, with its own throwaway home
-and nothing of yours inside it, press `⌘K` and choose "Open Agentbox as a new
-user". `npm run fresh` does the same from a terminal.
+and nothing of yours inside it, press `⌘K` or `Ctrl+K` and choose "Open Agentbox as a new
+user". `npm run fresh` does the same from a terminal. `ZERO_NO_SUPERVISOR=1` applies to `npm start` and to `npx agentbox-app`.
 
 The app is named in exactly one place, `shared/product-name.mjs`. Change it
 there and run `node scripts/product-name.mjs --write`, and everything else

package/bin/agentbox.mjs

@@ -12,11 +12,11 @@
 
 import path from 'node:path';
 import fs from 'node:fs';
-import os from 'node:os';
 import { spawn } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
 
 import { bootHeadless, createServer, newToken } from '../main/serve.mjs';
+import { appHome } from '../main/store/home.mjs';
 
 const here = path.dirname(fileURLToPath(import.meta.url));
 const appDir = path.dirname(here);
@@ -43,9 +43,13 @@ if (args.includes('--help') || args.includes('-h')) {
 
 // WHERE THE STORE LIVES. A copy run out of npm has no folder of its own to
 // write into, and writing inside node_modules would be thrown away by the next
-// install. `~/.agentbox` is the plain answer and `--dir` is the escape hatch.
+// install. The default is appHome(): a dot-folder already on disk, else the
+// XDG data directory on Linux and `~/.agentbox` on macOS, where this command
+// has always kept it. Not the desktop config's default, which on macOS is
+// `~/Agentbox` and would open every existing Mac user on an empty inbox.
+// `--dir` and AGENTBOX_HOME are the escape hatches.
 const dataDir = path.resolve(
-  flag('dir', process.env.AGENTBOX_HOME ?? path.join(os.homedir(), '.agentbox')),
+  flag('dir', process.env.AGENTBOX_HOME ?? appHome()),
 );
 fs.mkdirSync(dataDir, { recursive: true });
 
@@ -56,12 +60,17 @@ if (!fs.existsSync(path.join(dist, 'index.html'))) {
 }
 
 const booted = await bootHeadless({ dataDir, appDir, userDir: dataDir });
-// Whoever was signed in to the team last time is signed in again.
-booted.team?.start().then(() => booted.supervisor.wake?.()).catch((err) => console.warn(`team: ${err.message}`));
-// AND THE AGENTS' CLOCK, as the desktop starts it (main/main.mjs). Without it a
-// tab only moved work when something woke the supervisor: a queued thread sat
-// queued and a scheduled one never fired (found 2026-10-01 on a test copy).
-booted.supervisor.start();
+// ZERO_NO_SUPERVISOR: the desktop already honors this (main/main.mjs). This
+// entry is the same inbox, so a launch that asks for no agents must not start
+// them here either.
+if (!process.env.ZERO_NO_SUPERVISOR) {
+  // Whoever was signed in to the team last time is signed in again.
+  booted.team?.start().then(() => booted.supervisor.wake?.()).catch((err) => console.warn(`team: ${err.message}`));
+  // AND THE AGENTS' CLOCK, as the desktop starts it (main/main.mjs). Without it a
+  // tab only moved work when something woke the supervisor: a queued thread sat
+  // queued and a scheduled one never fired (found 2026-10-01 on a test copy).
+  booted.supervisor.start();
+}
 const token = newToken();
 const server = createServer({
   channels: booted.channels,

package/briefs/message-rules.md

@@ -59,10 +59,21 @@ opens beside the message by itself. Not the source files you edited, which are
 no use to them.
 
 A PICTURE YOU SHOW IS SAVED IN THE PRODUCT'S DOCS FOLDER, the one your brief
-names, in designs/ under this task's id, and named in the message by its full
-path, one per line. The app draws it where you name it. Not in your code
-checkout, which is deleted once the work ships, and never in /tmp, which the
-app will not draw at all.
+names, in designs/ under this task's id, and named by its full path. Not in
+your code checkout, which is deleted once the work ships, and never in /tmp,
+which the app will not draw at all.
+
+WHAT THE APP CAN SHOW, so you can lay out what you made the way it reads best:
+- A picture's path, anywhere in the message, is drawn right there at full
+  width, and a click opens it. It is drawn as a block, so inside a sentence or
+  a bullet it splits the line.
+- A folder's path on a line of its own draws its newest six pictures as a grid.
+- An html page in designs/ opens beside the message by itself, so one page can
+  set several options side by side with notes on each.
+- A sound or a film plays where it is named; a localhost address opens beside
+  the message. Headings, lists, tables and bold all draw.
+The arrangement is yours. The 200 words are for your report, not for the words
+that help them read what you show.
 
 Steps they must take are a numbered list, five at most, the first one doable now.
 

package/main/account-tooling.mjs

@@ -198,7 +198,8 @@ function list(names) {
 const identityCache = new Map();
 
 export function accountIdentity(dir, { home = os.homedir() } = {}) {
-  const file = path.join(dir || defaultClaudeHome(home), '.claude.json');
+  let file = path.join(dir || defaultClaudeHome(home), '.claude.json');
+  if (!dir && !fs.existsSync(file)) file = path.join(home, '.claude.json');
   // Cached on the file's own mtime rather than on a timer. That file is ~120 KB
   // on this machine and the settings page re-reads on every poll, so parsing it
   // each time would be real work for an answer that changes about twice a

package/main/agent-updates.mjs

@@ -6,6 +6,7 @@ import path from 'node:path';
 import {execFile} from 'node:child_process';
 import {promisify} from 'node:util';
 import {TaskTerminals,terminalEnv} from './task-terminals.mjs';
+import {codexLaunchEnv} from './codex-launch-env.mjs';
 const exec=promisify(execFile);
 const valid=v=>typeof v==='string'&&/^\d+\.\d+\.\d+$/.test(v);
 export function newerVersion(installed,latest){
@@ -34,7 +35,8 @@ export async function installedAgent(engine,config){
  if(!bin)throw Error('This agent is not installed.');
  const home=config.home||os.homedir();
  const settings=engine==='claude'?json(path.join(process.env.CLAUDE_CONFIG_DIR||path.join(home,'.claude'),'settings.json')):{};
- const env=terminalEnv();
+ const cleanEnv=terminalEnv();
+ const env=engine==='codex'?codexLaunchEnv(bin,cleanEnv):cleanEnv;
  // Version inspection must not itself auto-update anything.
  const {stdout}=await exec(bin,['--version'],{timeout:8000,maxBuffer:16384,env:{...env,DISABLE_AUTOUPDATER:'1'}});
  const version=stdout.match(/\b\d+\.\d+\.\d+(?:-[\w.-]+)?\b/)?.[0];

package/main/approvals.mjs

@@ -387,12 +387,20 @@ const REQUEST_SUFFIX = '.request.json';
  * FORWARD to now. A worker can therefore make its own request look younger than
  * it is, which costs it the front of the stack, and can never make it look
  * older. Nanoseconds because APFS keeps them and two files written back to back
- * differ by about 170 microseconds; equal stamps keep `readdir` order, which is
- * as good as anything when two things really did happen at once.
+ * differ by about 170 microseconds.
+ *
+ * A coarse clock stamps both files the same. tmpfs does this: two writes in
+ * one poll share a ctime, and `readdir` then comes back in name order, which
+ * is the forgery the paragraph above is about. The inode breaks that tie.
+ * The kernel assigns it, a later create in a fresh directory gets a higher
+ * one, and a worker cannot move it backwards. Equal inode and equal ctime
+ * keep the order we already had.
  */
 function bornAt(dir, name) {
-  try { return fs.lstatSync(path.join(dir, name), { bigint: true }).ctimeNs; }
-  catch { return 2n ** 63n; } // gone or unreadable: never in front of something real
+  try {
+    const st = fs.lstatSync(path.join(dir, name), { bigint: true });
+    return { ctime: st.ctimeNs, ino: st.ino };
+  } catch { return { ctime: 2n ** 63n, ino: 2n ** 63n }; } // gone or unreadable: never in front of something real
 }
 
 export function listPending(storeRoot, { now = Date.now } = {}) {
@@ -409,7 +417,8 @@ export function listPending(storeRoot, { now = Date.now } = {}) {
   for (const { f } of names
     .filter((f) => !seenAt.has(prefix + f.slice(0, -REQUEST_SUFFIX.length)))
     .map((f) => ({ f, born: bornAt(dir, f) }))
-    .sort((a, b) => (a.born < b.born ? -1 : a.born > b.born ? 1 : 0))) {
+    .sort((a, b) => (a.born.ctime < b.born.ctime ? -1 : a.born.ctime > b.born.ctime ? 1
+      : a.born.ino < b.born.ino ? -1 : a.born.ino > b.born.ino ? 1 : 0))) {
     seenAt.set(prefix + f.slice(0, -REQUEST_SUFFIX.length), { at, seq: sightings += 1 });
   }
   const present = new Set();

package/main/claude-bin.mjs

@@ -71,6 +71,7 @@ export function candidatePaths(home = os.homedir()) {
     path.join(home, '.npm-packages/bin/claude'), // actually write in a guide
     path.join(home, '.yarn/bin/claude'),     // yarn global
     path.join(home, 'Library/pnpm/claude'),  // pnpm's own bin on macOS
+    path.join(home, '.local/share/pnpm/claude'), // pnpm's own bin on Linux
     path.join(home, '.deno/bin/claude'),     // deno
     path.join(home, 'bin/claude'),           // a hand-rolled ~/bin on PATH
     '/opt/local/bin/claude',                 // MacPorts

package/main/claude-plan.mjs

@@ -95,13 +95,25 @@ export function isMaxTier(raw) {
  *  as it was". */
 export function readPlan(profile, { home = os.homedir(), file = null } = {}) {
   const at = file ?? planFile(profile, home);
-  const none = { known: false, max: false, label: null, tier: null, from: null, file: at };
   let account = null;
   try {
     account = JSON.parse(fs.readFileSync(at, 'utf8'))?.oauthAccount ?? null;
   } catch {
-    return none;
+    return planOfAccount(null, at);
   }
+  return planOfAccount(account, at);
+}
+
+/**
+ * THE SAME ANSWER OFF AN `oauthAccount` SOMEBODY ALREADY HAS IN HAND.
+ *
+ *  Lifted out of `readPlan` so a caller that has read the file for its own
+ *  reasons (main/runs-on.mjs, which also wants to know whether there is a login
+ *  in there at all) does not carry a second copy of the tier ordering. One copy
+ *  of that rule, and the file read stays in one place per caller.
+ */
+export function planOfAccount(account, at = null) {
+  const none = { known: false, max: false, label: null, tier: null, from: null, file: at };
   if (!account || typeof account !== 'object') return none;
   // THE ORDER IS MOST SPECIFIC FIRST. A rate limit tier names the plan AND its
   // size (`max_20x` against `max_5x`), which is the thing worth showing; the

package/main/codex-bin.mjs

@@ -114,6 +114,7 @@ export function candidatePaths(home = os.homedir()) {
     path.join(home, '.npm-packages/bin/codex'), // actually write in a guide
     path.join(home, '.yarn/bin/codex'),
     path.join(home, 'Library/pnpm/codex'),    // pnpm's own bin on macOS
+    path.join(home, '.local/share/pnpm/codex'), // pnpm's own bin on Linux
     path.join(home, '.deno/bin/codex'),
     path.join(home, 'bin/codex'),             // a hand-rolled ~/bin on PATH
     '/opt/local/bin/codex',                   // MacPorts

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/config.mjs

@@ -11,7 +11,7 @@ import os from 'node:os';
 import crypto from 'node:crypto';
 import { resolveClaudeBin, candidatePaths } from './claude-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 +34,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
@@ -160,6 +152,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

package/main/demo.mjs

@@ -34,9 +34,8 @@ import path from 'node:path';
 import { spawn } from 'node:child_process';
 import { DEMO_DOCS, DEMO_ENV, DEMO_PRODUCTS, demoLedgerLines } from '../shared/demo-world.mjs';
 import { prepareHome } from '../shared/fresh-user-home.mjs';
-import { Name } from '../shared/product-name.mjs';
 import { relaunchCommand } from './fresh-user.mjs';
-import { encodeProjectPath, storeRootEnv } from './store/home.mjs';
+import { defaultStoreRoot, encodeProjectPath, storeRootEnv } from './store/home.mjs';
 import { NAME, nameSlug } from '../shared/product-name.mjs';
 
 /**
@@ -87,22 +86,21 @@ export function clearDemoHomes() {
 /**
  * Where the demo copy will keep its store, and where it will keep its own
  *  records. Both are derived from the throwaway home rather than configured,
- *  because the copy derives them the same way from the same home: `storeRoot`
- *  defaults to `<home>/<Name>` (main/config.mjs) and the app's home defaults
- *  to `<home>/.agentbox` (main/store/home.mjs).
+ *  because the copy derives them the same way from the same home. Both are
+ *  `defaultStoreRoot` for that home with no inherited data directory: on
+ *  macOS a folder of the app's name, on Linux the XDG path under the
+ *  throwaway. Passing the machine's XDG_DATA_HOME would seed the demo into
+ *  the real store.
  *
- *  THE FOLDER IS READ FROM THE SAME CONSTANT AS THAT DEFAULT, not spelled out
- *  again. It was the literal 'the app' mirroring what config.mjs then said,
- *  and when that default was renamed on 2026-09-22 this line went on pointing
- *  at the old folder: the demo copy would have written its store to one place
- *  and looked for it in another. Two literals that have to agree is the defect;
- *  one import is the fix. */
+ *  THE FOLDER IS THAT FUNCTION, not a second spelling of it. A literal next
+ *  to the default is how the demo once wrote its store in one place and
+ *  looked for it in another. */
 export function demoPaths(home) {
-  const storeRoot = path.join(home, Name);
+  const storeRoot = defaultStoreRoot({ home, env: {} });
   return {
     storeRoot,
     accountRoot: path.join(storeRoot, 'accounts', DEMO_ACCOUNT),
-    appHome: path.join(home, `.${nameSlug}`),
+    appHome: storeRoot,
   };
 }
 
@@ -192,7 +190,12 @@ export function seedDemoStore(home, { now = Date.now() } = {}) {
  *  standing in an invented store. */
 export function demoEnv(home, env = process.env) {
   const { appHome } = demoPaths(home);
-  return { ...env, HOME: home, CFFIXED_USER_HOME: home, ...storeRootEnv(appHome), [DEMO_ENV]: '1' };
+  const next = { ...env, HOME: home, CFFIXED_USER_HOME: home, ...storeRootEnv(appHome), [DEMO_ENV]: '1' };
+  // The copy's store is defaultStoreRoot of ITS home. The parent's
+  // XDG_DATA_HOME is the real data directory, and leaving it set points the
+  // demo at that directory. The other base directories go for the same reason.
+  for (const key of ['XDG_DATA_HOME', 'XDG_CONFIG_HOME', 'XDG_STATE_HOME', 'XDG_CACHE_HOME']) delete next[key];
+  return next;
 }
 
 /**

package/main/engine-setup.mjs

@@ -23,6 +23,7 @@
 
 import { spawn as nodeSpawn } from 'node:child_process';
 import { terminalEnv } from './task-terminals.mjs';
+import { codexLaunchEnv } from './codex-launch-env.mjs';
 
 const INSTALLERS = {
   claude: { shell: '/bin/bash', url: 'https://claude.ai/install.sh', pipe: 'bash' },
@@ -57,7 +58,8 @@ function realSpawn(file, args, { env, onData, keepStdin = false } = {}) {
   let child;
   try {
     child = nodeSpawn(file, args, { env, stdio: [keepStdin ? 'pipe' : 'ignore', 'pipe', 'pipe'] });
-  } catch {
+  } catch (error) {
+    onData?.(`${error.message}\n`);
     return { exit: Promise.resolve(127), kill() {} };
   }
   const feed = (d) => onData?.(String(d));
@@ -65,7 +67,7 @@ function realSpawn(file, args, { env, onData, keepStdin = false } = {}) {
   child.stderr?.on('data', feed);
   const exit = new Promise((resolve) => {
     child.on('exit', (code) => resolve(code ?? 1));
-    child.on('error', () => resolve(127));
+    child.on('error', (error) => { onData?.(`${error.message}\n`); resolve(127); });
   });
   return { exit, kill: () => { try { child.kill('SIGTERM'); } catch { /* already gone */ } } };
 }
@@ -82,6 +84,7 @@ const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
  */
 export function createEngineSetup({ find, spawn = realSpawn, wait = sleep, env = process.env, poll = POLL, onSignIn = () => {} } = {}) {
   const runEnv = terminalEnv(env);
+  const toolEnv = (engine, bin) => engine === 'codex' ? codexLaunchEnv(bin, runEnv) : runEnv;
   const jobs = new Map();
 
   const fresh = (engine) => ({ engine, phase: 'idle', error: null, log: '', running: null, login: null, run: 0 });
@@ -91,20 +94,26 @@ export function createEngineSetup({ find, spawn = realSpawn, wait = sleep, env =
 
   async function signedIn(j, bin) {
     const { file, args } = statusCommand(j.engine, bin);
-    const p = spawn(file, args, { env: runEnv });
+    let output = '';
+    const p = spawn(file, args, { env: toolEnv(j.engine, bin), onData: (d) => { output = (output + String(d).replace(ANSI, '')).slice(-LOG_LIMIT); } });
     const TIMED_OUT = Symbol('no answer');
     const code = await Promise.race([p.exit, wait(STATUS_TIMEOUT).then(() => { p.kill(); return TIMED_OUT; })]);
     // TOLD TO THE APP, which routes on it (w-d5d632e503): a Claude Code that
     // is signed out beside a Codex that is signed in is a Mac that runs on
     // Codex. Only a real yes or no; a check that never answered says nothing.
     if (code === 0 || code === 1) onSignIn(j.engine, code === 0);
-    return code === 0;
+    if (code === 0 || code === 1) return code === 0;
+    if (output) say(j, output);
+    const name = j.engine === 'codex' ? 'Codex' : 'Claude Code';
+    throw new Error(code === TIMED_OUT
+      ? `${name} did not answer the sign-in check. Try again.`
+      : `${name} could not check sign-in: ${lastLine(output) || `exit ${code}`}`);
   }
 
   function startLogin(j, bin) {
     j.login?.kill();
     const { file, args } = signInCommand(j.engine, bin);
-    const login = spawn(file, args, { env: runEnv, keepStdin: true, onData: (d) => say(j, d) });
+    const login = spawn(file, args, { env: toolEnv(j.engine, bin), keepStdin: true, onData: (d) => say(j, d) });
     j.login = login;
     return login;
   }
@@ -130,18 +139,19 @@ export function createEngineSetup({ find, spawn = realSpawn, wait = sleep, env =
     if (!live()) return;
     j.phase = 'signing-in';
     let login = startLogin(j, hit.path);
-    let gaveUp = false;
-    login.exit.then((code) => { if (login === j.login && code !== 0) gaveUp = true; });
+    let ended = false;
+    const watchLogin = (loginProcess) => loginProcess.exit.then(() => { if (loginProcess === j.login) ended = true; });
+    watchLogin(login);
     for (;;) {
       await wait(poll);
       if (!live()) return;
       if (await signedIn(j, hit.path)) { if (live()) ready(j); return; }
       if (j.login !== login) {
         login = j.login;
-        gaveUp = false;
-        login.exit.then((code) => { if (login === j.login && code !== 0) gaveUp = true; });
+        ended = false;
+        watchLogin(login);
       }
-      if (gaveUp) return fail(j, 'The sign-in was closed before it finished.');
+      if (ended) return fail(j, `The sign-in was closed before it finished.${lastLine(j.log) ? ` ${lastLine(j.log)}` : ''}`);
     }
   }
 
@@ -182,12 +192,13 @@ export function createEngineSetup({ find, spawn = realSpawn, wait = sleep, env =
     async readiness(engine) {
       const hit = find(engine);
       if (!hit?.found) return { engine, found: false, signedIn: false };
-      return { engine, found: true, signedIn: await signedIn({ engine }, hit.path) };
+      try { return { engine, found: true, signedIn: await signedIn({ engine, log: '' }, hit.path) }; }
+      catch (error) { return { engine, found: true, signedIn: false, error: error.message }; }
     },
     /** The same question against a path already found, so asking it at
      *  launch does not search the Mac again. */
     signedInNow(engine, bin) {
-      return signedIn({ engine }, bin);
+      return signedIn({ engine, log: '' }, bin).catch(() => false);
     },
   };
 }

package/main/fresh-user.mjs

@@ -96,7 +96,7 @@ export function openFreshUser({
   const notes = [];
   if (withTools && !prepared.claudeBin) notes.push('Claude Code is not at ~/.local/bin/claude, so agents will not run in it.');
   if (!prepared.keychain) notes.push('There is no ~/Library/Keychains here, so Claude Code will say it is not logged in.');
-  if (withAgents && !prepared.agents) notes.push('There is no ~/.claude on this Mac, so it will have no agents to offer.');
+  if (withAgents && !prepared.agents) notes.push('There is no ~/.claude on this computer, so it will have no agents to offer.');
 
   return { ok: true, home: prepared.home, agents: prepared.agents, notes, pid: child?.pid ?? null };
 }

package/main/git-change.mjs

@@ -42,7 +42,10 @@ const MAX_ROWS_PER_FILE = 20_000;
 const NOT_CODE = /(^|\/)(node_modules|\.git)\//;
 
 function git(cwd, args, { maxBuffer = 64 * 1024 * 1024 } = {}) {
-  return execFileSync('git', ['--no-pager', ...args], {
+  // A user's `diff.mnemonicPrefix` rewrites a/ and b/ into c/ i/ o/ w/.
+  // The reader below only knows one prefix. Turn the setting off for this
+  // process so a checkout reads the same on every machine.
+  return execFileSync('git', ['--no-pager', '-c', 'diff.mnemonicPrefix=false', ...args], {
     cwd,
     encoding: 'utf8',
     maxBuffer,
@@ -189,7 +192,10 @@ export function filesFromPatch(patch) {
   const nameOn = (line, side) => {
     const name = line.slice(4).trim();
     if (name === '/dev/null') return null;
-    return name.replace(side === 'old' ? /^a\// : /^b\//, '');
+    // a/ and b/ are the ordinary prefixes. c/ i/ o/ w/ are mnemonicPrefix,
+    // and 1/ 2/ are `git diff --no-index` under that same setting. One
+    // prefix comes off; a file that is itself named `b/foo` stays `b/foo`.
+    return name.replace(/^[abiowc12]\//, '');
   };
   for (const line of String(patch ?? '').split('\n')) {
     if (line.startsWith('diff --git ')) { closeHunk(); file = null; oldName = null; continue; }