agentbox-app 0.1.7 → 0.1.12

package/shared/runs-on.mjs

@@ -0,0 +1,79 @@
+// WHAT THE AGENTS ARE RUNNING ON, IN WORDS.
+//
+// From a session with a new user, 2026-10-07: "He didn't realize it
+// auto-connected to Claude/Codex; he wasn't sure how it was even running. Would
+// be nice to have some small indication."
+//
+// He was right that nothing said. The app finds whichever coding agent is
+// already signed in on the Mac and runs every worker on that subscription
+// (main/claude-plan.mjs, main/codex-account.mjs), and the walk is SILENT about
+// it by design: `needsPlan` in renderer/src/plan-setup.ts skips the plan
+// question entirely when one tool is found and signed in, which is the right
+// call and leaves nobody told. The only screen that has ever named the account
+// is Settings, two clicks in, and you have to suspect there is something to
+// look for before you go.
+//
+// THE PLAN'S VOCABULARY, NOT THE TOOL'S. "Claude" and "ChatGPT" here, never
+// "Claude Code" and "Codex", which is the rule the walk already follows
+// (renderer/src/plan-setup.ts: words people know, "never the names of the tools
+// underneath"). The fact being shown is WHOSE SUBSCRIPTION IS BEING SPENT, and
+// nobody pays for a CLI. The tool names stay where they belong: on a byline
+// about which agent is working a row (`engineWordFor`, renderer/src/byline.ts),
+// which is a different question with a different answer.
+//
+// NOTHING IS SAID UNTIL SOMETHING IS KNOWN. Every function here answers null on
+// an engine it cannot name, and the screens draw nothing at all for null rather
+// than "checking…" or a dash. A corner that says it does not know is worse than
+// a corner that says nothing: it spends the glance and answers no question.
+
+/** The word for the plan behind an engine. Null for an engine we cannot name. */
+export function runsOnName(engine) {
+  if (engine === 'claude') return 'Claude';
+  if (engine === 'codex') return 'ChatGPT';
+  return null;
+}
+
+/**
+ * THE LINE ON A GLANCE SURFACE. "Claude · Max 20x", or just "Claude" where the
+ *  plan cannot be read.
+ *
+ *  The plan is the raw label the tool itself reports, already turned into words
+ *  by whoever read it (`planLabel` in main/claude-plan.mjs for Claude, the
+ *  named-plan table in main/codex-account.mjs for ChatGPT). It is never
+ *  invented here: a plan nobody measured, printed confidently, is the app
+ *  lying about what somebody is paying for.
+ */
+export function runsOnLine({ engine = null, plan = null } = {}) {
+  const name = runsOnName(engine);
+  if (!name) return null;
+  const words = String(plan ?? '').trim();
+  return words ? `${name} · ${words}` : name;
+}
+
+/**
+ * THE WHOLE SENTENCE, for a hover and for whatever reads the screen aloud. The
+ *  glance surface carries two words and a plan; this is where the rest of the
+ *  answer lives, and it is the half that tells a new person what they are
+ *  looking at.
+ */
+export function runsOnTitle({ engine = null, plan = null } = {}) {
+  const name = runsOnName(engine);
+  if (!name) return null;
+  const words = String(plan ?? '').trim();
+  const plansentence = words ? ` Your ${words} plan.` : '';
+  return `Your agents run on the ${name} account already signed in on this Mac.${plansentence}`;
+}
+
+/**
+ * THE ONE LINE DURING THE WALK, on the Mac where there was nothing to ask.
+ *
+ *  It replaces silence, not a question: somebody with no coding agent set up
+ *  still gets the plan question and the setup card, and never sees this.
+ */
+export function foundOnThisMac({ engine = null, plan = null } = {}) {
+  const name = runsOnName(engine);
+  if (!name) return null;
+  const words = String(plan ?? '').trim();
+  if (words) return `Your agents will run on the ${name} ${words} plan already signed in on this Mac.`;
+  return `Your agents will run on the ${name} account already signed in on this Mac.`;
+}

package/shared/schemes.d.mts

@@ -0,0 +1,11 @@
+// Types for shared/schemes.mjs, for the window side.
+//
+// The lists are built from the app's past names at load, so their length is
+// not a constant and nothing here pretends otherwise. `isScheme` takes the
+// protocol as `URL` hands it over, with its colon on the end.
+export declare const DOC_SCHEME: string;
+export declare const IMG_SCHEME: string;
+export declare const DOC_SCHEMES: readonly string[];
+export declare const IMG_SCHEMES: readonly string[];
+export declare const ALL_SCHEMES: readonly string[];
+export declare function isScheme(schemes: readonly string[], protocol: string): boolean;

package/shared/schemes.mjs

@@ -10,7 +10,7 @@
 // of these schemes is STORED: a product's logo is kept in the store as
 // `<scheme>://file/…` and a message she has already been sent holds picture
 // urls in its body. Dropping the old scheme would not degrade those, it would
-// break them, and the symptom is a broken image in a row she wrote months ago.
+// break them, and the symptom is a broken image in a row written months ago.
 // So the current name is what new urls are built with, and every name this app
 // has had is still registered and still answered.
 

package/shared/shortcuts.d.mts

@@ -0,0 +1,41 @@
+// Types for shared/shortcuts.mjs, which is plain ESM so that the Settings page
+// (Vite) and the supervisor (Node) read one list of keys. See the module for
+// why each row reads the way it does.
+
+export interface Shortcut {
+  /**
+   * The caps, drawn in order. A chord is ONE cap ('⌘K', '⌘↵'), the way the
+   *  walk already draws them, because ⌘ and K are not two keys to a reader.
+   *
+   *  AND THE HOVER HINT NO LONGER AGREES WITH THAT. ⌘J was drawn both ways on
+   *  w-2f7fac6027, one cap per key won, because a single ⌘J cap looked
+   *  condensed next to the usual way shortcuts are drawn. So
+   *  `capsFor` in hint-plate.ts splits a chord into one cap per glyph, and this
+   *  page does not. That is a real disagreement between two surfaces and it is
+   *  left standing rather than quietly resolved: this is a reference page where
+   *  a chord is read as one thing to press, and the hint is a label on a
+   *  control she is pointing at. If the page ever looks condensed too,
+   *  the fix is to take `capsFor` here, not to put one cap back there. */
+  keys: string[];
+  /**
+   * The word set between two caps. Absent means they simply sit side by side,
+   *  which is what ↑ ↓ means: both of them, either way. */
+  join?: 'or' | 'to';
+  /** What it does, in plain English. ONE sentence, under seventy characters. */
+  what: string;
+}
+
+export interface ShortcutGroup {
+  /** THE HEADING SAYS WHEN THE KEYS WORK, LITERALLY, AND IT IS THE ONLY PROSE
+   *  A GROUP GETS. There is deliberately no note field: see the module. */
+  label: string;
+  keys: Shortcut[];
+}
+
+export const SHORTCUTS: ShortcutGroup[];
+
+/** Every cap drawn on the page, flattened. The test walks this. */
+export function everyKey(groups?: ShortcutGroup[]): string[];
+
+/** The keys as one block of plain text, for an agent's system prompt. */
+export function keysForAgents(groups?: ShortcutGroup[]): string;

package/shared/shortcuts.mjs

@@ -0,0 +1,236 @@
+// PURE. EVERY KEY AGENTBOX HAS, IN THE ORDER A PERSON MEETS THEM.
+//
+// A shortcuts page in settings, because onboarding a non-technical tester
+// meant saying each key out loud, one at a time: the app had a switch for
+// whether it WHISPERS its keys and no page anywhere that says what they are.
+//
+// WHY THIS IS A FILE AND NOT MARKUP IN THE COMPONENT. A page that prints a key
+// the handler does not have is worse than no page at all — that is the rule
+// `list-rules.ts` already keeps for the hint on a row, and the reason it holds
+// even harder here is that a hint is read for a second and a reference page is
+// believed. So the list is a value, and
+// `tests/the-shortcuts-page-lists-keys-that-work.test.mjs` reads every entry
+// below against the branch in App.tsx (or main/main.mjs, or Compose.tsx) that
+// actually runs it. A key added here without a handler fails the suite.
+//
+// WHY IT IS IN shared/ AND PLAIN ESM (w-7ec8553e23, 2026-10-04). It lived in
+// renderer/src as TypeScript until an agent told the user to "Press S on this
+// task" three days after S stopped scheduling: nothing a session is handed
+// said what the keys are, so it went by an old memory. The supervisor now
+// hands every run `keysForAgents()`, read off this same list, and main cannot
+// import TypeScript. Types are in shortcuts.d.mts beside it.
+//
+// ONE SENTENCE A ROW, AND IT IS SHORT (w-1bc916a880). Every
+// sentence here is now under seventy characters and the test enforces it. A row
+// that wants a second idea becomes its own row, or it does not go on the page.
+//
+// AND NO KEY HIDES INSIDE A SENTENCE.
+//
+// HOW IT IS GROUPED, and it is not how the code is arranged. The code has one
+// switch for the list, one branch for an open task, a chord block above both
+// and a main-process handler under all of it. Nobody thinks in those. Four
+// headings, and every key sits under the one that matches when she would want
+// it: in your inbox, in a task you have opened, closing and scheduling and
+// undoing, anywhere in the app.
+//
+// EVERY HEADING IS LITERAL AND THERE IS NO SUBHEADING AT ALL (w-1bc916a880,
+// second round).
+//
+// The plainest point first: that heading named one of the two
+// directions its own rows draw. Three of the four were figures of speech, and a
+// figure of speech is a second thing to decode on a page whose only job is to
+// be looked up. So a heading now says WHEN the keys under it work, in the words
+// the app itself uses for those places, and the one group that cannot be named
+// that way is named by what its keys do instead, because all four of its keys
+// work in both places.
+//
+// What the three of them carried, and where it went:
+//
+//   "In Scheduled, E brings a task back instead of closing it." This was the
+//   most confusing one. It is also the same class of thing as G, B and
+//   the import letters below: a behaviour that only happens in one view. The
+//   page's existing rule is that those stay off it, so this now obeys the rule
+//   the rest of the file already kept.
+//
+// The two ↵ rows say what ↵ does when it does something.
+//
+//   "Anything without a key of its own is in ⌘K by name." The lede at the top
+//   of the page already says this, so it was the same sentence twice.
+//
+// WHAT IS DELIBERATELY NOT HERE, so nobody adds it back as an oversight:
+//
+// ⌘1..4, for PRIORITY or for anything else. Priority was removed deliberately
+// and that handler no longer fires. The chord then went to a section of the
+// sidebar until 2026-10-02, and that is gone as well: Tab moves along the tabs
+// now and is listed above.
+//
+//   Y, N and I on a row in the list. Real since w-9741ed0e0b, but they answer
+//   a Codex conversation's import row and are dead on every other row in the
+//   app. A reference page that lists a key which does nothing on nineteen
+//   screens out of twenty teaches somebody that the app ignores them.
+//
+//   ⇥ inside the new task card, which changes the project it goes to. It is
+//   gated to that one card, the card draws its projects where she can see
+//   them, and it used to ride along inside the C row's sentence, which is the
+//   fault the NO KEY HIDES INSIDE A SENTENCE block above is about.
+//
+//   ⇧⇥ in the reply box, which cycles Claude Code's permission modes. Real,
+//   and it belongs to the reply box rather than to the app; it is also the one
+//   key here that cannot be said without the word "permissions", and Settings
+//   already has a whole group explaining those.
+//
+//   ⌘R, ⌘=, ⌘- and ⌘0. The Mac's own chords, answered in main.mjs so they work
+//   over the game. Nobody needs to be taught reload and zoom.
+//
+// EVERY SENTENCE IS PLAIN. A tester does not know what a modal, a pane, a
+// binary or a view is. No row uses a word the app does not print on screen
+// somewhere she can see it. THE SIDEBAR ROW IS WHY THAT NOW MATTERS TWICE: it
+// used to name the sections, "Inbox, Scheduled, In progress, Closed", and
+// that went wrong in both halves. The real order is Inbox, In
+// progress, Scheduled, Closed (`workspaceDestinations`), and Scheduled is
+// drawn only when something is actually scheduled. A reference
+// page that recites a list the sidebar can change goes stale without anybody
+// touching it, so the row names no sections at all.
+
+import { NAME } from './product-name.mjs';
+
+/** @type {import('./shortcuts.d.mts').ShortcutGroup[]} */
+export const SHORTCUTS = [
+  {
+    // App.tsx, the `switch (e.key)` at the foot of the key handler: this is the
+    // list with nothing open, which is where anybody starts.
+    //
+    // "IN YOUR INBOX", BECAUSE INBOX IS A WORD THE APP PRINTS AND TASK LIST IS
+    // NOT (w-1bc916a880, third round).
+    //
+    // The mistake is worth naming because it is the same one
+    // the round before was meant to fix. "Task list" was reached for to cover
+    // the fact that these keys work in all four sidebar sections rather than
+    // only the first, which is an accurate thing about the code and a phrase
+    // nobody sees on a screen. Inbox is the first row of the
+    // sidebar. The heading claims these keys work there; it does not claim they
+    // work ONLY there, and one of its rows moves between the sections anyway.
+    label: 'In your inbox',
+    keys: [
+      // case 'j': case 'J': case 'ArrowDown' → selected + 1
+      { keys: ['J', '↓'], join: 'or', what: 'Move down the list.' },
+      // case 'k': case 'K': case 'ArrowUp' → selected - 1
+      { keys: ['K', '↑'], join: 'or', what: 'Move up the list.' },
+      // case 'ArrowLeft': case 'ArrowRight' → boardSideways (w-23fc91bff5).
+      // "Board" is the word the View and filters menu prints.
+      { keys: ['←', '→'], what: 'Move to the next column on the board.' },
+      // case 'Enter' → setFocused(pointed)
+      { keys: ['↵'], what: 'Open the task you are on.' },
+      // App.tsx, `if (e.key === 'Tab')`: nextTab(stateTabOrder, view, shiftKey)
+      // walks the tabs along the top of the inbox, wrapping. It replaced ⌘1 to
+      // ⌘4 on 2026-10-02 (w-914b16eab6), which jumped through the sidebar's
+      // sections before those became these tabs. Shift-Tab goes back and is
+      // left unlisted on her word: "just show the Next tab".
+      { keys: ['⇥'], what: 'Move to the next tab along the top.' },
+      // case 'b': case 'B' → setInboxDisplay(flipView(inboxDisplay)), asked
+      // for by name (w-58c8f466e7). "List" and "Board" are the words the View
+      // and filters menu prints, so the sentence uses those.
+      { keys: ['B'], what: 'Switch between the list and the board.' },
+      // Escape in the focused branch: doc → task → list. In the list switch it
+      // clears a selection and closes search.
+      { keys: ['esc'], what: 'Go back one step: a file, then the task, then the list.' },
+    ],
+  },
+  {
+    // App.tsx, the `if (focused)` branch: a task open in front of her. NOT
+    // "answering an agent" any more, because ⌘J opens its terminal and that is
+    // not an answer; the heading says when the keys work, which is the scheme.
+    label: 'In a task you have opened',
+    keys: [
+      // focused branch: 'r' → setModal('reply'); list switch: 'r' in the inbox
+      { keys: ['R'], what: 'Write back to the agent.' },
+      // Compose.tsx onKeyDown: (meta||ctrl) && Enter → send; Focus.tsx the same
+      { keys: ['⌘↵'], what: 'Send what you have typed.' },
+      // focused branch: ArrowDown / ArrowUp walk opts
+      { keys: ['↑', '↓'], what: 'Move through the options an agent has offered.' },
+      // focused branch: Enter sends optionSel. Its own row rather than a clause
+      // at the end of the one above, so somebody scanning for ↵ finds it.
+      { keys: ['↵'], what: 'Send the option you have selected.' },
+      // focused branch: /^[1-9]$/ → pickOption(focused, Number(e.key))
+      { keys: ['1', '9'], join: 'to', what: 'Pick an option by its number.' },
+      // ⌘J, above the inInput gate in App.tsx: dispatches task-terminal-toggle,
+      // and toasts "Open a task to use its terminal" when there is none
+      // (w-ef92663cb1). It landed after this list last changed, so it was
+      // missing here at first.
+      { keys: ['⌘J'], what: 'Show or hide this task’s terminal.' },
+      // threads/Summary.tsx, `useSummaryShortcut`: it listens in the capture
+      // phase and stops the key there, so S belongs to the summary on a thread
+      // that has one. It is under THIS heading and not the one below because it
+      // is the one key in the app that works only inside an open thread.
+      { keys: ['S'], what: 'Show or hide the summary.' },
+    ],
+  },
+  {
+    // The one group that cannot be named by WHERE she is, because all four of
+    // its keys work both in the list and inside an open task. So it is named by
+    // what the keys do, literally and in the order they are drawn.
+    label: 'Closing, scheduling and undoing',
+    keys: [
+      // focused branch: 'e' → markDone. List switch: inbox → markDone,
+      // snoozed → unsnooze. It never approves anything.
+      { keys: ['E'], what: 'Close the task and take it out of your inbox.' },
+      // focused branch and list switch: 'l' → openSnooze. IT WAS S UNTIL
+      // 2026-10-01 AND THAT IS THE WHOLE OF WHY IT MOVED. S had come to mean
+      // the summary inside a thread and still meant the schedule picker in the
+      // list, so this page taught one letter for two different things and an
+      // office manager testing the app met both inside a minute. One meaning
+      // per letter: S is the summary, L is later.
+      { keys: ['L'], what: 'Put the task off until a time you pick.' },
+      // focused branch and list switch: 'z' → undo
+      { keys: ['Z'], what: 'Undo the last thing you did.' },
+      // (meta||ctrl) && 'a' && !inInput && !modal → tick the whole list
+      { keys: ['⌘A'], what: 'Tick every task in the list. Press it again to untick.' },
+    ],
+  },
+  {
+    label: 'Anywhere in the app',
+    keys: [
+      // (meta||ctrl) && 'k' → the palette, above every other branch, and
+      // forwarded from inside an open file by main.mjs as well.
+      { keys: ['⌘K', 'Ctrl+K'], join: 'or', what: `The command bar: everything ${NAME} can do, by name.` },
+      // 'n' in both branches → setModal('compose'). C does the same and is
+      // left off: N is the default (w-fb9051e597).
+      // "Threads", not tasks, since w-ec62ab6b38.
+      { keys: ['N'], what: 'Start a new thread.' },
+      // '/' above the focused branch → openSearch
+      { keys: ['/'], what: 'Search your threads.' },
+      // '\\' above the focused branch → togglePanel
+      { keys: ['\\'], what: 'Show or hide the left sidebar.' },
+      // main/main.mjs before-input-event: ⌘Y / ⌘N answer the oldest approval.
+      // Its own card prints "⌘Y / ⌘N" beside Allow and Deny, so the words here
+      // are the card's words. It lives under this heading rather than under an
+      // open task because it is answered from anywhere at all.
+      { keys: ['⌘Y', '⌘N'], join: 'or', what: 'Allow or deny a card asking to run something.' },
+    ],
+  },
+];
+
+/** Every cap drawn on the page, flattened. The test walks this. */
+export function everyKey(groups = SHORTCUTS) {
+  return groups.flatMap((g) => g.keys.flatMap((k) => k.keys));
+}
+
+// WHAT AN AGENT IS TOLD, and it is this page and nothing else, so a key that
+// moves here has moved for every agent on its next run. The closing line is
+// the point: an agent's own saved memory is read before anything we hand it,
+// and on 2026-10-04 one said "press S" three days after S stopped scheduling.
+/** The keys as one block of plain text, for an agent's system prompt. */
+export function keysForAgents(groups = SHORTCUTS) {
+  const lines = [
+    `The keys in ${NAME}, the app this person reads you in, as they are today.`,
+    'When you tell them to press something, use these. Keys have moved before,',
+    'so a key you remember from an earlier session, a memory or a note that',
+    'disagrees with this list is out of date. Anything without a key is in ⌘K',
+    'by name.',
+  ];
+  for (const g of groups) {
+    lines.push('', `${g.label}:`);
+    for (const k of g.keys) lines.push(`- ${k.keys.join(k.join ? ` ${k.join} ` : ' ')}: ${k.what}`);
+  }
+  return lines.join('\n');
+}

package/shared/spawn-trouble.d.mts

@@ -6,3 +6,5 @@
 // main and by the tests, which are both plain JS and need nothing here.
 
 export function strandedTitle(count: number): string;
+/** The line in a thread where a run stopped, in our words; `raw` is the tool's own refusal. */
+export function runStoppedLine(raw: string): string;

package/shared/spawn-trouble.mjs

@@ -6,11 +6,11 @@
 // across the top of her inbox. Her three complaints were all correct. There is
 // no OAuth in Agentbox, so the sentence names a thing that does not exist here.
 // It is ugly. And it was on screen while agents were working perfectly well,
-// because it was about one of her two Claude accounts and not about the app.
+// because it was about one Claude account among several and not about the app.
 //
 // So the raw text never reaches the renderer again. It goes in the session's
 // own trace log, which is where a person debugging wants it, and what she is
-// shown is one sentence of ours written in her words.
+// shown is one sentence of ours written in plain words.
 //
 // Every sentence here has to survive the same test: read it out loud to
 // somebody who has never heard of a subprocess, and they know what happened
@@ -24,7 +24,7 @@
 // CODEX. It is right about Codex anyway, and that is measured rather than
 // assumed. On 2026-09-05 `codex app-server` (codex-cli 0.148.0) was driven the
 // way main/codex-app-server.mjs drives it, with CODEX_HOME pointed at an empty
-// directory so there was no auth.json and her real ~/.codex login was neither
+// directory so there was no auth.json and the real ~/.codex login was neither
 // read nor written. The turn retried ten times and failed with
 //
 // unexpected status 401 Unauthorized: Missing bearer or basic authentication in
@@ -41,18 +41,18 @@
 
 // AN ACCOUNT THAT IS SIGNED IN AND NOT ALLOWED TO RUN.
 //
-// She was. Her second login was intact and her browser sign-in succeeded every
-// time she did it; the WORKSPACE that account belongs to has Claude Code turned
-// off. Run by hand on her Mac, this is the whole of what the CLI says:
+// It happens. A login can be intact, with the browser sign-in succeeding every
+// time, while the WORKSPACE that account belongs to has Claude Code turned
+// off. Run by hand, this is the whole of what the CLI says:
 //
 //   Your organization has disabled Claude subscription access for Claude Code ·
 //   Use an Anthropic API key instead, or ask your admin to enable access
 //
 // "subscription access" is in the list below, so every one of those was filed
-// as a login that had run out and she was told to type /login. She did, twice
-// in one afternoon; both logins worked; nothing changed, because no login can
-// change an admin's policy. FOUR dead runs on one row that day, all four
-// carrying "Sign that account back in and it picks straight up."
+// as a login that had run out and the person was told to type /login. Doing
+// it again and again changes nothing, because no login can change an admin's
+// policy, and every dead run on the row carried "Sign that account back in
+// and it picks straight up."
 //
 // TESTED BEFORE SIGNED_OUT, which is the whole of the fix: these lines say
 // "subscription" and "access" and mean something else entirely.
@@ -188,9 +188,8 @@ export function troubleCause(raw) {
 //
 // carries the one thing she actually wants to know, and we were throwing it
 // away and then telling her the vaguer "when the limit resets". The timezone
-// is dropped rather than shown: this Mac is set to America/Los_Angeles and
-// every limit line in her store prints that same zone, so naming it would only
-// add a word she has to read. Null when there is no time to quote, and then
+// is dropped rather than shown: the limit line prints the zone the Mac is
+// already set to, so naming it would only add a word she has to read. Null when there is no time to quote, and then
 // the sentence falls back to the wording that has always been there.
 export function limitResetsAt(raw) {
   // Both wordings are real: the CLI's own line is "resets 6pm" and the API's
@@ -202,14 +201,14 @@ export function limitResetsAt(raw) {
 const MONTHS = ['jan', 'feb', 'mar', 'apr', 'may', 'jun', 'jul', 'aug', 'sep', 'oct', 'nov', 'dec'];
 
 // THE SAME HOUR AS A MOMENT, so the fleet can wait exactly until it
-// (2026-09-22: a limit that reset at 6:50pm held every agent until 7:03pm,
+// (a limit that reset at, say, 6:50pm could hold every agent until 7:03pm,
 // because the app waited a fixed thirty minutes instead of reading this line).
 // The next local occurrence of that clock time at or after `from`; null when
 // the line names no hour.
 export function limitResetMoment(raw, from = Date.now()) {
   // CODEX NAMES A DAY, NOT AN HOUR: "try again at Sep 28th, 2026 1:05 PM"
   // (codex-cli 0.153.4, 2026-09-24). A weekly limit read as "thirty minutes"
-  // put the capped login back in the pool every half hour for four days.
+  // put the capped login back in the pool every half hour for days.
   const dated = /try again at ([a-z]{3,9})\.? (\d{1,2})(?:st|nd|rd|th)?,? (\d{4}),? (\d{1,2}):(\d{2})\s*(am|pm)/i.exec(String(raw ?? ''));
   if (dated) {
     const month = MONTHS.indexOf(dated[1].slice(0, 3).toLowerCase());
@@ -250,7 +249,7 @@ export function troubleSentence(cause) {
   if (cause === 'at-limit') return 'No agents can start. Your Claude plan is at its limit.';
   if (cause === 'workspace') return 'No agents can start. Claude will not run in this folder.';
   if (cause === 'interrupted') return 'No agents can start. The connection to Claude keeps dropping.';
-  return 'No agents can start on this Mac right now.';
+  return 'No agents can start on this computer right now.';
 }
 
 // THE SECOND LINE: what happens next, so the first line is never a dead end.
@@ -343,8 +342,8 @@ export function engineTroubleNote(cause, engineWord = 'Codex') {
 // The count is the point, and it is why this is a different sentence from
 // `troubleSentence` above rather than a rewording of it. That one is about the
 // FLEET, and it can only ever be true when every account on the Mac is down at
-// once. That is why her screen stayed quiet: four Codex tasks and four on a
-// signed-out login sat there all day while her other agents worked, so the
+// once. That is why the screen could stay quiet: Codex tasks and tasks on a
+// signed-out login could sit there all day while the other agents worked, so the
 // fleet was never down and the one line the app owns was structurally unable to
 // speak. The subject here is her TASKS, which is the thing she went looking for
 // and the thing that was actually stuck.
@@ -443,6 +442,28 @@ const DEAD_RUN_OPENERS = {
   unknown: 'stopped before it did anything, so this task has not been started.',
 };
 
+/**
+ * THE LINE IN A THREAD WHERE A RUN STOPPED, in our words.
+ *
+ * The CLI types its own refusal into the run as if the agent had said it
+ * ("Failed to authenticate: OAuth session expired..."), and the thread drew it
+ * as the agent's message. This is about one run, not the task: a run that
+ * stops mid-thread has usually done plenty before it, so it says nothing about
+ * what has or has not been done.
+ */
+const RUN_STOPPED = {
+  'signed-out': 'This run stopped because the account was signed out.',
+  'org-blocked': 'This run stopped because that account is switched off by its organization.',
+  'at-limit': 'This run stopped because the account hit its usage limit.',
+  workspace: "This run stopped because it would not start in this project's folder.",
+  interrupted: 'This run was cut off in the middle.',
+  unknown: 'This run stopped before it finished.',
+};
+
+export function runStoppedLine(raw) {
+  return RUN_STOPPED[troubleCause(raw)] ?? RUN_STOPPED.unknown;
+}
+
 export function deadRunSentence({ engineWord = 'The agent', cause = 'unknown', runs = 1, resetsAt = null } = {}) {
   const opener = `${engineWord} ${DEAD_RUN_OPENERS[cause] ?? DEAD_RUN_OPENERS.unknown}`;
 
@@ -468,7 +489,7 @@ export function deadRunSentence({ engineWord = 'The agent', cause = 'unknown', r
 // WHAT GOES ON HER ROW WHEN THE RUN WAS FINE AND HER ANSWER STILL WENT NOWHERE.
 //
 // `settleDelivery` is two independent tests joined with an AND: did the process
-// exit cleanly, and did an agent leave a word on the row since she wrote. A run
+// exit cleanly, and did an agent leave a word on the row since the user wrote. A run
 // can pass the first and fail the second, and several ordinary ones do -- a
 // Codex turn that talks in its thread and never calls a store tool, a worker
 // that claims a row and finishes without writing, any session on an install

package/shared/team-rules.d.mts

@@ -0,0 +1,17 @@
+// Types for shared/team-rules.mjs, read by the renderer.
+type Row = { createdBy?: string | null; assignee?: string; runner?: string; people?: string[]; status?: string };
+type ProductLike = { team?: { projectId?: string; sharedBy?: string | null } | null } | null | undefined;
+
+export function isShared(product: ProductLike): boolean;
+export function runnerOf(item: Row, product: ProductLike): string | null;
+export function heldByAPerson(item: Row): boolean;
+export function mayRunHere(item: Row, product: ProductLike, me: string | null): boolean;
+export function inMyInbox(item: Row, product: ProductLike, me: string | null): boolean;
+export function lastSpeaker(item: Row): string | null;
+export function iSpokeLast(item: Row, product: ProductLike, me: string | null): boolean;
+export function handedOnByReply(item: Row, product: ProductLike, me: string | null): string | null;
+/** One thread you are in where somebody spoke after you (w-920461cbe6). */
+export interface ThreadWaiting { uid: string; mine: boolean; fresh: number; people: string[]; text: string; last: string; lastBy: string }
+/** What in a conversation waits on you; null on a row from before threads. */
+export interface Waits { chat: number; threads: ThreadWaiting[] }
+export function whatWaits(item: Row & { talk?: unknown }, me: string | null): Waits | null;