agentbox-app 0.1.6

package/shared/claude-commands.mjs

@@ -0,0 +1,131 @@
+// 2026-09-16: generated headless commands plus names advertised by the current
+// native session. The eight-command notes below describe the original design.
+// WHAT "/" MEANS IN AGENTBOX, NOW THAT IT MEANS TWO THINGS.
+//
+// She was then given three ways to do it and picked the middle one: "Keep the
+// six modes at the top and add only the ones that say something about how a
+// message runs: /model, /effort, /fast, /goal, /context, /usage, /mcp,
+// /compact. Read them out of the installed binary at build time rather than
+// typing them into a file, so the list cannot rot quietly."
+//
+// THE READING HALF IS scripts/read-claude-commands.mjs AND THE TABLE IT WRITES.
+// This file is the thinking on top of it, and it is short on purpose.
+//
+// THE ONE MEASUREMENT THAT SHAPED EVERYTHING HERE, taken on 2026-08-27 against
+// the installed 2.1.246, because the obvious design does not work:
+//
+//   claude -p '/context
+//
+//   Then in one short sentence say what file is in this directory.'
+//
+//   returned the context table and NOTHING ELSE. 142 lines, zero mentions of
+//   the file and zero mentions of the word directory. The command ate the
+//   message.
+//
+// SO A COMMAND CANNOT RIDE ALONG WITH HER REPLY. It is not a modifier on a
+// message the way a permission mode is; it is a turn of its own, exactly as it
+// is in Claude Code, where typing /context does not also send whatever you had
+// half-written. That is why picking one of these eight from the menu TYPES it
+// into the box instead of setting a hidden value on the send: what she is about
+// to do is send a command, and the box should say so before she presses Send.
+//
+// AND WHAT COMES BACK IS THE CONFIRMATION SHE ASKED FOR. Agentbox's trace
+// already renders assistant text into the thread, so the answer arrives on the
+// row by itself. Nothing had to be invented to show it.
+//
+// THE SIX MODES ARE NOT IN HERE and must not move into it. They are ours, they
+// set a value on a message she is still writing, and five of the six are not
+// Claude Code commands at all. modes.ts says all of that at length. The menu
+// draws both lists; they are two different verbs and the menu labels them so.
+
+import { CLAUDE_COMMANDS, READ_FROM, READ_AT } from './claude-commands.generated.mjs';
+
+export { CLAUDE_COMMANDS, READ_FROM, READ_AT };
+
+/**
+ * Every spelling that reaches a command: its own name and the aliases Claude
+ *  Code registers for it. `/cost` and `/stats` are theirs, for `/usage`. */
+export function commandWords(cmd) {
+  return [cmd.name, ...(cmd.aliases ?? [])];
+}
+
+/**
+ * The line the menu prints beside the command. Claude Code's own shorter
+ *  sentence where they wrote one for a menu, otherwise their full one.
+ *
+ * WITH THE EM DASHES TAKEN OUT, and that has to happen here rather than in the
+ * generated file. One of the eight carries one today: `/goal` reads "Set a goal
+ * — keep working until the condition is met", and that sentence is Claude
+ * Code's, read out of the installed binary at build time. Editing it where it
+ * lands would be undone by the next `npm run build` and would make the file
+ * stop matching the binary, which is the whole reason it is generated. So the
+ * record stays faithful and the MENU does the spelling. A comma, because these
+ * are all one short sentence with a pause in it. */
+export function commandHint(cmd) {
+  return (cmd.menuDescription || cmd.description).replace(/\s*—\s*/g, ', ');
+}
+
+/**
+ * The rows the menu draws for what has been typed so far, in her order.
+ *
+ *  Prefix on the name first and on an alias second, which is the same rule
+ *  modeMatches follows and for the same reason: a word appearing inside a
+ *  longer word is a coincidence, and a menu that moves its cursor on a
+ *  coincidence feels random. */
+export function commandMatches(query) {
+  if (query === null || query === undefined) return [];
+  if (query === '') return [...CLAUDE_COMMANDS];
+  const first = CLAUDE_COMMANDS.filter((c) => c.name.startsWith(query));
+  const alias = CLAUDE_COMMANDS.filter(
+    (c) => !first.includes(c) && commandWords(c).some((w) => w.startsWith(query)),
+  );
+  return [...first, ...alias];
+}
+
+/**
+ * What picking a row puts in the box. A trailing space, always, because every
+ *  one of the eight either takes an argument or is harmless with none, and a
+ *  caret sitting after the space is what tells somebody there is more to type.
+ *  It is never sent by the pick: she presses Send, the same as any message. */
+export function commandDraft(cmd) {
+  return `/${cmd.name} `;
+}
+
+/* --------------------- and the other end, in the run ---------------------- */
+
+/**
+ * WHETHER A REPLY IS ONE OF THE EIGHT, asked by the supervisor at the moment it
+ * decides what to hand the CLI.
+ *
+ * Returns the prompt to send verbatim, or null for an ordinary message. Null is
+ * the answer for everything that is not exactly one of these commands, because
+ * this decides whether a message SKIPS the brief, and a brief skipped by
+ * accident is a worker that does not know which row it is on.
+ *
+ * THE RULES, AND EACH ONE IS A THING THAT WOULD OTHERWISE GO WRONG:
+ *
+ *   - The slash is the first character. A slash mid-sentence is a path or a
+ *     date. Same rule as slashQuery in modes.ts.
+ *   - The word after it is one of the eight, or one of their aliases. Not any
+ *     command Claude Code has: the other 94 are not on the menu, so a person
+ *     typing one has not been told it would run, and 70 of them cannot run
+ *     outside an interactive session at all.
+ *   - Everything after the word is the argument and is passed through
+ *     untouched, including newlines, because `/goal <condition>` and
+ *     `/compact <instructions>` are sentences.
+ *   - The name is normalised to the command's own name, so `/cost` reaches the
+ *     CLI as `/usage`. An alias is a spelling for us; the CLI takes both, and
+ *     sending its own word is one less thing to be wrong about.
+ */
+export function commandPrompt(reply, nativeNames = []) {
+  if (typeof reply !== 'string') return null;
+  if (!reply.startsWith('/')) return null;
+  const m = reply.match(/^\/([a-z][a-z0-9:_-]*)(?:(\s[\s\S]*))?$/i);
+  if (!m) return null;
+  const typed = m[1].toLowerCase();
+  const word = typed === 'review' && nativeNames.includes('code-review') ? 'code-review' : typed;
+  const cmd = CLAUDE_COMMANDS.find((c) => commandWords(c).includes(word)) ?? (nativeNames.includes(word) ? { name: word } : null);
+  if (!cmd) return null;
+  const rest = (m[2] ?? '').trim();
+  return rest ? `/${cmd.name} ${rest}` : `/${cmd.name}`;
+}

package/shared/claude-models.generated.d.mts

@@ -0,0 +1,15 @@
+// GENERATED BY scripts/read-claude-models.mjs. DO NOT EDIT BY HAND.
+
+export declare const READ_FROM: string | null;
+export declare const READ_AT: string;
+
+export declare const CLAUDE_MODELS: ReadonlyArray<{
+  /** What Agentbox sends the CLI: an alias, never a version. */
+  alias: string;
+  /** What that alias resolved to on the Claude Code that built this. */
+  id: string;
+  /** Claude Code's own display name for that id, e.g. "Opus 5". */
+  label: string;
+  /** The level it thinks at when nobody picks one, out of the same catalog. */
+  defaultLevel: string | null;
+}>;

package/shared/claude-models.generated.mjs

@@ -0,0 +1,26 @@
+// GENERATED BY scripts/read-claude-models.mjs. DO NOT EDIT BY HAND.
+//
+// Which model each alias really is, and Claude Code's own name for it, read
+// out of the copy of Claude Code installed on the machine that built this.
+// `npm run build` rewrites it. Committed so a machine with no Claude Code on
+// it can still build, and so a version that points an alias at a different
+// model shows up as a diff rather than as a wrong label on the picker.
+//
+// WHY IT IS READ AND NOT TYPED: labelling a model wrong is expensive, because
+// Agentbox sends the alias, the CLI decides what the alias means, and a version
+// number typed into a file of ours would look authoritative while being a
+// guess. Running an old model by mistake is the failure being avoided.
+
+export const READ_FROM = "2.1.283";
+export const READ_AT = "2026-09-29";
+
+export const CLAUDE_MODELS = [
+  {"alias":"opus","id":"claude-opus-5-5","label":"Opus 5.5","defaultLevel":"medium"},
+  {"alias":"claude-opus-5","id":"claude-opus-5","label":"Opus 5","defaultLevel":"high"},
+  {"alias":"sonnet","id":"claude-sonnet-5","label":"Sonnet 5","defaultLevel":"high"},
+  {"alias":"claude-sonnet-4-6","id":"claude-sonnet-4-6","label":"Sonnet 4.6","defaultLevel":null},
+  {"alias":"haiku","id":"claude-haiku-4-5","label":"Haiku 4.5","defaultLevel":null},
+  {"alias":"claude-3-5-haiku","id":"claude-3-5-haiku","label":"Haiku 3.5","defaultLevel":null},
+  {"alias":"fable","id":"claude-fable-5-1","label":"Fable 5.1","defaultLevel":"high"},
+  {"alias":"claude-fable-5","id":"claude-fable-5","label":"Fable 5","defaultLevel":"high"},
+];

package/shared/claude-usage.d.mts

@@ -0,0 +1,16 @@
+// Types for shared/claude-usage.mjs, which the renderer imports and which is
+// plain JavaScript because main imports it too. Hand-written and short: the
+// module is one parser and the timezone arithmetic under it.
+//
+// The words the panel prints moved to shared/usage.mjs on 2026-09-05, and their
+// declarations went with them. `UsageLimit` is declared there too, because a
+// limit is a limit whichever coding agent reported it.
+
+import type { UsageLimit } from './usage.d.mts';
+
+export declare function resetAt(text: string, now?: number, zoneNow?: string | null): number | null;
+export declare function readUsage(text: string | null | undefined, now?: number, zoneNow?: string | null): UsageLimit[];
+export declare function pillText(
+  limits: UsageLimit[] | null | undefined,
+  now?: number,
+): { used: string; when: string | null } | null;

package/shared/claude-usage.mjs

@@ -0,0 +1,172 @@
+// WHAT IS LEFT OF HER LIMIT, OUT OF CLAUDE CODE'S OWN `/usage`.
+//
+// He is right that it is the number that decides how many agents get started,
+// and right that going elsewhere to read it defeats the point of the inbox.
+//
+// THERE ARE THREE LIMITS, NOT ONE, and that is the first thing measuring changed
+// about his ask. Verbatim off her Mac, 2026-08-31 16:47:
+//
+//   Current session: 29% used · resets Aug 31 at 6:19pm (America/Los_Angeles)
+//   Current week (all models): 6% used · resets Sep 3 at 3:59pm (America/Los_Angeles)
+//   Current week (Fable): 2% used · resets Sep 3 at 3:59pm (America/Los_Angeles)
+//
+// AND IT IS SLOW. Timed twice on the same machine: 23.2s and 28.0s. So this can
+// never be live, and nothing that reads it may block a window being drawn.
+//
+// This file is the PURE half: the text in, the three limits out. It is pure so
+// the reading is pinned by tests rather than by a screenshot. Running the
+// command is main/claude-usage.mjs.
+//
+// THE WORDS THE PANEL PRINTS LEFT THIS FILE ON 2026-09-05, and they went to
+// shared/usage.mjs. What is Claude Code's is still here: this text format, the
+// timezone stamp it prints, and the refusal to count down from a stamp computed
+// somewhere else. What belongs to a LIMIT, any limit, is next door.
+
+import { instantIn, localZone, sessionLimit, untilReset, wallIn } from './usage.mjs';
+
+/** One limit, as the CLI reported it. */
+// { span, qualifier, name, percent, resetsAt|null, resetsText, resetsOn, zone }
+
+const LINE = /^Current\s+(session|week)(?:\s*\(([^)]+)\))?\s*:\s*(\d+)%\s*used(?:\s*·\s*resets\s+(.+?))?\s*$/i;
+// THE MINUTES ARE OPTIONAL, AND THAT IS WHY HER CORNER WENT QUIET. Claude Code
+// drops the ":00" when a reset lands on the hour, so the stamp on her Mac read
+// "Sep 1 at 4pm" and this refused it. Refusing it took the countdown out of the
+// pill AND out of the tooltip, which left the wordless "41%" she photographed
+// and could not read. It is one hour in every five.
+//
+// THE AM/PM HALF STAYS REQUIRED. An hour on its own is ambiguous by twelve
+// hours, and the standing rule in this file is to refuse rather than guess.
+const RESET = /^([A-Z][a-z]{2})\s+(\d{1,2})\s+at\s+(\d{1,2})(?::(\d{2}))?\s*([ap])m(?:\s*\(([^)]+)\))?/i;
+const MONTHS = ['jan', 'feb', 'mar', 'apr', 'may', 'jun', 'jul', 'aug', 'sep', 'oct', 'nov', 'dec'];
+
+/**
+ * WHEN A RESET ACTUALLY IS, from the stamp the CLI prints.
+ *
+ * The stamp has no year on it, so the year is taken from `now` and rolled
+ * forward when that would put the reset more than a day in the past, which is
+ * the December-to-January case and the only one it can be.
+ *
+ * IT REFUSES RATHER THAN GUESSES WHEN THE ZONE IS NOT THIS MACHINE'S. Claude Code
+ * prints the zone it computed the stamp in. When that is the zone this machine is
+ * in, reading "6:19pm" as local time is exactly right. When it is not, the
+ * difference is however many hours, and a countdown built on that would be
+ * confidently wrong. So it returns null and the caller prints the clock time
+ * instead, which is true in either case.
+ *
+ * AND THE CLOCK TIME IS READ IN THAT ZONE, NOT IN THE PROCESS'S (2026-09-04).
+ * This function has taken `zoneNow` since it was written, and used it for the
+ * refusal above and for nothing else: the instant itself came out of
+ * `new Date(y, m, d, h, min)`, which reads those fields in whatever zone the
+ * PROCESS happens to be in. On her Mac the two are the same zone and every
+ * answer was right, which is why it survived. Anywhere else it is silently out
+ * by the difference: running this suite in Asia/Tbilisi against her verbatim
+ * America/Los_Angeles reading put every reset eleven hours early, which turned
+ * `pillText`'s "2h 14m left" into "any moment" and made the panel print
+ * "Resets Sep 1 at 4pm" for a reset that was today. A function handed the
+ * moment AND the zone and then reading one of them off the machine cannot be
+ * tested, and it rots the day it leaves the desk it was written on.
+ */
+export function resetAt(text, now = Date.now(), zoneNow = localZone()) {
+  const m = RESET.exec(String(text ?? '').trim());
+  if (!m) return null;
+  const [, mon, day, hour12, minute, half, zone] = m;
+  if (zone && zoneNow && zone !== zoneNow) return null;
+  const month = MONTHS.indexOf(mon.toLowerCase());
+  if (month < 0) return null;
+  let hour = Number(hour12) % 12;
+  if (half.toLowerCase() === 'p') hour += 12;
+  // Absent minutes mean the hour exactly, which is what the CLI means by
+  // printing "4pm". It is a default for a stamp that omitted them, never a
+  // guess at ones it printed and we failed to read.
+  const min = minute === undefined ? 0 : Number(minute);
+  // The stamp carries no year, so it comes from `now` READ IN THE SAME ZONE the
+  // clock time is about to be read in. Taking the year from one zone and the
+  // day from another is a one-day error for the few hours a year they disagree.
+  const year = wallIn(now, zoneNow)?.year ?? new Date(now).getFullYear();
+  let at = instantIn(year, month, Number(day), hour, min, zoneNow);
+  // A reset a long way behind us is last year's date read as this year's.
+  if (at < now - 24 * 3_600_000) at = instantIn(year + 1, month, Number(day), hour, min, zoneNow);
+  return at;
+}
+
+/**
+ * WHAT EACH LIMIT IS CALLED, IN HER WORDS. One copy, because the sentence the
+ *  corner reads aloud and the panel's rows have to agree word for word: they are
+ *  on the screen at the same moment, one of them read aloud and one of them read.
+ *
+ *  SO "all models" IS DROPPED. It is the CLI's qualifier on the week line and it
+ *  means every model, which is to say it is not a qualifier at all. Printed, it
+ *  put "This week, all models" directly above "This week, Fable", where the
+ *  first reads as one subset beside another instead of as the total it is. The
+ *  qualifier is still kept on the limit itself and any OTHER one is still
+ *  printed, so a fourth line the CLI invents tomorrow arrives named.
+ *
+ *  IT IS STAMPED ONTO THE LIMIT HERE RATHER THAN DERIVED WHERE THE PANEL DRAWS
+ *  (2026-09-05). These are Claude Code's spans and Claude Code's qualifiers, and
+ *  the panel draws Codex's limits now too; a namer that ran over every reading
+ *  would have had one branch for "session", one for "week" and no honest answer
+ *  for anything else -- which is how "This week, Fable", a Claude model, could
+ *  have appeared over a Codex reading. Each reader names its own limits. */
+function limitName(span, qualifier) {
+  if (span === 'session') return 'This session';
+  const q = qualifier && qualifier.toLowerCase() !== 'all models' ? qualifier : null;
+  return q ? `This week, ${q}` : 'This week';
+}
+
+/**
+ * EVERY LIMIT THE COMMAND REPORTED, in the order it reported them.
+ *
+ * Unknown lines are ignored rather than guessed at: the command prints a whole
+ * page (requests, sessions, what is contributing to the limits) and this only
+ * claims to understand the lines that say a percentage.
+ */
+export function readUsage(text, now = Date.now(), zoneNow = localZone()) {
+  const out = [];
+  for (const raw of String(text ?? '').split('\n')) {
+    const m = LINE.exec(raw.trim());
+    if (!m) continue;
+    const [, span, qualifier, percent, resets] = m;
+    const reset = RESET.exec(String(resets ?? '').trim());
+    const kind = span.toLowerCase();
+    const named = qualifier ? qualifier.trim() : null;
+    out.push({
+      // `session` is the five hour one he asked for. The week lines carry a
+      // qualifier ("all models", "Fable") and it is kept as the CLI wrote it.
+      span: kind,
+      qualifier: named,
+      name: limitName(kind, named),
+      percent: Math.max(0, Math.min(100, Number(percent))),
+      // The whole stamp, always, because it is true even when the countdown
+      // cannot be computed.
+      // Written back the way the CLI wrote it: "6:19pm" keeps its minutes and
+      // "4pm" does not grow a ":00" it never had.
+      resetsText: reset ? `${reset[3]}${reset[4] ? `:${reset[4]}` : ''}${reset[5].toLowerCase()}m` : null,
+      // AND THE DAY IT FALLS ON, kept separately. The clock time alone is what
+      // the panel used to have, and on the two WEEK rows "4pm" reads as today
+      // when it is Thursday's. Claude Code prints the day, so we keep the day
+      // to print. "Sep 3", as the command wrote it.
+      resetsOn: reset ? `${reset[1]} ${Number(reset[2])}` : null,
+      resetsAt: resets ? resetAt(resets, now, zoneNow) : null,
+      zone: reset?.[6] ?? null,
+    });
+  }
+  return out;
+}
+
+/**
+ * WHAT THE PILL SAYS. Null when there is nothing honest to print, and then
+ * nothing is drawn at all rather than a pill saying it does not know.
+ *
+ * Two parts, which is what he asked for: "Even a small pill with percent used
+ * and time left would do it."
+ */
+export function pillText(limits, now = Date.now()) {
+  const session = sessionLimit(limits);
+  if (!session) return null;
+  const used = `${session.percent}%`;
+  if (session.resetsAt) return { used, when: untilReset(session.resetsAt - now) };
+  // No countdown to be had, either because the stamp was missing or because it
+  // was computed in another timezone. The clock time is still true.
+  if (session.resetsText) return { used, when: `resets ${session.resetsText}` };
+  return { used, when: null };
+}

package/shared/codex-commands.d.mts

@@ -0,0 +1,4 @@
+import type { ClaudeCommand } from './claude-commands.mjs';
+export const CODEX_COMPACT: ClaudeCommand;
+export function codexCommand(text: unknown): {name: 'compact'; valid: boolean} | null;
+export const COMPACTION_COPY: Readonly<Record<string, string>>;

package/shared/codex-commands.mjs

@@ -0,0 +1,17 @@
+// Only operations PowerUp actually dispatches. Paths and prose remain messages.
+export const CODEX_COMPACT = Object.freeze({ name: 'compact', description: 'Free up context in this conversation', menuDescription: null, whole: true, argumentHint: null, aliases: [] });
+export function codexCommand(text) {
+  if (typeof text !== 'string') return null;
+  const value = text.trim();
+  if (!/^\/compact(?:\s|$)/i.test(value)) return null;
+  return { name: 'compact', valid: /^\/compact$/i.test(value) };
+}
+export const COMPACTION_COPY = Object.freeze({
+  running: 'Compacting this conversation…',
+  done: 'Conversation compacted. You can continue this task.',
+  failed: 'Couldn’t compact this conversation. Try again.',
+  busy: 'Wait for the current response to finish and pause any active goal, then run /compact.',
+  unavailable: 'Compaction isn’t available with this Codex version.',
+  missing: 'This task doesn’t have a Codex conversation to compact yet.',
+  invalid: 'Run /compact on its own. Your draft has been kept.',
+});

package/shared/codex-import.d.mts

@@ -0,0 +1,38 @@
+// Types for shared/codex-import.mjs, so the renderer can import it under
+// strict TypeScript the way it does the other shared modules.
+export const CODEX_IMPORT_LABEL: string;
+export const CODEX_MIRROR_LABEL: string;
+export const NOT_IMPORTED_LABEL: string;
+export const IMPORT_KIND: string;
+export function codexLabel(id: string | null | undefined): string;
+export function codexIdOf(item: { labels?: string[] } | null | undefined): string | null;
+export function isCodexImportRow(item: { labels?: string[]; status?: string } | null | undefined): boolean;
+export function isNotImportedRow(item: { labels?: string[]; status?: string } | null | undefined): boolean;
+export function isCodexMirrorRow(item: { labels?: string[] } | null | undefined): boolean;
+export function whenPhrase(when: number | null | undefined, now?: number): string;
+export function plainQuote(text: string | null | undefined): string;
+export function threadFactsLine(thread: CodexThreadLike, now?: number): string;
+export const FIRST_LINE_BUDGET: number;
+export function importFirstLine(thread: CodexThreadLike, opts?: { projectName?: string | null; now?: number }): string;
+export function productsForThread<P extends { repoPath?: string | null }>(thread: CodexThreadLike, products?: P[]): P[];
+export interface CodexThreadLike {
+  id?: string;
+  title?: string;
+  folder?: string;
+  when?: number;
+  prompt?: string;
+  last?: string;
+  short?: string;
+  startedAt?: number;
+  lastActive?: number;
+  turns?: number;
+  images?: number;
+  live?: boolean;
+}
+export function codexImportRow(thread: CodexThreadLike, opts?: { projectName?: string | null; now?: number }): {
+  title: string; body: string; kind: string; priority: number; labels: string[];
+};
+export function codexMirrorPatch(thread: CodexThreadLike): { body: string; result: string; kind: string; labels: string[] };
+export function importChoice(answer: string | null | undefined): 'yes' | 'no' | null;
+export function whereThreadLands<P extends { repoPath?: string | null }>(thread: CodexThreadLike, products?: P[]): P | null;
+export function threadsNeedingRows<T extends CodexThreadLike>(threads: T[], existingItems?: Array<{ labels?: string[] }>): T[];

package/shared/codex-import.mjs

@@ -0,0 +1,232 @@
+// THE ROW THAT ASKS WHETHER A CODEX CONVERSATION COMES IN, and what her yes and
+// her no do to it.
+//
+//   THE TITLE IS CODEX'S OWN. The row is called what Codex called it, so she
+//   finds it by the name she remembers from the other tab.
+//
+//   THE FIRST LINE OF THE BODY SAYS WHERE IT WOULD GO AND WHEN IT WAS. That is
+//   the line the inbox row prints under the title, so it has to carry the
+//   whole question on its own: "Import into the app? A Codex conversation
+//   from 7:22 PM today."
+//
+// THE BODY ENDS IN THE APP'S OWN OPTIONS. Two options, Import into X and Not
+// now, so opening the row draws the strip and a 1 or a 2 answers it exactly as
+// Y and N do on the row.
+//
+//   NOTHING IS RESUMED. She chose that on 08-29 for Claude Code threads and it
+//   holds here: a yes makes a row she can READ, with her prompt and Codex's
+//   last message, and replies still happen in Codex.
+//
+// A NO NEVER LOSES ONE.So a no closes the row under its own label, Closed shows
+// it under "Not imported" with an Import key, and the ⌘K import card lists it
+// too.
+//
+// Pure on purpose, like shared/agent-import.mjs beside it: the words are tested
+// rather than eyeballed, and main/store.mjs does the writing.
+
+/** On the row while it is asking. */
+import { Name } from '../shared/product-name.mjs';
+export const CODEX_IMPORT_LABEL = 'codex-import';
+/** On the row once it is hers to read. */
+export const CODEX_MIRROR_LABEL = 'codex';
+/** On a row she said not now to. */
+export const NOT_IMPORTED_LABEL = 'not-imported';
+/** And which conversation, on all three. Codex's own thread id. */
+export const codexLabel = (id) => `codex:${String(id ?? '').trim()}`;
+
+/** The kind the asking row wears, so the list can draw it differently. */
+export const IMPORT_KIND = 'import';
+
+export function codexIdOf(item) {
+  for (const label of item?.labels ?? []) {
+    if (typeof label === 'string' && label.startsWith('codex:')) return label.slice(6);
+  }
+  return null;
+}
+export const isCodexImportRow = (item) => (item?.labels ?? []).includes(CODEX_IMPORT_LABEL) && item?.status !== 'done';
+export const isNotImportedRow = (item) => (item?.labels ?? []).includes(NOT_IMPORTED_LABEL) && item?.status === 'done';
+export const isCodexMirrorRow = (item) => (item?.labels ?? []).includes(CODEX_MIRROR_LABEL) && !!codexIdOf(item);
+
+/** "7:22 PM today", "yesterday at 7:22 PM", "Friday at 7:22 PM", else the date. */
+export function whenPhrase(when, now = Date.now()) {
+  const then = new Date(Number(when) || 0);
+  if (!when || !Number.isFinite(then.getTime())) return '';
+  const time = then.toLocaleTimeString('en-US', { hour: 'numeric', minute: '2-digit' });
+  const midnight = (d) => new Date(d.getFullYear(), d.getMonth(), d.getDate()).getTime();
+  const days = Math.round((midnight(new Date(now)) - midnight(then)) / 86400000);
+  if (days <= 0) return `${time} today`;
+  if (days === 1) return `yesterday at ${time}`;
+  if (days < 7) return `${then.toLocaleDateString('en-US', { weekday: 'long' })} at ${time}`;
+  return then.toLocaleDateString('en-US', { month: 'long', day: 'numeric' });
+}
+
+/**
+ * WHAT CODEX WROTE, IN WORDS THAT WORK FROM A ROW (2026-09-16).
+ *
+ * Codex answers in markdown aimed at its own window: a picture at a path in a
+ * temporary folder, a link to a preview server it started on this Mac, a link
+ * to a notes file in its worktree.
+ *
+ *  So: pictures are left out. A link to the open web stays a link, because it
+ *  works from anywhere (her own cofounder.co link does). A link to this Mac, a
+ *  file path or a localhost address, keeps its words and loses its target, and
+ *  a line that was nothing but such a link goes entirely, since "Open the
+ *  interactive preview." with nothing to open is the confusing part. */
+const isWebLink = (target) => /^https?:\/\//i.test(target) && !/^https?:\/\/(localhost|127\.0\.0\.1|0\.0\.0\.0|\[::1\])([:/]|$)/i.test(target);
+export function plainQuote(text) {
+  const lines = String(text ?? '').split('\n').map((raw) => {
+    const line = raw.replace(/!\[[^\]]*\]\([^)]*\)/g, '');
+    const only = line.trim().match(/^\[([^\]]+)\]\(\s*([^)\s]+)[^)]*\)[.!]?$/);
+    if (only && !isWebLink(only[2])) return null;
+    return line.replace(/\[([^\]]+)\]\(\s*([^)\s]+)[^)]*\)/g, (whole, words, target) => (isWebLink(target) ? whole : words));
+  });
+  return lines.filter((l) => l !== null).join('\n').replace(/\n{3,}/g, '\n\n').trim();
+}
+
+/**
+ * One paragraph of a longer text. Headings lose their hashes and become
+ *  sentences, so "### 1. Folio" reads as "1. Folio." inside the line. */
+const clip = (text, max) => {
+  const t = plainQuote(text)
+    .replace(/^\s*#{1,6}\s*(.+?)\s*$/gm, (_m, h) => (/[.!?:]$/.test(h) ? h : `${h}.`))
+    .replace(/\s+/g, ' ')
+    .trim();
+  return t.length > max ? `${t.slice(0, max - 1).trimEnd()}…` : t;
+};
+
+const plural = (n, one, many) => `${n} ${n === 1 ? one : many}`;
+
+/**
+ * THE LINE THAT SAYS WHAT THE CONVERSATION IS, IN FACTS. Where it ran, how
+ * long it has gone on, what she attached, and whether Codex is still in
+ * it.*/
+export function threadFactsLine(thread, now = Date.now()) {
+  const where = String(thread?.short || thread?.folder || '').trim();
+  const startedAt = Number(thread?.startedAt) || 0;
+  const when = Number(thread?.when) || 0;
+  const lastActive = Number(thread?.lastActive) || 0;
+  if (!where && !startedAt && !when) return '';
+  // One sentence for when and where. A conversation that went on for a while
+  // says when it started and when it was last touched; a short one says only
+  // when it was.
+  const longRun = startedAt && Math.abs(when - startedAt) > 60_000;
+  const opening = longRun ? `started ${whenPhrase(startedAt, now)}` : (when || startedAt) ? `from ${whenPhrase(when || startedAt, now)}` : '';
+  let tail = '.';
+  if (thread?.live) tail = ', still going.';
+  else if (lastActive && startedAt && lastActive - startedAt > 60_000) tail = `, last active ${whenPhrase(lastActive, now)}.`;
+  const bits = [`A Codex conversation${opening ? ` ${opening}` : ''}${where ? ` in ${where}` : ''}${tail}`];
+  const turns = Number(thread?.turns) || 0;
+  const images = Number(thread?.images) || 0;
+  if (turns || images) {
+    bits.push(`${turns ? plural(turns, 'turn', 'turns') : ''}${turns && images ? ', ' : ''}${images ? plural(images, 'screenshot attached', 'screenshots attached') : ''}.`);
+  }
+  return bits.join(' ');
+}
+
+/**
+ * THE FIRST LINE IS WHAT SHE ASKED CODEX, because that is what the inbox row
+ * prints under the title and it is the detail she approves from. The whole
+ * line stays inside the row's 112 character budget, so the quote is cut to
+ * fit and the full prompt follows under it. */
+export const FIRST_LINE_BUDGET = 110;
+export function importFirstLine(thread, { projectName, now = Date.now() } = {}) {
+  const name = String(projectName || '').trim() || 'this project';
+  // One line of plain words: a web link keeps its words here and loses its
+  // address, because the inbox line draws text and not markdown.
+  const asked = plainQuote(thread?.prompt).replace(/\[([^\]]+)\]\([^)]*\)/g, '$1').replace(/\s+/g, ' ').trim().replace(/[.!?…]+$/, '');
+  if (!asked) {
+    const when = whenPhrase(thread?.when, now);
+    return `Import into ${name}? A Codex conversation${when ? ` from ${when}` : ''}.`;
+  }
+  const lead = `Import into ${name}? You asked Codex: "`;
+  const room = FIRST_LINE_BUDGET - lead.length - 2; // the closing quote and the full stop
+  const quote = asked.length > room ? `${asked.slice(0, Math.max(1, room - 1)).trimEnd()}…` : asked;
+  return `${lead}${quote}".`;
+}
+
+/**
+ * THE ASKING ROW'S WORDS. The first line carries the question and is what the
+ *  inbox row prints; the facts line, her prompt and Codex's last message are the
+ *  detail she approves from. */
+export function codexImportRow(thread, { projectName, now = Date.now() } = {}) {
+  const title = String(thread?.title || '').trim();
+  const name = String(projectName || '').trim() || 'this project';
+  const first = importFirstLine(thread, { projectName: name, now });
+  const facts = threadFactsLine(thread, now);
+  const prompt = clip(thread?.prompt, 700);
+  const last = clip(thread?.last, 700);
+  const body = [
+    `**${first}**`,
+    ...(facts ? [facts] : []),
+    ...(prompt ? [`You asked: ${prompt}`] : [`${Name} could not read what you asked; open it in Codex to see.`]),
+    ...(last ? [`Codex last said: ${last}`] : ['Codex has not answered yet.']),
+    'Yes makes it a row here you can read. No puts it in Closed under Not imported, where it can be brought in any time. Nothing is moved.',
+    `## Options\n1. Import into ${name}\n2. Not now`,
+  ].join('\n\n');
+  return {
+    title,
+    body,
+    kind: IMPORT_KIND,
+    priority: 5,
+    labels: [CODEX_IMPORT_LABEL, codexLabel(thread?.id)],
+  };
+}
+
+/**
+ * THE ROW ONCE SHE SAID YES. Her prompt is the body and Codex's last message
+ *  is the result, so the thread reads You, then Codex, the way it did over
+ *  there. The result carries the one line that says where replies go. */
+export function codexMirrorPatch(thread) {
+  const prompt = plainQuote(thread?.prompt);
+  const last = plainQuote(thread?.last);
+  return {
+    body: prompt || String(thread?.title ?? '').trim(),
+    result: last ? `${last}\n\nRead from Codex. Replies happen there.` : 'Codex has not answered yet.\n\nRead from Codex. Replies happen there.',
+    kind: 'directive',
+    labels: [CODEX_MIRROR_LABEL, codexLabel(thread?.id)],
+  };
+}
+
+/**
+ * WHAT HER ANSWER MEANS. A key on the row sends the word; the strip sends
+ *  "Option 1: Import into X"; a typed reply can be either. Null is not an
+ *  answer to this row and falls through to the ordinary reply path. */
+export function importChoice(answer) {
+  const a = String(answer ?? '').trim().toLowerCase();
+  if (!a) return null;
+  if (/^option\s*1\b/.test(a) || /^(y|yes|import)\b/.test(a)) return 'yes';
+  if (/^option\s*2\b/.test(a) || /^(n|no|not now|skip|decline)\b/.test(a)) return 'no';
+  return null;
+}
+
+/**
+ * WHICH PROJECT A CONVERSATION BELONGS TO: the one whose folder it ran in,
+ * her rule from 08-25. Null when nobody points at that folder. */
+export function productsForThread(thread, products = []) {
+  const key = String(thread?.folder ?? '').replace(/\/+$/, '');
+  if (!key) return [];
+  return products.filter((p) => String(p?.repoPath ?? '').replace(/\/+$/, '') === key);
+}
+export function whereThreadLands(thread, products = []) {
+  return productsForThread(thread, products)[0] ?? null;
+}
+
+/**
+ * WHICH CONVERSATIONS HAVE NO ROW YET, anywhere. A row asking, a row she
+ *  imported and a row she declined all carry `codex:<id>`, and any of the
+ *  three is a reason to file nothing. */
+export function threadsNeedingRows(threads, existingItems = []) {
+  const already = new Set();
+  for (const item of existingItems) {
+    const id = codexIdOf(item);
+    if (id) already.add(id);
+  }
+  const byId = new Map();
+  for (const t of threads ?? []) {
+    const id = String(t?.id ?? '').trim();
+    if (!id || already.has(id) || byId.has(id)) continue;
+    if (!String(t?.title ?? '').trim()) continue;
+    byId.set(id, t);
+  }
+  return [...byId.values()];
+}