agentbox-app 0.1.7 → 0.1.12

package/main/message-priority.mjs

@@ -0,0 +1,87 @@
+// A MESSAGE FROM A TEAMMATE IS SORTED BY HOW URGENT IT IS (2026-10-01): the
+// agent reads each message and gives it a priority, so the reader does not
+// have to.
+//
+// A message is made with priority 0 and nothing ever moved it, so the inbox's
+// priority sort could not tell "the checkout page is down" from "thanks!". Now
+// the Mac the message waits on asks the same small model the namer uses
+// (main/row-label.mjs) for one of the four levels, once per message, and
+// writes it onto the row as an agent. A level the person set by hand wins, by
+// the fold's own rule, and this does not ask again after one.
+import { askSmallModel } from './row-label.mjs';
+
+/** The four words, onto the app's own values (renderer/src/priority.ts). */
+export const LEVELS = { urgent: 9, high: 7, medium: 5, low: 2 };
+
+const LIVE = new Set(['open', 'claimed', 'blocked']);
+
+/**
+ * PURE. The newest message on a conversation: its words, who wrote it and
+ * when. A reply is the newest when there is one; otherwise the opening body.
+ */
+export function latestMessage(item) {
+  const a = item?.wrote?.answer;
+  const b = item?.wrote?.body;
+  const answered = !!a && !!item?.answer && item.answer !== '(withdrawn)' && (!b || a.ts >= b.ts);
+  const w = answered ? a : b;
+  const text = String((answered ? item.answer : item?.body) ?? '').trim();
+  if (!w || !text) return null;
+  return { text, by: w.by ?? null, ts: w.ts ?? 0 };
+}
+
+/**
+ * PURE. Does this row hold a message for me to sort? Only a conversation that
+ * is still going, waiting on me, whose newest message someone else wrote, and
+ * which has not been sorted since that message. Never one whose priority the
+ * person set by hand: the fold keeps theirs over ours, so asking would only
+ * repeat forever.
+ */
+export function wantsPriority(item, product, me) {
+  if (!me || !item || item.agent) return false;
+  if (!product?.team?.direct) return false;
+  if (!LIVE.has(item.status)) return false;
+  if (item.assignee !== me) return false;
+  const latest = latestMessage(item);
+  if (!latest || !latest.by || latest.by === me) return false;
+  const set = item.wrote?.priority;
+  if (set?.source === 'founder') return false;
+  // AND NEVER OVER THE LEVEL THE SENDER PICKED (w-7ba439c883). A message now
+  // crosses carrying how urgent the person who wrote it thought it was, and a
+  // guess from here would overwrite it: the sender's line is composeItem's, so
+  // it claims no authority the fold would defend, and a level written from here
+  // counts for nothing anyway (an agent's tag, shared/rank.mjs itemPriority).
+  // A row nobody chose a level for is composeItem's 0, so a number above it is
+  // exactly "somebody picked one", and `by` says it was not this Mac.
+  if (set?.by && set.by !== me && Number.isFinite(item.priority) && item.priority > 0) return false;
+  return !(set && set.source !== 'system' && set.ts >= latest.ts);
+}
+
+/** PURE. The one question, about the message alone, cut short. */
+export function priorityPrompt(latest) {
+  const text = String(latest?.text ?? '').replace(/\r/g, '').trim().slice(0, 1500);
+  return [
+    'A teammate sent this message to the person you work for. How soon do they',
+    'need to read it and answer? Reply with one word: urgent, high, medium or low.',
+    '',
+    'urgent: something is broken or blocked now, or it is due within hours.',
+    'high: it needs an answer today.',
+    'medium: an ordinary question or request.',
+    'low: a thank you, an FYI or a social note that needs no answer.',
+    '',
+    '--- message ---',
+    text,
+    '---',
+  ].join('\n');
+}
+
+/** PURE. The model's reply as one of the four words, or '' when it is not one. */
+export function cleanPriority(text) {
+  const first = String(text ?? '').split('\n').map((l) => l.trim()).filter(Boolean)[0] ?? '';
+  const word = first.replace(/^["'`“”‘’]+|["'`“”‘’.!]+$/g, '').trim().toLowerCase();
+  return Object.hasOwn(LEVELS, word) ? word : '';
+}
+
+/** Ask the small model about one message. '' on every failure, never a throw. */
+export function sortMessage(latest, opts = {}) {
+  return askSmallModel(priorityPrompt(latest), cleanPriority, opts);
+}

package/main/notify.mjs

@@ -104,7 +104,7 @@ export function createNotifier({ window, Notification, powerMonitor, coalesceMs
     // two-minute diagnosis.
     n.on('failed', (_e, err) => {
       live = null;
-      console.warn(`zero: macOS refused the notification (${err}). Check ${NAME} in System Settings > Notifications.`);
+      console.warn(`zero: the system refused the notification (${err}). Check ${NAME} in the system notification settings.`);
     });
     live = n;
     try {

package/main/rail-note.mjs

@@ -27,8 +27,8 @@ import path from 'node:path';
 export const NOTE_NAME = 'pinned.md';
 
 // Far past anything a sidebar column can hold, and still small enough that a
-// runaway paste cannot fill her disk. A note that hits this is refused rather
-// than truncated: half her words written back is worse than none.
+// runaway paste cannot fill the disk. A note that hits this is refused rather
+// than truncated: half a note written back is worse than none.
 export const MAX_NOTE_BYTES = 200_000;
 
 /** The file this product's sidebar note lives in, or null if it has no folder. */

package/main/refresh-agent-models.mjs

@@ -0,0 +1,21 @@
+import {spawn} from 'node:child_process';
+import {createCodexAppServer} from './codex-app-server.mjs';
+import {rememberCodexModels} from './codex-models.mjs';
+import {forget,claudeModels} from './claude-models.mjs';
+import {terminalEnv} from './task-terminals.mjs';
+import {codexLaunchEnv} from './codex-launch-env.mjs';
+export async function refreshAgentModels(engine,config,home){
+ if(engine==='claude'){forget();claudeModels({bin:config.claudeBin});return;}
+ // Codex is optional and codexBin is null without it: nothing to ask, and spawn(null) only threw into the terminal.
+ if(!config.codexBin)return;
+ const client=createCodexAppServer({spawn:()=>spawn(config.codexBin,['app-server'],{cwd:config.home,env:codexLaunchEnv(config.codexBin,{...terminalEnv(),CODEX_HOME:home}),stdio:['pipe','pipe','pipe']}),requestTimeoutMs:10000});
+ const deadline=setTimeout(()=>client.close('Model refresh timed out'),15000);
+ try{
+  await client.initialize();let cursor=null;const models=[];const seen=new Set();
+  do{const r=await client.request('model/list',{limit:100,includeHidden:true,...(cursor?{cursor}:{})});
+   if(!Array.isArray(r.data))throw Error('Model list could not be read.');models.push(...r.data);cursor=r.nextCursor;
+   if(cursor&&seen.has(cursor))throw Error('Model list did not finish.');seen.add(cursor);
+  }while(cursor);
+  if(!models.length)throw Error('No models were returned.');rememberCodexModels(home,models);
+ }finally{clearTimeout(deadline);client.close('Model refresh complete');}
+}

package/main/repeats.mjs

@@ -36,7 +36,7 @@ function describeRule({ every, at, on }) {
 // How many periods in a row may be superseded before the founder is told.
 const MISSES_BEFORE_ALERT = 3;
 
-// The protocol goes FIRST in an occurrence's body, ahead of her words. An
+// The protocol goes FIRST in an occurrence's body, ahead of the user's instruction. An
 // over-long body keeps its prefix and cuts its suffix, so a protocol written
 // last can be truncated away entirely, and a worker that never saw it cannot
 // know that a quiet finish has to be marked.
@@ -112,11 +112,11 @@ export class Repeats {
     title, body, priority = 5, every = 'day', at, on, engine, model,
   }, now = Date.now()) {
     // Refused here rather than stored and ignored later: a rule that cannot be
-    // kept has to fail while she is still looking at what she typed.
+    // kept has to fail while the user is still looking at what they typed.
     //
     // `on` is validated AND stored. It was in neither, so a weekly rule was
     // checked without the day that makes it weekly, and no weekly rule ever
-    // survived this line (hers). The refusal says which day is missing now,
+    // survived this line. The refusal says which day is missing now,
     // because "every week at 08:00" reads like a bug in the clock.
     if (!title || !String(title).trim()) throw new Error('a repeating task needs a title');
     if (!isRepeatRule({ every, at, on })) throw new Error(`not a schedule ${NAME} can keep: ${describeRule({ every, at, on })}`);
@@ -134,7 +134,7 @@ export class Repeats {
   patchRule(productDir, id, patch, now = Date.now()) {
     // `on` joins the other two: changing a daily rule to a Thursday one sends
     // every, at AND on, and checking the first two alone refused the change for
-    // the same reason a new weekly rule was refused (hers).
+    // the same reason a new weekly rule was refused.
     if (('at' in patch || 'every' in patch || 'on' in patch)) {
       const current = this.get(productDir, id, now);
       if (!current) throw new Error(`no such repeating task: ${id}`);

package/main/row-label.mjs

@@ -1,47 +1,46 @@
-// THE NAME ON THE ROW, WRITTEN RATHER THAN TAKEN FROM HER FIRST SENTENCE.
+// THE NAME ON THE ROW, WRITTEN RATHER THAN TAKEN FROM THE FIRST SENTENCE.
 //
-// A message she dictates keeps its first line as its title, verbatim and
-// forever (renderer/src/message-split.ts). Measured on her Agentbox store the day
-// she asked: 214 of the 330 items are hers, median title 84 characters, 145 over
-// 60, 37 cut off mid sentence with an ellipsis, and 76 opening with "I", "I've
-// been", "Can you" or "We". Eleven of those down a column is eleven rows that
-// look like one row.
+// A dictated message keeps its first line as its title, verbatim and forever
+// (renderer/src/message-split.ts). Such titles run long, are often cut off mid
+// sentence with an ellipsis, and many open with "I", "I've been", "Can you" or
+// "We". Eleven of those down a column is eleven rows that look like one row.
 //
 // THERE IS NOTHING TO EXTRACT FROM CLAUDE CODE, which is the first thing this
 // had to find out. Claude Code does generate a short name for a session and it
-// writes it to the terminal tab; it never puts it on disk. Measured 2026-09-03:
-// ZERO of her 3,126 transcript files written since 20 August carry a `summary`
-// row, and main/agent-sessions.mjs found the same over 495 files on 08-29. So
-// the name is not read from anywhere. It is written, here, by the same kind of
-// call Claude Code makes: one small fast model, one message, one line back.
+// writes it to the terminal tab; it never puts it on disk: none of thousands of
+// transcript files measured carried a `summary` row, and main/agent-sessions.mjs
+// found the same. So the name is not read from anywhere. It is written, here, by
+// the same kind of call Claude Code makes: one small fast model, one message,
+// one line back.
 //
-// AND IT IS WRITTEN FROM WHERE THE THREAD STANDS, NOT FROM ITS FIRST MESSAGE.
-// This is the difference she was shown and the one she picked. Titled from its
-// opening line alone came back "Fix onboarding and theme visibility", which was
-// true the day she wrote it and by then the row was about landing five
-// branches; given the last thing written on the row as well, the same call said
-// "Landing branches for app fixes". Her threads run for days, so a name fixed
-// at the first message goes stale the way rule 8 of her instructions is about,
-// and this is the same failure arriving from the other side.
+// AND IT IS WRITTEN ONCE, FROM WHERE THE THREAD STOOD WHEN IT WAS NAMED.
+// A thread's opening line describes where it started, so the prompt is given
+// the last thing written on the row as well and the name describes the work
+// rather than the first sentence of the ask. It used to be REWRITTEN every time
+// the row's content moved, on the same reasoning, and that is what this file no
+// longer does: a tester lost their threads because the names kept changing
+// under them while agents worked (w-c141733b61, `wantsName` below). A name that
+// follows the work is worth less than a name a person can find again.
 //
 // WHY THE APP DOES THIS AND NOT THE WORKER. It was written into briefs/worker.md
 // first and taken straight back out: the brief is pasted into every session and
 // tests/the-brief-only-says-what-applies.mjs holds it under 6,000 characters,
 // which it was 33 characters short of. A rule every worker must remember is also
-// a rule most of them will not, and the row she is looking at right now may have
+// a rule most of them will not, and the row the user is looking at right now may have
 // no worker on it at all. Doing it here names every row on every product with
 // nothing for anyone to remember.
 //
-// The write goes to `label`, never to `title`. The title is hers, the fold makes
-// her outrank us on it, and she still reads her own words the moment she opens
-// the row (shared/work-items.mjs).
+// The write goes to `label`, never to `title`. The title belongs to the user,
+// the fold makes the user outrank us on it, and the user still reads their own
+// words the moment they open the row (shared/work-items.mjs).
 
 import { spawn } from 'node:child_process';
+import { codexLaunchEnv } from './codex-launch-env.mjs';
 
 /**
  * The model this runs on. Small and fast on purpose: this is a naming call, it
  *  happens on a timer, and it must never be worth thinking about. Measured
- *  through the CLI on 2026-09-03 over ten of her real rows: 14.1s median a call,
+ *  through the CLI over ten real rows: 14.1s median a call,
  *  nearly all of it the CLI starting a session rather than the model working. */
 export const NAME_MODEL = 'claude-haiku-4-5-20251001';
 
@@ -52,7 +51,7 @@ export const NAME_MODEL = 'claude-haiku-4-5-20251001';
 export const NAME_TIMEOUT_MS = 90_000;
 
 /**
- * What a name may be. Long enough for "Landing branches for app fixes", short
+ * What a name may be. Long enough for a seven-word name, short
  *  enough that it can never be the thing that makes a row clip: the row draws
  *  one line and the summary budget beside it is 112. */
 export const NAME_MAX = 64;
@@ -63,41 +62,72 @@ export const NAME_MAX = 64;
 const LIVE = new Set(['open', 'claimed', 'blocked']);
 
 /**
- * The newest moment anything about this row's CONTENT changed. Deliberately not
- *  `updatedAt`: a heartbeat, a claim and a release all move that, and renaming a
- *  row every time a worker touches it would spend a call a minute on a busy row
- *  and change the words under her while she reads them. */
-export function contentTouchedAt(item) {
-  const w = item?.wrote ?? {};
-  let last = 0;
-  for (const field of ['title', 'body', 'result', 'answer']) {
-    const ts = w[field]?.ts ?? 0;
-    if (ts > last) last = ts;
-  }
-  return last;
+ * PURE. Is this title already a name somebody wrote?
+ *
+ * The one question that decides whether this module speaks at all, and it is
+ * answered off the words alone because that is all there is: nothing on a row
+ * records whether its title was typed or derived.
+ *
+ * Three marks, and together they separate the two shapes `splitMessage` makes
+ * (renderer/src/message-split.ts). A first line of 120 characters or less is
+ * kept VERBATIM and is the name its person wrote. A longer one is clipped into
+ * a title by the app, and every clip it can produce is either a whole sentence
+ * of at least 25 characters or a hard cut ending in an ellipsis.
+ *
+ *   as short as a name we would write   NAME_MAX, so a title already that tight
+ *                                       has nothing for us to improve,
+ *   as few words as a name has          the same eight `cleanName` allows,
+ *   not ending as a sentence does       '.', '!', '?' and '…' are how a clipped
+ *                                       title ends and not how a name does.
+ *
+ * It errs towards leaving the words alone, which is the right way to be wrong:
+ * the cost is a short typed sentence keeping its own first line, and the cost
+ * the other way is somebody losing the thread they named.
+ */
+export function isWrittenName(title) {
+  const t = String(title ?? '').trim();
+  if (!t) return false;
+  if (t.length > NAME_MAX) return false;
+  if (t.split(/\s+/).length > 8) return false;
+  return !/[.!?…]$/.test(t);
 }
 
 /**
  * PURE. Does this row want naming?
  *
- * Three ways to say no, and the third is the one that keeps this cheap:
+ * Four ways to say no, and the last two are the fix for a tester losing their
+ * own threads on 2026-10-01: "Add comment to cart.js" became "Improve cart.js
+ * header comment" and then "Update cart file comment" inside two minutes.
+ *
  *   - it is done, so nobody is scanning for it,
  *   - it has nothing to name from, which is a row with no words on it yet,
- *   - its label is already at least as new as the newest thing said on the row.
+ *   - ITS PERSON ALREADY NAMED IT. A short clear title is the name they will
+ *     look for, and on a team it is the name they will point someone else at.
+ *     Improving it is not an improvement.
+ *   - IT HAS BEEN NAMED. Once, when the thread was made, and then never again.
+ *
+ * That last line used to read `wroteAt < contentTouchedAt(item)`, so the name
+ * followed where the thread stood: an agent writes a note and a result on every
+ * run, so every run earned a new name. Following the thread was the intended
+ * behaviour and there was a test for it; what it cost in practice is that no
+ * thread stayed findable, so the brief for this change overrides both. The idea
+ * it was serving survives in the prompt, which still reads the latest thing on
+ * the row, so the one name a thread gets describes the work and not just its
+ * opening line.
  *
- * A row whose label we wrote and whose content has not moved since is finished
- * business forever, so a store that has settled costs nothing per tick.
+ * The exception is a name the person writes themselves later: a title newer
+ * than our label is a rename, so `rowTitle` draws theirs (list-rules.ts) and
+ * this stays quiet rather than answering it with another name of ours.
  */
 export function wantsName(item) {
   if (!item || !LIVE.has(item.status)) return false;
   if (!String(item.title ?? '').trim() && !String(item.body ?? '').trim()) return false;
-  const wroteAt = item.wrote?.label?.ts ?? 0;
-  if (!String(item.label ?? '').trim()) return true;
-  return wroteAt < contentTouchedAt(item);
+  if (isWrittenName(item.title)) return false;
+  return !String(item.label ?? '').trim();
 }
 
 /**
- * PURE. The one message the naming call gets. Her words first, then the last
+ * PURE. The one message the naming call gets. The user's words first, then the last
  *  thing written on the row, which is what makes the name describe the thread
  *  rather than its opening line. Truncated hard: a name does not get better for
  *  having read six thousand words, and this is spawned on a timer. */
@@ -148,21 +178,55 @@ export function cleanName(text) {
   return bare;
 }
 
+/**
+ * THE SAME CALL ON A MAC THAT HAS ONLY CODEX. `codex exec` prints the reply
+ *  alone on stdout and everything else on stderr, so the reading below is the
+ *  same. No session is kept, none of her Codex config or MCP servers is loaded,
+ *  and nothing may be written. Measured 2026-10-01, codex-cli 0.160.0: 5.6s. */
+export function codexNameArgs(item) {
+  return codexArgs(namePrompt(item));
+}
+
+function codexArgs(prompt) {
+  return [
+    'exec', '--skip-git-repo-check', '--ephemeral', '--ignore-user-config', '--ignore-rules',
+    '-s', 'read-only', '-c', 'model_reasoning_effort=low', prompt,
+  ];
+}
+
 /**
  * Name one row. Resolves to a clean name, or to '' for every failure there is:
  * the binary missing, a non-zero exit, a timeout, an empty reply, a reply that
  * is not a name. Never throws and never rejects, because this is called from a
  * timer whose only correct behaviour on failure is to leave the row alone.
  */
-export function nameRow(item, { claudeBin, model = NAME_MODEL, timeoutMs = NAME_TIMEOUT_MS } = {}) {
+export function nameRow(item, opts = {}) {
+  return askSmallModel(namePrompt(item), cleanName, opts);
+}
+
+/**
+ * One short question to the small model, on Claude Code or Codex, its reply put
+ * through `clean`. The same promise as `nameRow` and for the same reason: ''
+ * for every failure, never a throw. Shared with the message sorter
+ * (main/message-priority.mjs).
+ *
+ * `env` is which account the call bills. Without one it inherits the app's own
+ * environment, which is always the default Claude account: when that account
+ * hit its weekly limit on 2026-10-06 every call died in two seconds and no row
+ * was named for a day, while agents ran on the second account. The supervisor
+ * passes one per account and walks them (`_askSmall` in main/supervisor.mjs).
+ */
+export function askSmallModel(prompt, clean, { claudeBin, codexBin = null, engine = 'claude', model = NAME_MODEL, timeoutMs = NAME_TIMEOUT_MS, env } = {}) {
   return new Promise((resolve) => {
-    if (!claudeBin) return resolve('');
+    const bin = engine === 'codex' ? codexBin : claudeBin;
+    if (!bin) return resolve('');
     let child;
     try {
-      child = spawn(claudeBin, ['-p', namePrompt(item), '--model', model], {
+      child = spawn(bin, engine === 'codex' ? codexArgs(prompt) : ['-p', prompt, '--model', model], {
         // Somewhere that is nobody's project. A naming call must not pick up a
         // CLAUDE.md, a settings file or a hook from whatever folder it lands in.
         cwd: '/tmp',
+        ...(engine === 'codex' ? { env: codexLaunchEnv(bin, env) } : env ? { env } : {}),
         stdio: ['ignore', 'pipe', 'pipe'],
       });
     } catch {
@@ -178,8 +242,8 @@ export function nameRow(item, { claudeBin, model = NAME_MODEL, timeoutMs = NAME_
       resolve(value);
     };
     const timer = setTimeout(() => finish(''), timeoutMs);
-    child.stdout.on('data', (d) => { out += d.toString(); if (out.length > 4000) finish(cleanName(out)); });
+    child.stdout.on('data', (d) => { out += d.toString(); if (out.length > 4000) finish(clean(out)); });
     child.on('error', () => finish(''));
-    child.on('close', (code) => finish(code === 0 ? cleanName(out) : ''));
+    child.on('close', (code) => finish(code === 0 ? clean(out) : ''));
   });
 }

package/main/runs-on.mjs

@@ -0,0 +1,93 @@
+// WHICH ACCOUNT THE AGENTS ARE ACTUALLY RUNNING ON, read off this Mac.
+//
+// w-e217e577e5, 2026-10-07, from a session with a new user: "He didn't realize
+// it auto-connected to Claude/Codex; he wasn't sure how it was even running."
+//
+// Every fact here was already on the disk and already being read, each by the
+// screen that needed it: main/claude-plan.mjs for the Claude plan (the Accounts
+// page), main/codex-account.mjs for the ChatGPT one (the Codex card). What did
+// not exist was ONE answer to "what is powering this", in a shape small enough
+// to ride the snapshot and be drawn in a corner. That is all this is: the two
+// readers, asked about the one account the fleet is spending, and null whenever
+// the answer would be a guess.
+//
+// NULL IS AN ORDINARY ANSWER AND IT MEANS DRAW NOTHING. A Mac mid-setup, a
+// config file being rewritten under us, a login that exists with no plan string
+// in it: the first two are null, the third is the name with no plan. Nothing
+// here ever reports an account that is not there, because the corner it feeds
+// is read by somebody deciding whose money this is spending.
+//
+// IT IS CACHED ON THE LOGIN FILES' OWN TIMES, NOT ON A CLOCK. The snapshot is
+// built every ten seconds and `~/.claude.json` is 148 KB on the machine this was
+// written on, so parsing it per tick is work nobody asked for; it is also a file
+// that genuinely changes, since Claude Code refetches its own profile as it
+// runs. `signInFiles`/`signInStamp` (main/sign-in-files.mjs) already name the
+// files a login writes and read their modification times and nothing else, so
+// the cache key is the newest of those times. A moved time re-reads. A cache
+// that aged out on a timer instead would be either stale after a sign-in or
+// re-parsing for nothing, and the file itself knows which.
+
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { planFile, planOfAccount } from './claude-plan.mjs';
+import { codexAccount, codexAuthFile } from './codex-account.mjs';
+import { signInFiles, signInStamp } from './sign-in-files.mjs';
+
+/** keyed by engine and folder, valued by the stamp it was read at. */
+const remembered = new Map();
+
+/**
+ * WHAT THE FLEET IS RUNNING ON, or null because nothing readable is signed in.
+ *
+ * @param {object} facts
+ * @param {string} facts.engine Which coding agent the workspace runs on, which
+ *   the supervisor has already decided (`Supervisor#engineFacts`). Never worked
+ *   out here: the capability gate lives there, and a corner that guessed could
+ *   name the subscription the fleet is not spending.
+ * @param {string} [facts.claudeProfile] The Claude login, `default` or a folder.
+ * @param {string} [facts.codexHome] The CODEX_HOME this workspace runs on.
+ * @returns {{ engine: string, plan: string|null }|null} `plan` is the words the
+ *   tool itself reports, never a label of ours.
+ */
+export function runsOn({ engine = null, home = os.homedir(), claudeProfile = 'default', codexHome = null } = {}) {
+  if (engine !== 'claude' && engine !== 'codex') return null;
+  const folder = engine === 'codex'
+    ? (codexHome || path.join(home, '.codex'))
+    : (!claudeProfile || claudeProfile === 'default' ? null : claudeProfile);
+  // The home is in the key as well as the folder. A default Claude login has no
+  // folder of its own, so without it two homes share one entry, which is exactly
+  // what a test with a throwaway home does and what a packaged app would do if
+  // HOME ever moved under it.
+  const key = `${engine}:${home}:${folder ?? 'default'}`;
+  const stamp = signInStamp(signInFiles({ engine, folder, home }));
+  const seen = remembered.get(key);
+  if (seen && seen.stamp === stamp) return seen.value;
+  const value = stamp ? read(engine, { home, claudeProfile, folder }) : null;
+  remembered.set(key, { stamp, value });
+  return value;
+}
+
+function read(engine, { home, claudeProfile, folder }) {
+  if (engine === 'codex') {
+    const id = codexAccount(null, { file: codexAuthFile(folder) });
+    return id ? { engine: 'codex', plan: id.plan ?? null } : null;
+  }
+  // THE LOGIN AND THE PLAN COME OUT OF ONE READ. `readPlan` answers only the
+  // second, and "not signed in" and "signed in with no plan string" are two
+  // different screens: the first draws nothing, the second draws the name.
+  let account = null;
+  try {
+    account = JSON.parse(fs.readFileSync(planFile(claudeProfile, home), 'utf8'))?.oauthAccount ?? null;
+  } catch {
+    return null;
+  }
+  if (!account || typeof account !== 'object') return null;
+  const plan = planOfAccount(account);
+  return { engine: 'claude', plan: plan.known ? plan.label : null };
+}
+
+/** Forgets every cached reading. For tests, and for a sign-out that lands. */
+export function forgetRunsOn() {
+  remembered.clear();
+}

package/main/serve.mjs

@@ -28,10 +28,17 @@ import path from 'node:path';
 import crypto from 'node:crypto';
 import { fileURLToPath } from 'node:url';
 
+import { spawn } from 'node:child_process';
 import { loadConfig } from './config.mjs';
 import { Store } from './store.mjs';
 import { Supervisor } from './supervisor.mjs';
+import { carryHerBriefsAcross, joinMessageRules, setAsideShippedMessageRules, unifyAgentInstructions } from './instruction-settings.mjs';
 import { registerIpc } from './ipc.mjs';
+import { reportFromRenderer } from './crash-report.mjs';
+import * as workItemsDisk from './store/work-items.mjs';
+import { createTeamService, teamStateFile } from './team/index.mjs';
+import { loadCloudConfig, supabaseSession, headlessSessionFile } from './team/session.mjs';
+import { appHome, carryMisplacedMachinery, storeRootEnv } from './store/home.mjs';
 
 const here = path.dirname(fileURLToPath(import.meta.url));
 const repoRoot = path.dirname(here);
@@ -114,6 +121,28 @@ function readVersion() {
   }
 }
 
+/**
+ * The four channels main/main.mjs registers beside its window, not in ipc.mjs.
+ *
+ *  Each is about the desktop window itself (the dock badge, a ⌘R, banners in
+ *  Notification Center, the window's own crashes), so `registerIpc` never
+ *  files them and a tab asking got a 404. That was not harmless: a failed
+ *  `badge` became an uncaught error, the screen reported it on `crash`, that
+ *  failed too, and the tab sent thousands of requests a second.
+ *  tests/a-browser-tab-gets-an-answer-on-every-channel.test.mjs.
+ *
+ *  A tab has no dock and no ⌘R of ours to report, and nothing here decides
+ *  banners yet, so three of them answer with nothing. A crash goes through the
+ *  same scrubbed path as the desktop's, which writes nothing until crash
+ *  reports are set up for this process.
+ */
+function answerWhatOnlyTheWindowAnswered(ipcMain) {
+  ipcMain.handle('zero:badge', () => null);
+  ipcMain.handle('zero:notify', () => null);
+  ipcMain.handle('zero:boot-info', () => ({ reloaded: false, builtAt: null, recovered: null }));
+  ipcMain.handle('zero:crash', (_e, payload) => { reportFromRenderer(payload ?? {}); return null; });
+}
+
 /**
  * Boot the doing half, with no Electron anywhere.
  *
@@ -124,12 +153,48 @@ function readVersion() {
  */
 export async function bootHeadless({ dataDir = repoRoot, appDir = repoRoot, userDir = dataDir } = {}) {
   const config = loadConfig(dataDir);
+  // The browser editor uses the same user files as the desktop. Finish the
+  // older migrations first so only user content enters the combined file.
+  carryHerBriefsAcross(appDir, userDir);
+  joinMessageRules(appDir, userDir);
+  setAsideShippedMessageRules(appDir, userDir);
+  unifyAgentInstructions(appDir, userDir);
+  // THE APP'S OWN HOME IS THE STORE ROOT, BEFORE ANYTHING OPENS THE STORE, as
+  // main/main.mjs does for the desktop. The ledgers live under the home the
+  // store reads from this variable, and every worker is handed `storeRoot` as
+  // that same variable. Without this line the two disagreed: the copy wrote its
+  // rows wherever an inherited variable pointed (or a dot-folder in $HOME), each worker
+  // looked under `storeRoot`, and every store call answered "no work item".
+  // tests/an-agent-in-a-browser-copy-can-reach-its-own-work-item.test.mjs.
+  // Rows already written under the old home come along, or they would vanish.
+  const inheritedHome = appHome();
+  Object.assign(process.env, storeRootEnv(config.storeRoot));
+  carryMisplacedMachinery(inheritedHome, config.storeRoot);
   const store = await new Store(config).init();
   const supervisor = new Supervisor(config, store, appDir, dataDir, userDir);
   const window = broadcastingWindow();
   const host = nodeHost();
-  const ipc = registerIpc({ store, supervisor, config, window, host });
-  return { config, store, supervisor, window, host, ipc, channels: host.ipcMain.handlers };
+  // THE TEAM, as on the desktop (main/main.mjs), with no Electron: the session
+  // file is plain JSON readable only by this user, kept in this copy's own
+  // folder and not in the store (headlessSessionFile), and Google sign-in opens
+  // in the Mac's own browser.
+  const cloudConfig = loadCloudConfig(appDir);
+  let ipc = null;
+  const team = cloudConfig ? createTeamService({
+    session: supabaseSession({
+      cloudConfig,
+      sessionFile: headlessSessionFile({ userDir, storeRoot: config.storeRoot }),
+      openExternal: async (url) => { spawn('open', [url], { stdio: 'ignore', detached: true }).unref(); },
+    }),
+    store,
+    disk: workItemsDisk,
+    accountRoot: config.accountRoot,
+    stateFile: teamStateFile(config.storeRoot),
+    onChange: () => ipc?.push?.(),
+  }) : null;
+  ipc = registerIpc({ store, supervisor, config, window, host, team });
+  answerWhatOnlyTheWindowAnswered(host.ipcMain);
+  return { config, store, supervisor, window, host, ipc, team, channels: host.ipcMain.handlers };
 }
 
 /** A token in the url, because the port alone is not a door key. */
@@ -161,10 +226,17 @@ export function createServer({ channels, token, listeners = new Set(), dist = pa
   return http.createServer(async (req, res) => {
     const url = new URL(req.url, 'http://127.0.0.1');
 
-    // The token rides in a header on api calls and in the query on the first
-    // page load, because a browser cannot put a header on a navigation.
+    // The token rides in a header on api calls and in the query on the event
+    // stream, because a browser cannot put a header on either a navigation or
+    // an EventSource. It guards the two doors that reach the store. The built
+    // screen is the same public files for everybody, and its own script and
+    // style requests carry no token, so asking for one there drew a blank tab.
+    // NOR DOES THE PAGE ITSELF ASK: the tab takes the token out of its address
+    // bar on load, so a reload asks for `/` bare, and refusing that drew
+    // "Wrong or missing token" on every reload (tests/a-browser-tab-survives-a-reload).
+    const guarded = url.pathname === '/events' || url.pathname.startsWith('/api/');
     const given = req.headers['x-agentbox-token'] || url.searchParams.get('token');
-    if (given !== token) {
+    if (guarded && given !== token) {
       res.writeHead(403, { 'content-type': 'text/plain' });
       res.end('Wrong or missing token. Use the url the terminal printed.');
       return;