agentbox-app 0.1.13 → 0.1.16

package/shared/rank.mjs

@@ -69,19 +69,15 @@ export function placeScore(order, slug, direct) {
 /**
  * The number an item carries into that score.
  *
- * An AGENT'S tag counts for nothing. Agents used to set this themselves, on a
- * rule in the worker brief that told them 7 meant blocking; of the 442 items
- * agents filed, 127 came in at 7 or higher, which is not an order, it is
- * noise. She asked for the ordering to be the app's job, the rule is out of
- * the brief, and this is the half that also covers the items already sitting
- * in the store carrying an agent's 8.
- *
- * Everything else counts, and the test for "hers" is deliberately wide: her
- * compose box writes the number as 'system' rather than 'founder' (the split
- * in store.composeItem is words-versus-lifecycle, not authority), and a repeat
- * rule's number arrives the same way. Reading only 'founder' here would have
- * thrown away the Urgent tag on the very row she complained about
- * (tests/urgent-does-not-wait-behind-medium.test.mjs).
+ * A LEVEL COUNTS WHOEVER SET IT (w-5ac9c9006d, 2026-10-16). An agent's tag
+ * used to count for nothing, because agents once tagged 127 of 442 rows at 7
+ * or higher on an old brief rule. That made every level an agent wrote a lie
+ * on screen, and her answer was to stop discarding them: "If agent-determined
+ * priorities are ignored, then it seems like the whole prioritization system
+ * is ignored. If an agent sets something and I'm like, 'Oh that's the wrong
+ * priority,' I'll fix it. We should also always treat priorities as the
+ * source of truth, regardless of where they came from." Her fix is a new
+ * level, and the fold keeps hers over an agent's.
  *
  * Nought means untagged, not bottom. It is the seed the fold starts an item
  * at and the default her compose sends when she picks no number, and her own
@@ -93,11 +89,29 @@ export const DEFAULT_PRIORITY = 5;
 
 export function itemPriority(item) {
   if (!item) return DEFAULT_PRIORITY;
-  if (item.wrote?.priority?.source === 'agent') return DEFAULT_PRIORITY;
   const n = item.priority;
   return Number.isFinite(n) && n > 0 ? n : DEFAULT_PRIORITY;
 }
 
+/**
+ * THE LEVEL A THREAD SHOWS IS THE LEVEL IT RUNS AT (w-5ac9c9006d, 2026-10-15).
+ *
+ * Every screen drew the raw stored number while the fleet ran `itemPriority`,
+ * so a thread an agent filed untagged read Low and ran as Medium, and an
+ * agent's own 8 read High and ran as Medium. In Progress then showed three
+ * "Low" threads running while a "High" and a "Medium" waited. An agent's level
+ * now counts (above); an untagged row reads Medium here as it runs.
+ *
+ * A CONVERSATION keeps the number it carries: its level is the message
+ * sorter's (main/message-priority.mjs), written as an agent on purpose, and a
+ * conversation never spawns, so there is no running order for it to disagree
+ * with. `conversation` is the caller's to say, since only it knows the product.
+ */
+export function shownPriority(item, conversation = false) {
+  if (conversation) return item?.priority ?? null;
+  return itemPriority(item);
+}
+
 /**
  * The top of her own scale, and the only level that INTERRUPTS.
  *
@@ -110,12 +124,11 @@ export function itemPriority(item) {
 export const URGENT_PRIORITY = 9;
 
 /**
- * Is this HER urgent row?
+ * Is this row Urgent?
  *
- * itemPriority already throws away an agent's number, so this cannot be
- * reached by a worker tagging its own proposal a nine. That matters more here
- * than anywhere else in this file: everything downstream of this predicate
- * takes a running session away from something else.
+ * Whoever set it, since 2026-10-16 (itemPriority). Everything downstream of
+ * this predicate takes a running session away from something else, so an
+ * agent's nine interrupts like hers; a wrong one is hers to lower.
  */
 export function isUrgent(item) {
   return itemPriority(item) >= URGENT_PRIORITY;

package/shared/repeats.d.mts

@@ -28,6 +28,10 @@ export const REPEAT_LABEL_PREFIX: string;
 export function repeatLabel(ruleId: string): string;
 export function ruleIdOf(item: { labels?: string[] } | null | undefined): string | null;
 export function isCleanRun(item: { labels?: string[] } | null | undefined): boolean;
+export function runToOpen<T extends { id: string; product: string; labels?: string[]; createdAt: number }>(
+  rule: { id: string; product: string; lastOccurrence?: string },
+  items: T[],
+): T | null;
 export const DAY_NAMES: string[];
 export function isRepeatRule(rule: unknown): boolean;
 export function ruleLabel(rule: unknown): string;
@@ -43,3 +47,7 @@ export function foldRepeats(
   lines: Array<{ id: string; ts: number; patch: Record<string, unknown> } | null>,
   now?: number,
 ): Map<string, RepeatRule>;
+export const PROTOCOL_OPENS: string;
+export const INSTRUCTION_MARK: string;
+/** A repeating run's body without the agent's rules in front of it; any other body whole. */
+export function instructionOf(body: string | null | undefined): string;

package/shared/repeats.mjs

@@ -15,6 +15,16 @@ const KEY_RE = /^\d{4}-\d{2}-\d{2}$/;
 export const CLEAN_LABEL = 'clean';
 export const REPEAT_LABEL_PREFIX = 'repeat:';
 
+// A run's body is the app's rules for the agent (main/repeats.mjs), then the
+// person's instruction after INSTRUCTION_MARK. Screens show the instruction.
+export const PROTOCOL_OPENS = 'THIS IS ONE RUN OF A REPEATING TASK.';
+export const INSTRUCTION_MARK = 'HER INSTRUCTION FOLLOWS.';
+export function instructionOf(body) {
+  const text = String(body ?? '');
+  const at = text.indexOf(`\n${INSTRUCTION_MARK}\n`);
+  return text.startsWith(PROTOCOL_OPENS) && at >= 0 ? text.slice(at + INSTRUCTION_MARK.length + 2).trim() : text;
+}
+
 export function repeatLabel(ruleId) {
   return `${REPEAT_LABEL_PREFIX}${ruleId}`;
 }
@@ -24,14 +34,35 @@ export function ruleIdOf(item) {
   return found ? found.slice(REPEAT_LABEL_PREFIX.length) : null;
 }
 
+// THE STANDING INSTRUCTION: the words every run after this one is briefed with.
+// `serve` copies this into each occurrence's body under the protocol, and the
+// store tool an agent changes it through reads and writes the same thing, so
+// what the tool shows a run is what the next run gets.
+export function standingInstruction(rule) {
+  return rule?.body ?? rule?.title;
+}
+
 // A clean run is one the worker EXPLICITLY marked clean. Everything else is news
 // and reaches her, including a run that died without saying anything: this
 // predicate exists to hide, never to show, so it fails open by construction.
 export function isCleanRun(item) {
-  return !!ruleIdOf(item) && (item?.labels ?? []).includes(CLEAN_LABEL);
+  const labels = item?.labels ?? [];
+  const aRun = !!ruleIdOf(item) || labels.some((l) => typeof l === 'string' && (l.startsWith('teammate:') || l === 'teammate-offer'));
+  return aRun && labels.includes(CLEAN_LABEL);
+}
+
+// THE THREAD AN OPENED REPEATING TASK LANDS ON: its latest run, an ordinary
+// work item, so the Reply box under it messages that run's agent like any
+// other thread (w-5e3f2e047f). The run it last served first; when that one has
+// left the store's window, the newest of its runs still on file. Null before
+// the first run, and never a run of another rule or another project.
+export function runToOpen(rule, items) {
+  const mine = (items ?? []).filter((i) => i.product === rule.product && ruleIdOf(i) === rule.id);
+  return mine.find((i) => i.id === rule.lastOccurrence)
+    ?? mine.reduce((newest, i) => (!newest || i.createdAt > newest.createdAt ? i : newest), null);
 }
 
-export const DAY_NAMES = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'];
+export const DAY_NAMES = ['Sunday','Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'];
 
 // Three shapes, because they are the three a founder actually asks for:
 //   { every: 'day',     at }        every morning

package/shared/room-cards.mjs

@@ -0,0 +1,167 @@
+// A ROOM'S WALL AND THE ROW MY MAC PUBLISHES FOR IT (w-3d0fa23ffb).
+//
+// Pure. Rows are as the cloud sends them (cloud/supabase/migrations/
+// 20261021000000_rooms.sql): `room_profiles` say what a person lets a card
+// show, `room_presence` is one row per Mac. docs/team/ROOMS-PLAN.md has the
+// rules; the test is tests/a-room-wall-shows-each-person-as-they-chose.
+import { levelFor, localDate, streakOf } from './agent-hours.mjs';
+import { visibilityOf } from './thread-cards.mjs';
+
+export const PRESENCE_STALE_MS = 15 * 60_000;
+export const WORKING_ON_MAX = 64;
+const DAY_MS = 86_400_000;
+
+export function displayNameOf(name, { full = false } = {}) {
+  let s = String(name ?? '').trim();
+  if (s.includes('@')) s = s.split('@')[0];
+  const words = s.split(/\s+/).filter(Boolean);
+  if (words.length < 2 || full) return words.join(' ');
+  return `${words[0]} ${words.at(-1)[0].toUpperCase()}.`;
+}
+
+const ms = (v) => (v == null ? NaN : typeof v === 'number' ? v : Date.parse(v));
+// A date the publisher wrote in their own zone, read as local midnight here.
+const dayMs = (d) => (typeof d === 'string' ? new Date(`${d}T00:00:00`).getTime() : NaN);
+const num = (v) => (Number.isFinite(Number(v)) ? Number(v) : 0);
+
+function sumPresence(rows, now) {
+  let agents = 0, total = 0, week = 0, today = 0;
+  const days = new Set();
+  const months = new Map();
+  let lead = null;
+  for (const r of rows) {
+    if (r.gone) continue;
+    total += num(r.hours_total);
+    if (now < dayMs(r.week_start) + 7 * DAY_MS) week += num(r.hours_week);
+    if (now < dayMs(r.day) + DAY_MS) today += num(r.hours_today);
+    for (const d of r.active_days ?? []) days.add(String(d).slice(0, 10));
+    for (const m of Array.isArray(r.hours_by_month) ? r.hours_by_month : []) {
+      if (typeof m?.month === 'string') months.set(m.month, (months.get(m.month) ?? 0) + num(m.hours));
+    }
+    const fresh = now - ms(r.updated_at) < PRESENCE_STALE_MS;
+    if (!fresh || !(num(r.agents_running) > 0)) continue;
+    agents += num(r.agents_running);
+    if (!lead || (ms(r.working_at) || 0) > (ms(lead.working_at) || 0)) lead = r;
+  }
+  const byMonth = [...months].sort(([a], [b]) => a.localeCompare(b)).map(([month, hours]) => ({ month, hours }));
+  return { agents, total, week, today, streak: streakOf([...days], now), byMonth, lead };
+}
+
+function workingOf({ profile, lead, teammate, cards }) {
+  const none = { workingOn: null, workingPrivate: false };
+  if (!lead) return none;
+  if (profile.show_working === 'none' || lead.working_private) return { workingOn: null, workingPrivate: true };
+  if (profile.show_working === 'everyone' && lead.working_on) return { workingOn: lead.working_on, workingPrivate: false };
+  // Running, and no name this viewer may read: it says Private thread.
+  const hidden = { workingOn: null, workingPrivate: true };
+  if (!teammate) return hidden;
+  const card = cards
+    .filter((c) => c.state === 'running' && c.visible !== false && c.title)
+    .sort((a, b) => num(b.updatedAt) - num(a.updatedAt))[0];
+  return card ? { workingOn: String(card.title).slice(0, WORKING_ON_MAX), workingPrivate: false } : hidden;
+}
+
+// One card per member with a profile, sorted by name so cards never jump.
+// Invisible people are already hidden from others by the cloud; my own
+// profile still reaches me, so I leave my own wall too. `mine` is what this
+// Mac knows I am working on, which my own card shows whatever others see.
+// `names` is the cloud's room_names for this room, or null on a cloud without
+// it: a member with no card at all is on the wall, named, as not on Rooms yet.
+// In a `listed` room, open to anyone, my own card shows me what strangers see.
+export function wallCards({ members = [], profiles = [], presence = [], teammates = [], teamCards = [], meId = null, now = Date.now(), mine = null, names = null, listed = false }) {
+  const inRoom = new Set(members);
+  const mates = new Set(teammates);
+  const out = [];
+  for (const p of profiles) {
+    if (!p?.person_id || !inRoom.has(p.person_id)) continue;
+    if (now < ms(p.invisible_until)) continue;
+    const id = p.person_id;
+    const s = sumPresence(presence.filter((r) => r.person_id === id), now);
+    const cards = teamCards.filter((c) => c.personId === id);
+    out.push({
+      id,
+      me: id === meId,
+      name: p.display_name || '',
+      avatarUrl: p.avatar_url ?? null,
+      headline: p.headline ?? null,
+      bio: p.bio ?? null,
+      // My own count is this Mac's, not the cloud's last word on it.
+      agents: p.show_agents === false ? null : id === meId && Number.isFinite(mine?.agents) ? mine.agents : s.agents,
+      level: p.show_level === false ? null : levelFor(s.total),
+      hoursTotal: s.total,
+      hoursWeek: s.week,
+      hoursToday: s.today,
+      streak: s.streak,
+      byMonth: s.byMonth,
+      teammate: mates.has(id) && id !== meId,
+      showActivity: p.show_activity !== false,
+      // A list of threads an older Mac still sends is read by nobody.
+      activity: null,
+      status: p.show_status !== false && p.status_text && !(ms(p.status_until) <= now) ? p.status_text : null,
+      ...(id === meId && mine ? ownWorking(mine, listed && p.show_working !== 'everyone')
+        : workingOf({ profile: p, lead: s.lead, teammate: mates.has(id) && id !== meId, cards })),
+    });
+  }
+  for (const n of names ?? []) {
+    if (n.has_card || !inRoom.has(n.person_id) || n.person_id === meId) continue;
+    out.push({
+      id: n.person_id, me: false, away: true, name: displayNameOf(n.name), avatarUrl: n.avatar_url ?? null, headline: null, bio: null,
+      agents: null, level: null, hoursTotal: 0, hoursWeek: 0, hoursToday: 0, streak: 0, byMonth: [],
+      teammate: mates.has(n.person_id), showActivity: false, activity: null, status: null, workingOn: null, workingPrivate: false,
+    });
+  }
+  return out.sort((a, b) => a.name.localeCompare(b.name) || a.id.localeCompare(b.id));
+}
+
+const ownWorking = (mine, hidden) => (hidden
+  ? { workingOn: null, workingPrivate: !!mine.workingOn }
+  : { workingOn: mine.workingOn ?? null, workingPrivate: false });
+
+const shortName = (item) => (String(item?.label ?? '').trim() || String(item?.title ?? '')).slice(0, WORKING_ON_MAX);
+
+// The presence row this Mac sends. `running` is the supervisor's running
+// sessions ({itemId, product, startedAt}); `summary` is summarizeRuns'.
+// A thread is named only when its project and its own word leave it to the
+// whole team, and only when I let everyone see it: realtime sends whole rows,
+// so a name on the row reaches everyone in my rooms.
+export function myPresence({ running = [], items = [], products = [], summary, now = Date.now(), showWorking = 'everyone' }) {
+  const lead = [...running].sort((a, b) => num(b.startedAt) - num(a.startedAt))[0];
+  let working_on = null;
+  let working_private = false;
+  if (lead && showWorking !== 'none') {
+    const item = items.find((i) => i.id === lead.itemId);
+    const product = products.find((p) => p.slug === (item?.product ?? lead.product));
+    const v = item ? visibilityOf(item, product) : 'private';
+    if (v !== undefined && v !== 'team') working_private = true;
+    else if (showWorking === 'everyone') working_on = shortName(item) || null;
+  }
+  return {
+    agents_running: running.length,
+    working_on,
+    working_private,
+    working_at: lead ? new Date(num(lead.startedAt) || now).toISOString() : null,
+    hours_total: round2(summary?.total),
+    hours_week: round2(summary?.week),
+    week_start: summary?.weekStart ?? localDate(now),
+    hours_today: round2(summary?.today),
+    day: summary?.day ?? localDate(now),
+    streak_days: summary?.streak ?? 0,
+    active_days: summary?.activeDays ?? [],
+    hours_by_month: summary?.byMonth ?? [],
+    // Never a list of threads: it reached everyone in my rooms.
+    activity: [],
+  };
+}
+
+const round2 = (v) => Math.round(num(v) * 100) / 100;
+
+// A switch turned off keeps that value off the cloud, so nobody can read it
+// from the row, a realtime event or an invite preview.
+export function withoutHidden(row, profile) {
+  const out = { ...row };
+  if (profile?.show_agents === false) out.agents_running = 0;
+  if (profile?.show_level === false) {
+    Object.assign(out, { hours_total: 0, hours_week: 0, hours_today: 0, streak_days: 0, active_days: [], hours_by_month: [] });
+  }
+  return out;
+}

package/shared/room-links.d.mts

@@ -0,0 +1,4 @@
+export const JOIN_SCHEME: string;
+export const JOIN_SITE: string;
+export function joinLink(token: string): string;
+export function tokenFromLink(text: unknown): string | null;

package/shared/room-links.mjs

@@ -0,0 +1,21 @@
+// A room's invite link (docs/team/ROOMS-PLAN.md, Joining): the web address
+// people share, and the app's own scheme that page opens.
+import { nameSlug } from './product-name.mjs';
+
+export const JOIN_SCHEME = nameSlug;
+export const JOIN_SITE = `https://${nameSlug}.ac/join/`;
+
+export const joinLink = (token) => `${JOIN_SITE}${token}`;
+
+/** Any link on the app's own scheme: a room invite, or Stripe's way back. */
+export const ourLink = (url) => typeof url === 'string' && url.startsWith(`${JOIN_SCHEME}://`);
+
+const TOKEN = /^[A-Za-z0-9_-]{16,64}$/;
+
+/** The token in a pasted link or a deep link, or the token itself; null for anything else. */
+export function tokenFromLink(text) {
+  const s = String(text ?? '').trim();
+  if (TOKEN.test(s)) return s;
+  const m = /^(?:https?:\/\/[^/\s]+\/join\/|[a-z][a-z0-9+.-]*:\/\/join\/)([A-Za-z0-9_-]+)\/?(?:[?#].*)?$/i.exec(s);
+  return m && TOKEN.test(m[1]) ? m[1] : null;
+}

package/shared/runs-on.d.mts

@@ -1,10 +1,10 @@
 export interface RunsOn {
-  /** 'claude' or 'codex', or null on a Mac where nothing is signed in. */
+  /** 'claude' or 'codex', or null on a computer where nothing is signed in. */
   engine?: string | null;
 }
 
 /** The word for the plan behind an engine, or null for one we cannot name. */
 export declare function runsOnName(engine?: string | null): string | null;
 
-/** The one line the walk says on a Mac that was already set up. Null for null. */
-export declare function foundOnThisMac(facts?: RunsOn): string | null;
+/** The one line the walk says where it was already set up. Null for null. */
+export declare function foundOnThisComputer(facts?: RunsOn): string | null;

package/shared/runs-on.mjs

@@ -1,11 +1,11 @@
-// THE ONE LINE SAYING IT FOUND AN ACCOUNT ALREADY ON THIS MAC.
+// THE ONE LINE SAYING IT FOUND AN ACCOUNT ALREADY ON THIS COMPUTER.
 //
 // From a session with a new user, 2026-10-07, in her words: a new user came in,
 // started running an agent, and was "like, 'Oh my God, where are the tokens
 // coming from? I didn't even connect my account.'"
 //
 // 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
+// already signed in on the computer 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
@@ -43,13 +43,16 @@ export function runsOnName(engine) {
 }
 
 /**
- * THE ONE LINE DURING THE WALK, on the Mac where there was nothing to ask.
+ * THE ONE LINE DURING THE WALK, on the computer 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.
+ *
+ *  It says computer rather than Mac: Agentbox runs on Linux too, and one
+ *  sentence beats a branch, since "this computer" is true on a Mac as well.
  */
-export function foundOnThisMac({ engine = null } = {}) {
+export function foundOnThisComputer({ engine = null } = {}) {
   const name = runsOnName(engine);
   if (!name) return null;
-  return `Your agents will run on the ${name} account already signed in on this Mac.`;
+  return `Your agents will run on the ${name} account already signed in on this computer.`;
 }

package/shared/shipped-note.d.mts

@@ -0,0 +1,4 @@
+// Types for shared/shipped-note.mjs.
+
+export function shippedNote(sha?: string | null): string;
+export function isShippedNote(text: unknown): boolean;

package/shared/shipped-note.mjs

@@ -0,0 +1,6 @@
+// The note the app writes on a row once its ship lands (main/store.mjs), and
+// the one reader that has to know it is the app's and not an agent's
+// (renderer/src/format.ts, offerIsLive).
+export const shippedNote = (sha) => (sha ? `Shipped to main as ${sha}.` : 'Shipped to main.');
+
+export const isShippedNote = (text) => /^Shipped to main(?: as [0-9a-f]{7,40})?\.$/.test(String(text ?? '').trim());

package/shared/shortcuts.mjs

@@ -93,6 +93,7 @@
 // touching it, so the row names no sections at all.
 
 import { NAME } from './product-name.mjs';
+import { chordOf, everyChord } from './key-caps.mjs';
 
 /** @type {import('./shortcuts.d.mts').ShortcutGroup[]} */
 export const SHORTCUTS = [
@@ -199,10 +200,11 @@ export const SHORTCUTS = [
       // (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).
+      // 'n' in both branches → setModal('compose').
       // "Threads", not tasks, since w-ec62ab6b38.
       { keys: ['N'], what: 'Start a new thread.' },
+      // cloudChord in the chords → toggleCloudRef: the cloud on or off.
+      { keys: ['⌘C'], what: 'Turn the cloud on or off, when no text is selected.' },
       // '/' above the focused branch → openSearch
       { keys: ['/'], what: 'Search your threads.' },
       // '\\' above the focused branch → togglePanel
@@ -225,18 +227,24 @@ export function everyKey(groups = SHORTCUTS) {
 // 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.
+// And in the glyphs of the keyboard in front of them: an agent telling
+// somebody on Linux to "press ⌘K" names a key they do not have, which is the
+// same mistake as a stale memory.
 /** The keys as one block of plain text, for an agent's system prompt. */
-export function keysForAgents(groups = SHORTCUTS) {
+export function keysForAgents(groups = SHORTCUTS, { mac = true } = {}) {
   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.',
+    'disagrees with this list is out of date. Anything without a key is in',
+    `${chordOf('⌘K', mac)} 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}`);
+    for (const k of g.keys) {
+      const keys = everyChord(k.keys, mac);
+      lines.push(`- ${keys.join(k.join && keys.length > 1 ? ` ${k.join} ` : ' ')}: ${k.what}`);
+    }
   }
   return lines.join('\n');
 }

package/shared/spawn-trouble.d.mts

@@ -8,3 +8,7 @@
 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;
+/** True when `text` is the app's own word that a run got nowhere. */
+export function saysARunGotNowhere(text: string | null | undefined): boolean;
+/** What one account's tile says when it cannot run; `dir` is its config folder, for the sign-in command. */
+export function accountSentence(cause: string, dir?: string | null): string;