agentbox-app 0.1.12 → 0.1.16

package/shared/not-shipped.mjs

@@ -0,0 +1,89 @@
+// A THREAD WHOSE WORK NEVER REACHED MAIN, read off the app's own notes.
+//
+// The ship queue and the cloud run write these words (main/ship-queue.mjs
+// `failureNote`, main/cloud/run.mjs `park`), so the reader here cannot drift
+// from the writers. The agent's last message was written before either, and
+// usually says the work is shipping, so these notes are what has to be shown.
+
+import { isShippedNote } from './shipped-note.mjs';
+
+export const SHIP_FAILED = 'It did not ship, and it went back to its agent: ';
+export const KEPT_ASIDE = "This thread's cloud run finished, but its work was not laid into the task folder: ";
+// The sweep's note when it reopens a thread that was closed without being asked.
+export const CLOSED_UNSHIPPED = 'This thread was closed before its work reached main, so it is back. ';
+// Written when the person was asked and closed it anyway; ends the matter.
+export const CLOSED_ANYWAY = 'Closed without its work reaching main.';
+
+const at = (item, field) => item?.wrote?.[field]?.ts ?? 0;
+
+/**
+ * `{ why, branch, reopened }` while the latest note says the work did not
+ * reach main and the agent has not spoken since, else null.
+ */
+export function notShipped(item) {
+  const note = typeof item?.note === 'string' ? item.note : '';
+  if (!note || at(item, 'result') > at(item, 'note')) return null;
+  let text = note;
+  const reopened = text.startsWith(CLOSED_UNSHIPPED);
+  if (reopened) text = text.slice(CLOSED_UNSHIPPED.length);
+  if (text.startsWith(SHIP_FAILED)) {
+    return { why: text.slice(SHIP_FAILED.length).trim(), branch: null, reopened };
+  }
+  if (text.startsWith(KEPT_ASIDE)) {
+    const branch = /on the branch (\S+?)\.(?:\s|$)/.exec(text)?.[1] ?? null;
+    return { why: branch ? `the cloud run's work is set aside on ${branch}` : "the cloud run's work is set aside", branch, reopened };
+  }
+  return null;
+}
+
+/**
+ * `{ sha }` while the app's own latest note says it shipped the work and
+ * nobody has written on the thread since. An agent saying it shipped does
+ * not count: only the app ships.
+ */
+export function shippedAs(item) {
+  if (!isShippedNote(item?.note) || item?.wrote?.note?.source !== 'system') return null;
+  if (at(item, 'result') > at(item, 'note') || at(item, 'answer') > at(item, 'note')) return null;
+  return { sha: / as ([0-9a-f]{7,40})\./.exec(item.note)?.[1] ?? null };
+}
+
+/** A closed thread whose close was told its work never reached main. */
+export function closedUnshipped(item) {
+  return item?.status === 'done' && typeof item?.note === 'string' && item.note.startsWith(CLOSED_ANYWAY);
+}
+
+/** The row's line: "Not shipped. <why>". */
+export function notShippedLine(item) {
+  const ns = notShipped(item);
+  return ns ? `Not shipped. ${ns.why.charAt(0).toUpperCase()}${ns.why.slice(1)}` : null;
+}
+
+/** What the agent is asked when the person picks "have the agent ship it". */
+export function shipItAsk(item) {
+  const ns = notShipped(item);
+  if (!ns) return null;
+  return ns.branch
+    ? `Bring the work on ${ns.branch} into this folder, check it against current main, then ship it.`
+    : 'Fix what stopped the ship, then ship it.';
+}
+
+/** The note a close writes once the person has been asked and said close. */
+export function closedAnywayNote(item) {
+  const ns = notShipped(item);
+  if (!ns) return null;
+  return ns.branch ? `${CLOSED_ANYWAY} It is still on ${ns.branch}.` : CLOSED_ANYWAY;
+}
+
+/** `{ ok: false, error }` for a close nobody was asked about, else null. */
+export function closeRefusal(item, { closeUnshipped = false } = {}) {
+  if (closeUnshipped) return null;
+  const line = notShippedLine(item);
+  return line ? { ok: false, error: `${line}. Reply to have it shipped, or close it on your computer.` } : null;
+}
+
+/** Done, with work that never reached main, and never asked about. */
+export function closedBeforeItShipped(item) {
+  if (item?.status !== 'done') return false;
+  const ns = notShipped(item);
+  return !!ns && !ns.reopened;
+}

package/shared/notify-rules.d.mts

@@ -0,0 +1,31 @@
+// Types for shared/notify-rules.mjs, which is plain ESM so that main (Node)
+// and the screen (Vite) can share one copy of the rule about when Agentbox is
+// allowed to interrupt you. The screen asks only `isNew`, which is the
+// question before "are you away"; the rest is main's.
+
+export const AWAY_AFTER_MS: number;
+
+export function atTheApp(state?: { focused?: boolean; idleMs?: number }): boolean;
+
+export function atTheComputer(state?: { idleMs?: number }): boolean;
+
+// `known` is the ids on the snapshot before this one, and null means there has
+// not been one. Empty and never-looked are different facts, and the module
+// says what reading one as the other cost.
+export function isNew(known: ReadonlySet<string> | null | undefined, id: string): boolean;
+
+export function clip(text: unknown, max?: number): string;
+
+export function shouldSpeak(state?: {
+  spoke?: boolean;
+  spokeAsk?: boolean;
+  waiting?: ReadonlyArray<{ kind?: string } | null | undefined>;
+}): boolean;
+
+export function banner(
+  waiting: ReadonlyArray<{ id?: string; title?: unknown; kind?: string } | null | undefined> | null | undefined,
+): { title: string; body: string; open: string | null } | null;
+
+export function phoneBanner(
+  waiting: ReadonlyArray<{ id?: string; title?: unknown; thread?: unknown; kind?: string } | null | undefined> | null | undefined,
+): { title: string; body: string; open: string | null } | null;

package/shared/notify-rules.mjs

@@ -31,6 +31,34 @@ export function atTheApp({ focused = false, idleMs = 0 } = {}) {
   return !!focused && idleMs < AWAY_AFTER_MS;
 }
 
+// THE PHONE'S RULE IS WIDER: she is at the computer, in any app, so the phone
+// says nothing. Someone in a browser on the laptop is not at the app, and the
+// desktop banner above is how she hears; buzzing the phone in her bag as well
+// is the "tons and tons of notifications" she reported (2026-10-13). The
+// phone is for when she has left the machine, which only the idle clock knows.
+export function atTheComputer({ idleMs = 0 } = {}) {
+  return idleMs < AWAY_AFTER_MS;
+}
+
+// WHAT COUNTS AS NEWS, which is the question before "is she away".
+//
+// renderer/src/App.tsx owns the definition of the inbox and asks this of every
+// row in it, against the ids it remembered from the snapshot before. `known` is
+// those ids, and `null` means there has not been a snapshot yet: on the app's
+// first look, everything waiting has been waiting, so none of it is a banner.
+//
+// EMPTY AND NEVER-LOOKED ARE DIFFERENT FACTS, and reading one as the other is
+// what sent this feature's best moment into the bin. App.tsx used to decide it
+// had never looked by asking whether the ids it remembered were empty, which is
+// also true of inbox zero — the state the whole product aims at. So the
+// arrival that most deserved to reach her, the first one after she got clear,
+// was the one the app silently dropped before any rule here could see it.
+// tests/the-first-arrival-after-inbox-zero-still-speaks.test.mjs.
+export function isNew(known, id) {
+  if (!known) return false;
+  return !known.has(id);
+}
+
 // A title long enough to be a paragraph is normal here; hers run past a
 // hundred characters. macOS will hard-truncate mid-word, so cut on a space and
 // say that it was cut.
@@ -59,14 +87,15 @@ export function clip(text, max = 120) {
 // main/notify.mjs resets this the moment she has the window, so the next time
 // she walks away she can be told again.
 //
-// THE ONE EXCEPTION, and it is here because an approval card has a clock on it.
-// A finished agent waits as long as it takes. An approval is a worker frozen
-// mid-run with her as the only way through, and it is DENIED AUTOMATICALLY
-// after fifteen minutes (TIMEOUT_MS, main/approval-prompt-server.mjs). If the
-// first banner of the stretch was a finished agent, an approval landing twenty
-// minutes later would die unheard under a strict one-and-done rule. So an
-// approval gets to speak once more, and that is the cap: at most two in one
-// stretch away, never more.
+// THE ONE EXCEPTION, and it is here because an approval is the one thing in the
+// inbox that nothing else can move. A finished agent has said its piece and the
+// thread is readable without her. An approval is a worker frozen mid-run with
+// her as the only way through, and it waits exactly that long: no clock answers
+// it (main/codex-approvals.mjs). If the first banner of the stretch was a
+// finished agent, an approval landing twenty minutes later would die unheard
+// under a strict one-and-done rule, and the run would still be standing there
+// when she got back. So an approval gets to speak once more, and that is the
+// cap: at most two in one stretch away, never more.
 export function shouldSpeak({ spoke = false, spokeAsk = false, waiting = [] } = {}) {
   const items = (waiting ?? []).filter(Boolean);
   if (!items.length) return false;
@@ -118,3 +147,21 @@ export function banner(waiting) {
     open: lead.kind === 'approval' ? null : (lead.id ?? null),
   };
 }
+
+// THE PHONE'S ALERT IS HEADED BY THE THREAD (2026-10-13). On a phone the
+// banner is read in a stack of others, and she asked for the bold line to be
+// "the specific chat title so I know which thread we're talking about". iOS
+// wraps the body and gives the title a line of its own, so the macOS reason
+// above for keeping a name out of the title does not hold there. The sentence
+// moves under it. An approval names the thread that is asking (`thread`) and
+// what it wants to run; with no thread to name, it is the desktop's words.
+export function phoneBanner(waiting) {
+  const say = banner(waiting);
+  if (!say) return null;
+  const items = waiting.filter(Boolean);
+  const asks = items.filter((i) => i.kind === 'approval');
+  const lead = asks.length ? asks[0] : items[items.length - 1];
+  const name = clip(asks.length ? lead.thread : lead.title, 80);
+  if (!name) return say;
+  return { title: name, body: asks.length ? `Waiting on you: ${say.body}` : say.title, open: say.open };
+}

package/shared/phone-files.mjs

@@ -0,0 +1,28 @@
+// A FILE HER PHONE SENT WITH A REPLY OR A NEW THREAD: put in her storage, in
+// the folder of the computer the thread is on, named by what is in it
+// (renderer/src/phone-sends-files.ts), and linked in her words. The computer
+// (main/phone-inbox.mjs) and the cloud server (cloud/gateway/phone.mjs) each
+// put it in the project's attachments under the same name, made from what is
+// in it, so a turn the cloud ran and the row the computer keeps link one file.
+
+export const PHONE_FILE = /(!?)\[([^\]\n]*)\]\(phone-files\/([0-9a-f]{64}\.[a-z0-9]{1,8})\)/g;
+export const PHONE_FILES_MAX = 10;
+// The bucket's own bound on a file (20261017000000_phone_files.sql).
+export const PHONE_FILE_MAX_BYTES = 25 * 1024 * 1024;
+
+export function phoneFilesIn(text) {
+  return [...String(text ?? '').matchAll(PHONE_FILE)].map((m) => ({ link: m[0], picture: m[1] === '!', label: m[2], name: m[3] }));
+}
+
+/** The name it goes under, as main/save-attachments.mjs makes one safe. */
+export const phoneFileSafeName = (f) => String(String(f.label ?? '').trim() || f.name).replace(/[^\w.-]+/g, '-').slice(0, 80);
+
+/** Where it goes in the project's documents folder: the same file, the same place. */
+export const phoneAttachmentRel = (f) => `attachments/${String(f.name).slice(0, 16)}-${phoneFileSafeName(f)}`;
+
+/** Her words with each file linked where it was put. */
+export function linkPhoneFiles(text, found = phoneFilesIn(text)) {
+  let out = String(text ?? '');
+  for (const f of found) out = out.replace(f.link, () => `${f.picture ? '!' : ''}[${phoneFileSafeName(f)}](${phoneAttachmentRel(f)})`);
+  return out;
+}

package/shared/phone-settings.mjs

@@ -0,0 +1,118 @@
+// YOUR COMPUTER'S SETTINGS ON YOUR PHONE: the copy the Mac sends, and the
+// changes the phone may ask for. The Mac's own handlers (main/settings.mjs)
+// still decide every value. This keeps paths and instruction text out of the
+// cloud, and refuses any key the phone has no page for.
+import { CLAUDE_PERMISSION_MODES } from './work-items.mjs';
+import { CODEX_MODE_ORDER } from './codex-modes.mjs';
+import { AGENT_MODES } from './agents.mjs';
+
+export const SETTINGS_VERSION = 1;
+
+/** A login by the last part of its folder's name; the folder itself stays on the Mac. */
+export const accountIdOf = (profile) => (profile === 'default' ? 'default' : String(profile ?? '').split(/[\\/]/).filter(Boolean).pop() ?? '');
+
+const ACCOUNT_ID = /^[\w.-]{1,80}$/;
+const SLUG = /^[a-z0-9][\w-]{0,119}$/i;
+const bool = (v) => typeof v === 'boolean';
+const oneOf = (list) => (v) => list.includes(v);
+const count = (v) => Number.isInteger(v) && v >= 1 && v <= 64;
+const accountId = (v) => typeof v === 'string' && ACCOUNT_ID.test(v) && v !== '.' && v !== '..';
+
+const WORKSPACE = {
+  cornerTag: bool,
+  diagnostics: bool,
+  adhdMode: bool,
+  alphaRooms: bool,
+  alphaTeammates: bool,
+  agentsAuto: bool,
+  memoryGate: bool,
+  cleanupLeftovers: bool,
+  sessionsAtOnce: count,
+  memoryGateSlots: (v) => v === null || count(v),
+  agentsFeltSlow: oneOf(['more', 'reset']),
+  outsideAgents: oneOf(AGENT_MODES),
+  permission: oneOf(CLAUDE_PERMISSION_MODES),
+  codexMode: oneOf(CODEX_MODE_ORDER),
+  phoneProjects: (v) => !!v && bool(v.all) && Array.isArray(v.except) && v.except.length <= 500 && v.except.every((s) => typeof s === 'string' && SLUG.test(s)),
+  activeAccount: (v) => !!v && oneOf(['claude', 'codex'])(v.engine) && (v.account === null || accountId(v.account)),
+};
+const PROJECT = {
+  autonomous: bool,
+  permission: oneOf(['workspace', ...CLAUDE_PERMISSION_MODES]),
+  codexMode: oneOf(['workspace', ...CODEX_MODE_ORDER]),
+  account: (v) => v === 'any' || accountId(v),
+};
+
+/** Why the Mac should not carry out this change, or null. */
+export function checkSetting(p) {
+  if (!p || typeof p !== 'object') return 'not a setting';
+  const rules = p.scope === 'workspace' ? WORKSPACE : p.scope === 'project' ? PROJECT : null;
+  if (!rules || !Object.hasOwn(rules, p.key)) return 'not a setting your phone can change';
+  if (p.scope === 'project' && !(typeof p.product === 'string' && SLUG.test(p.product))) return 'that setting needs its project';
+  return rules[p.key](p.value) ? null : 'not a value that setting takes';
+}
+
+function profileFor(model, engine, id) {
+  if (id === null) return null;
+  const list = engine === 'codex' ? model?.workspace?.codex?.accounts : model?.workspace?.accounts;
+  const hit = (list ?? []).find((a) => accountIdOf(a.profile) === id);
+  if (!hit) throw new Error('that account is not on this computer');
+  return hit.profile;
+}
+
+/** The window's own handler for a checked change, and what to hand it. */
+export function settingRoute(p, model) {
+  if (p.scope === 'project') {
+    const value = p.key === 'account' && p.value !== 'any' ? profileFor(model, 'claude', p.value) : p.value;
+    return ['zero:settings-set-project', { product: p.product, key: p.key, value }];
+  }
+  const value = p.key === 'activeAccount' ? { engine: p.value.engine, profile: profileFor(model, p.value.engine, p.value.account) } : p.value;
+  return ['zero:settings-set-workspace', { key: p.key, value }];
+}
+
+/**
+ * What the phone's Settings pages draw, from the Mac's settings model. Null
+ * when the Mac could not read its own settings.
+ */
+export function phoneSettingsOf(model, { version }) {
+  if (!model?.ok || !model.workspace) return null;
+  const w = model.workspace;
+  const gate = w.memoryGate ?? {};
+  return {
+    v: SETTINGS_VERSION,
+    version: String(version ?? ''),
+    workspace: {
+      cornerTag: !!w.cornerTag,
+      diagnostics: !!w.diagnostics,
+      adhdMode: !!w.adhdMode,
+      alpha: { rooms: !!w.alpha?.rooms },
+      outsideAgents: w.outsideAgents,
+      permission: w.permission,
+      codexMode: w.codexMode ?? null,
+      engines: (w.engineChoices ?? []).map((e) => e.id),
+      claude: { found: !!w.claudeFound },
+      codex: { found: !!w.codex?.found },
+      agentsAuto: !!w.agentsAuto,
+      sessionsAtOnce: w.sessionsAtOnce,
+      agentsTotal: w.agentsTotal,
+      agentsAutoTotal: w.agentsAutoTotal,
+      agentsNudge: w.agentsNudge ?? 0,
+      slotsMax: w.slotsMax,
+      slotsSuggested: w.slotsSuggested,
+      running: w.running,
+      memoryGate: { on: !!gate.on, slots: gate.slots ?? null, slotsAuto: gate.slotsAuto ?? null, slotsMax: gate.slotsMax ?? null, now: gate.now ?? null },
+      leftovers: { on: !!w.leftovers?.on, now: w.leftovers?.now ?? null },
+      accounts: (w.accounts ?? []).map((a) => ({
+        id: accountIdOf(a.profile), email: a.email ?? null, chosen: !!a.chosen, state: a.state,
+        note: a.trouble?.note ?? null, plan: a.plan?.label ?? null, running: a.running ?? 0,
+      })),
+      codexAccounts: (w.codex?.accounts ?? []).map((a) => ({
+        id: accountIdOf(a.profile), email: a.email ?? null, name: a.name ?? null, plan: a.plan ?? null, signedIn: !!a.signedIn, chosen: !!a.chosen,
+      })),
+    },
+    projects: (model.projects ?? []).map((p) => ({
+      slug: p.slug, name: p.name, onPhone: !!p.onPhone, autonomous: !!p.autonomous,
+      permission: p.permission, codexMode: p.codexMode, account: p.account === 'any' ? 'any' : accountIdOf(p.account), running: p.running ?? 0,
+    })),
+  };
+}

package/shared/phone-snapshot.d.mts

@@ -0,0 +1,16 @@
+// Types for shared/phone-snapshot.mjs, for the phone with the computer closed.
+export const SNAPSHOT_LIMITS: { lines: number; textChars: number; items: number; bytes: number };
+export const PHONE_COMMANDS: string[];
+export function hideSecrets(text: string, opts?: { home?: string | null }): string;
+export function bytesOf(value: unknown): number;
+export function threadSnapshot(item: Record<string, unknown>, history?: unknown[], limits?: typeof SNAPSHOT_LIMITS, opts?: { home?: string | null }): { v: number; item: Record<string, unknown>; history: unknown[]; olderLines: number };
+export function threadsWorthCarrying<T>(items: T[], opts?: { now?: number }): T[];
+export function snapshotKey(snapshot: unknown): string;
+export function madeHere(commandId: string): string;
+export function phoneChoices(kind: string, p: Record<string, unknown> | null | undefined): Record<string, unknown>;
+export function phoneChoiceOf(saved: unknown, personId: string | null | undefined, every?: string[]): { all: boolean; except: string[] };
+export function phoneProjectsOf(saved: unknown, personId: string | null | undefined, every?: string[]): string[];
+export function withPhoneProject(saved: unknown, personId: string | null | undefined, slug: string, on: boolean, every?: string[]): { owner: string; all: boolean; except: string[] };
+export function withPhoneAll(saved: unknown, personId: string | null | undefined, on: boolean, every?: string[]): { owner: string; all: boolean; except: string[] };
+export function checkCommand(cmd: unknown, ctx: { projects: string[]; hasItem: (project: string, id: string) => boolean }): string | null;
+export function phoneEligible(products: { slug?: string }[]): string[];