agentbox-app 0.1.12 → 0.1.13

package/scripts/approval-server.sh

@@ -39,10 +39,29 @@ case "$here" in
     exec env ELECTRON_RUN_AS_NODE=1 "$app/MacOS/$exe" "$res/app.asar/main/approval-prompt-server.mjs"
     ;;
   *)
-    # Running from source: node is nvm-only on this machine, and MCP servers
-    # boot from a bare login shell, so resolve it the same way the store
-    # launcher does.
-    export PATH="$HOME/.nvm/versions/node/$(ls "$HOME/.nvm/versions/node" 2>/dev/null | tail -1)/bin:$PATH"
-    exec node "$(cd "$here/.." && pwd)/main/approval-prompt-server.mjs"
+    # RUNNING FROM SOURCE, AND THIS LINE USED TO ASSUME NVM. It prepended
+    # $HOME/.nvm/versions/node/<newest>/bin and exec'd node. On a Mac that
+    # installed node by Homebrew, Volta, asdf or not at all, that folder is
+    # absent, PATH is untouched, and an MCP server booting from a bare login
+    # shell has no node on it: the exec failed and every agent died the same
+    # four-second death described at the top of this file. Reported from
+    # source on 2026-10-07 (issue 21).
+    #
+    # So the app hands its own binary down in ZERO_APPROVALS_RUNTIME, and
+    # ELECTRON_RUN_AS_NODE=1 makes that binary a node, exactly as the packaged
+    # branch above does. Nothing on the machine is needed.
+    server="$(cd "$here/.." && pwd)/main/approval-prompt-server.mjs"
+    if [ -f "$ZERO_APPROVALS_RUNTIME" ] && [ -x "$ZERO_APPROVALS_RUNTIME" ]; then
+      exec env ELECTRON_RUN_AS_NODE=1 "$ZERO_APPROVALS_RUNTIME" "$server"
+    fi
+    # Nobody handed one down, so this is somebody running the script by hand.
+    # A node already on PATH wins; nvm's newest is the last resort, for the
+    # bare login shell that has never sourced nvm.
+    if ! command -v node >/dev/null 2>&1; then
+      nvm="$HOME/.nvm/versions/node"
+      newest="$(ls "$nvm" 2>/dev/null | tail -1)"
+      [ -n "$newest" ] && export PATH="$nvm/$newest/bin:$PATH"
+    fi
+    exec node "$server"
     ;;
 esac

package/scripts/before-publish.mjs

@@ -69,17 +69,19 @@ function wouldShip(changed) {
     // If npm cannot tell us, the honest answer is the cautious one.
     return changed;
   }
-  // THE FILES THE PUBLISH ITSELF REWRITES, which would otherwise make every
-  // attempt poison the next one. `prepack` runs `npm run build`, and the build
-  // reads the installed Claude Code and writes what it found into
-  // shared/*.generated.*. So a failed publish leaves those modified, and the
-  // next publish refuses because of dirt the last publish made. Measured
-  // 2026-09-28: one failed attempt left claude-models.generated.mjs changed by
-  // a version number, and that alone blocked the retry.
+  // THE FILES A PUBLISH USED TO REWRITE, which made every attempt poison the
+  // next one. `prepack` runs `npm run build`, and the build read the installed
+  // Claude Code and wrote what it found over shared/*.generated.*. So a failed
+  // publish left those modified and the next publish refused because of dirt the
+  // last publish had made. Measured 2026-09-28: one failed attempt left
+  // claude-models.generated.mjs changed by a version number, and that alone
+  // blocked the retry.
   //
-  // They are safe to ignore here BECAUSE the build rewrites them anyway. What
-  // ships is whatever the build produces on the machine publishing, every time,
-  // committed or not, so a difference in the working tree changes nothing.
+  // THE BUILD NO LONGER WRITES THEM (w-6bbb709b1f): it writes
+  // shared/*.local.json, which is gitignored, and `npm run read:claude` is what
+  // updates the committed tables. This filter stays as the belt for a folder an
+  // OLDER build already dirtied, and because what ships is whatever the build
+  // produces on the machine publishing, so a difference here changes nothing.
   return changed.filter((f) => packed.has(f) && !/\.generated\./.test(f));
 }
 

package/shared/agent-import.mjs

@@ -148,6 +148,8 @@ export function whenWords(when, now = Date.now()) {
 /** Where she was when she started it, in the two places she named. */
 export function startedIn(source) {
   if (source === 'codex') return 'in Codex';
+  // VS Code, Cursor or Windsurf: the extension says which family, not which one.
+  if (source === 'editor') return 'in your code editor';
   return source === 'desktop' ? 'in the Claude Code desktop app' : 'in a terminal';
 }
 

package/shared/agents.d.mts

@@ -110,6 +110,7 @@ export interface AgentTurnLike {
 // ONE THING THE AGENT RAN, between two messages. Shape B.
 export interface AgentWorkLike {
   kind: 'work';
+  standalone?: true;
   at: number;
   verb: string;
   subject: string;

package/shared/bridge-map.mjs

@@ -15,6 +15,10 @@ export const REQUEST_CHANNELS = {
   terminal: 'zero:terminal',
   agentUpdate: 'zero:agent-update',
   snapshot: 'zero:snapshot',
+  refreshUsage: 'zero:refresh-usage',
+  // Whether a screen reader is running, which is the terminal pane's question
+  // before it builds xterm's accessibility tree.
+  assistiveTech: 'zero:assistiveTech',
   // The next page of old finished threads, at the foot of Done and All.
   olderItems: 'zero:older-items',
   dashboard: 'zero:dashboard',
@@ -73,9 +77,11 @@ export const REQUEST_CHANNELS = {
   agentThreads: 'zero:agent-threads',
   importThreads: 'zero:import-threads',
   badge: 'zero:badge',
+  cornerTag: 'zero:corner-tag',
   bootInfo: 'zero:boot-info',
   updateCheck: 'zero:update-check',
   updateInstall: 'zero:update-install',
+  updateMove: 'zero:update-move',
   notify: 'zero:notify',
   stopSession: 'zero:stop-session',
   runNow: 'zero:run-now',
@@ -91,6 +97,10 @@ export const REQUEST_CHANNELS = {
   settingsRead: 'zero:settings-read',
   claudeRecheck: 'zero:claude-recheck',
   codexRecheck: 'zero:codex-recheck',
+  // Point at the coding agent yourself, or hand the choice back to the search.
+  // The browser tab has no file panel, so main answers it ok-with-nothing-done
+  // there (main/serve.mjs stubs showOpenDialog) and the row stays honest.
+  engineBin: 'zero:engine-bin',
   engineSetup: 'zero:engine-setup',
   codexAddAccount: 'zero:codex-add-account',
   claudeAddAccount: 'zero:claude-add-account',
@@ -128,8 +138,13 @@ export const REQUEST_CHANNELS = {
   resumeItems: 'zero:resume-items',
   redeliver: 'zero:redeliver',
   setProductOrder: 'zero:set-product-order',
+  setThreadPlaces: 'zero:set-thread-places',
+  setThreadPins: 'zero:set-thread-pins',
   setProductHidden: 'zero:set-product-hidden',
   approve: 'zero:approve',
+  // The phone door's Settings page (main/phone-link.mjs): its state, on, off,
+  // a new key, and which address the QR code carries. The desktop window only.
+  phoneLink: 'zero:phone-link',
 };
 
 /** Told rather than asked: the app talks and the screen listens. */
@@ -140,9 +155,12 @@ export const PUSH_CHANNELS = {
   onZoomPercent: 'zero:zoom-percent',
   onRecovered: 'zero:recovered',
   onOpenItem: 'zero:open-item',
+  onOpenSettings: 'zero:open-settings',
   onScreenDetail: 'zero:screen-detail',
   onEscapeBrowser: 'zero:escape-browser',
   onKeyInTheFile: 'zero:key-in-the-file',
+  // A phone connected, left, or the key changed.
+  onPhoneChanged: 'zero:phone-changed',
 };
 
 // THE FEW THAT ARE NOT A STRAIGHT HANDOVER. Each is called with bare values

package/shared/claude-commands.generated.mjs

@@ -1,10 +1,12 @@
 // GENERATED BY scripts/read-claude-commands.mjs. DO NOT EDIT BY HAND.
 //
 // Claude Code's own words for the commands Agentbox's reply box offers,
-// 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 renames one of the eight
-// shows up as a diff rather than as a wrong menu.
+// read out of the copy of Claude Code installed on a machine that ran
+// `npm run read:claude`. A BUILD DOES NOT REWRITE THIS: a build wrote what it
+// read over this tracked file, and every folder that had run the app then
+// looked like it held work. Committed so a machine with no Claude Code on it
+// can still build, and so a version that renames one of the eight shows up as
+// a diff rather than as a wrong menu.
 //
 // WHY IT IS READ AND NOT TYPED: reading them out of the installed binary at
 // build time, rather than typing them into a file, is the only way the list

package/shared/claude-models.generated.mjs

@@ -1,10 +1,12 @@
 // 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.
+// out of the copy of Claude Code installed on a machine that ran
+// `npm run read:claude`. A BUILD DOES NOT REWRITE THIS: a build wrote what it
+// read over this tracked file, and every folder that had run the app then
+// looked like it held work. 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

package/shared/corner-tag.d.mts

@@ -0,0 +1,14 @@
+// Types for shared/corner-tag.mjs, the corner tag's rules, which main (Node)
+// and the tag's page (Vite) share one copy of. Only what the page calls is
+// declared; the window placement is main's half.
+
+export type HideChoice = { key: '5m' | '30m' | 'today'; label: string };
+export const HIDE_CHOICES: HideChoice[];
+
+export function tagSays(counts: { ready?: number; working?: number }): { kind: 'ready' | 'working'; text: string } | null;
+
+export type ReadyLine = { id: string; title: string; says: string; since?: number; open?: string | null };
+export function cardLines<T extends ReadyLine>(ready: T[], now: number, max?: number): {
+  lines: (T & { waited: string })[];
+  more: number;
+};

package/shared/corner-tag.mjs

@@ -0,0 +1,141 @@
+// THE CORNER TAG (w-dafae58a23): the rules, and nothing that touches a window.
+//
+// You lose track of agents once you are in another app, and the ones waiting on
+// you sit idle. The answer that survived eight rounds of drawings is a small tag
+// in a corner of the screen that says "2 ready for you" when an agent has
+// something for you and "20 working" when none does. Twenty agents running is
+// ordinary, so working agents are a count and never a list: only what is ready
+// for you is worth a line.
+//
+// It must never become a nag. So it hides for a while and comes back on its
+// own, there is no one-click way to make it gone for good (that becomes a thing
+// you closed once and forgot existed), it is turned off only in Settings, and
+// it steps aside while you are in the app itself.
+//
+// main/corner-tag.mjs owns the window and renderer/src/corner-tag owns the
+// page; both decide through this file so the tests pin behaviour, not wiring.
+
+/** Space between the tag and the edge of the screen when it rests in a corner. */
+export const MARGIN = 18;
+
+/** The ways to hide it. All of them come back; none of them is permanent. */
+export const HIDE_CHOICES = [
+  { key: '5m', label: '5 min' },
+  { key: '30m', label: '30 min' },
+  { key: 'today', label: 'Today' },
+];
+
+/** When a hide chosen at `now` runs out. 0 means "not hidden". */
+export function hiddenUntil(choice, now) {
+  if (choice === '5m') return now + 5 * 60_000;
+  if (choice === '30m') return now + 30 * 60_000;
+  if (choice === 'today') {
+    const d = new Date(now);
+    d.setHours(24, 0, 0, 0);
+    return d.getTime();
+  }
+  return 0;
+}
+
+/** The words on the tag, or null when there is nothing to say. Short, because
+ *  "22 ready for you" in the corner of a full screen was more than it needed;
+ *  "waiting" was picked over "ready" and "need you". */
+export function tagSays({ ready = 0, working = 0 } = {}) {
+  if (ready > 0) return { kind: 'ready', text: `${ready} waiting` };
+  if (working > 0) return { kind: 'working', text: `${working} working` };
+  return null;
+}
+
+/**
+ * What the tag counts and lists: everything waiting on you, newest first.
+ * The first version put threads from weeks ago at the top of the list; the
+ * second cut everything older than a day, and then a Needs you of 58 read
+ * "3 waiting" in the corner (w-0961e5523b). So the count is the whole of it,
+ * the same number the app shows, and only the order keeps the old ones out
+ * of the way: the list shows the newest three and folds the rest into "and N
+ * more". Something with no moment it became ready (an agent stopped on a
+ * yes, right now) sorts as now.
+ */
+export function readyNow(ready, now) {
+  return [...(ready ?? [])]
+    .sort((a, b) => (Number.isFinite(b.since) ? b.since : now) - (Number.isFinite(a.since) ? a.since : now));
+}
+
+/** Whether the tag is on screen right now. */
+export function tagShows({ on, hiddenUntil: until = 0, now, inApp, ready = 0, working = 0 }) {
+  if (on === false) return false;
+  if (until > now) return false;
+  // In the app itself the inbox already says all of this, bigger.
+  if (inApp) return false;
+  return !!tagSays({ ready, working });
+}
+
+/** How long something has waited, in units. */
+export function waitedFor(since, now) {
+  if (!Number.isFinite(since)) return '';
+  const min = Math.floor((now - since) / 60_000);
+  if (min < 1) return 'now';
+  if (min < 60) return `${min} min`;
+  return `${Math.floor(min / 60)} h`;
+}
+
+/** The lines under the tag: the newest first, three at most. */
+export function cardLines(ready, now, max = 3) {
+  const sorted = readyNow(ready, now, Infinity);
+  const lines = sorted.slice(0, max).map((r) => ({ ...r, waited: waitedFor(r.since, now) }));
+  return { lines, more: Math.max(0, sorted.length - lines.length) };
+}
+
+const clamp = (v, lo, hi) => Math.max(lo, Math.min(hi, v));
+
+function areaFor(point, areas) {
+  return areas.find((a) => point.x >= a.x && point.x < a.x + a.width && point.y >= a.y && point.y < a.y + a.height) ?? areas[0];
+}
+
+/**
+ * Where the tag goes when it appears: back where you last dragged it, pulled
+ * onto a screen if that screen is gone, or the bottom-right corner the first
+ * time. `spot` is the tag's top-left, `areas` are the screens' work areas.
+ */
+export function restingSpot(spot, size, areas) {
+  if (!spot) {
+    const a = areas[0];
+    return { x: a.x + a.width - MARGIN - size.width, y: a.y + a.height - MARGIN - size.height };
+  }
+  const a = areaFor({ x: spot.x + size.width / 2, y: spot.y + size.height / 2 }, areas) ?? areas[0];
+  return {
+    x: clamp(spot.x, a.x, a.x + a.width - size.width),
+    y: clamp(spot.y, a.y, a.y + a.height - size.height),
+  };
+}
+
+function inRightHalf(r, a) { return r.x + r.width / 2 > a.x + a.width / 2; }
+function inLowerHalf(r, a) { return r.y + r.height / 2 > a.y + a.height / 2; }
+
+/**
+ * The tag's new bounds when its words change length. The edge nearest its
+ * corner stays put, so "2 ready for you" turning into "20 working" does not
+ * walk the tag away from the edge you parked it against.
+ */
+export function keepCorner(bounds, size, area) {
+  const x = inRightHalf(bounds, area) ? bounds.x + bounds.width - size.width : bounds.x;
+  const y = inLowerHalf(bounds, area) ? bounds.y + bounds.height - size.height : bounds.y;
+  return { x, y, width: size.width, height: size.height };
+}
+
+/**
+ * Where the list opens when you point at the tag: toward the middle of the
+ * screen, so it never runs off an edge, lined up with the tag's outer edge.
+ */
+export function cardPlacement(tag, card, area, gap = 8) {
+  let above = inLowerHalf(tag, area);
+  const alignRight = inRightHalf(tag, area);
+  const x = clamp(alignRight ? tag.x + tag.width - card.width : tag.x, area.x, area.x + area.width - card.width);
+  const up = tag.y - gap - card.height;
+  const down = tag.y + tag.height + gap;
+  // A tall list near a short screen's middle may not fit the side it prefers.
+  if (above && up < area.y) above = false;
+  else if (!above && down + card.height > area.y + area.height) above = true;
+  const y = clamp(above ? up : down, area.y, area.y + area.height - card.height);
+  return { above, alignRight, card: { x, y, width: card.width, height: card.height } };
+}

package/shared/engines.mjs

@@ -1,3 +1,4 @@
+import { HARNESS_DEFINITIONS } from './harness-definitions.mjs';
 // WHICH CODING AGENT A TASK IS HANDED TO.
 //
 // AND THE PREMISE SHE GAVE FOR IT DID NOT HOLD. Measured head to head on her
@@ -44,11 +45,25 @@
 // main/codex.mjs when that comes back, because the renderer must never import
 // spawn code.
 
-/** The engines, in the order the picker draws them. */
-export const ENGINES = [
-  { id: 'claude', label: 'Claude Code', word: 'Claude Code' },
-  { id: 'codex', label: 'Codex', word: 'Codex' },
-];
+/**
+ * The engines, in the order the picker draws them.
+ *
+ * ADMITTED ONES ONLY, and that word is doing real work as of 2026-10-07. A
+ * harness being integrated and a harness being offered are two different
+ * decisions, and this list is the second one. OpenCode is registered in
+ * main/harnesses.mjs, its transport is measured and tested, and it is
+ * deliberately absent from here -- so `ENGINE_IDS`, `isEngine`, `engineFor`,
+ * the composer's picker, the Settings row and the byline all behave as if it
+ * were not there, while `harnessFor('opencode')` works for anything that asks
+ * for it by name. Without this filter, adding the definition alone would have
+ * put a third word in front of every user the moment it landed.
+ *
+ * docs/harnesses.md holds the bar a harness clears before `admitted` goes
+ * true, and the product review that turning it on requires.
+ */
+export const ENGINES = HARNESS_DEFINITIONS
+  .filter(({ admitted }) => admitted !== false)
+  .map(({ id, label, word }) => ({ id, label, word }));
 
 export const ENGINE_IDS = ENGINES.map((e) => e.id);
 

package/shared/harness-definitions.mjs

@@ -0,0 +1,103 @@
+// Names, flags, paths, and capabilities are data. This file is safe for the
+// renderer: it imports no processes, credentials, filesystem, or transports.
+const freeze = value => {
+  if (value && typeof value === 'object') { for (const child of Object.values(value)) freeze(child); Object.freeze(value); }
+  return value;
+};
+export const HARNESS_DEFINITIONS = freeze([
+  {
+    id: 'claude', label: 'Claude Code', word: 'Claude Code', binKey: 'claudeBin',
+    homeEnv: 'CLAUDE_CONFIG_DIR', accountPrefix: '', package: '@anthropic-ai/claude-code',
+    commandMenu: 'claude', commandRoute: 'claude',
+    casks: ['claude-code', 'claude-code@latest'],
+    installer: { shell: '/bin/bash', url: 'https://claude.ai/install.sh', pipe: 'bash' },
+    loginArgs: ['auth', 'login', '--claudeai'], statusArgs: ['auth', 'status', '--json'],
+    credentialFiles: ['.claude.json', '.credentials.json'],
+    // HOW A WORKER IS STARTED, AS DATA. This was six hardcoded flag names in
+    // main/supervisor.mjs, which made the cheapest possible new engine — one
+    // that speaks this same stream-json and differs by a binary and the
+    // `outputFormat` value, as Grok Build does in
+    // github.com/savannahfeder/agentbox/issues/21 — a supervisor edit. A key
+    // left out here means this engine does not take that flag, and the builder
+    // leaves it off the line rather than the call site asking who it is.
+    run: {
+      print: '-p',
+      outputFormat: { flag: '--output-format', value: 'stream-json' },
+      stream: ['--verbose', '--include-partial-messages'],
+      effort: '--effort',
+      system: '--append-system-prompt',
+      resume: '--resume',
+      fork: '--fork-session',
+      // Replies arrive on stdin, so the prompt leaves the line when they do.
+      input: ['--input-format', 'stream-json', '--replay-user-messages'],
+    },
+    scrubPatterns: ['^ANTHROPIC_', '^CLAUDE_CODE_', '^CLAUDECODE$', '^CLAUDE_PID$', '^CLAUDE_EFFORT$', '^CLAUDE_CONFIG_DIR$'],
+    capabilities: { nativeCommands: true, fork: true, nativeReview: false, remoteControl: true, inlineImages: false, claudeEffort: true },
+    imageInstruction: 'Open each one with the Read tool, at the absolute path below.',
+  },
+  {
+    id: 'codex', label: 'Codex', word: 'Codex', binKey: 'codexBin',
+    homeEnv: 'CODEX_HOME', accountPrefix: 'codex:', package: '@openai/codex', casks: ['codex'],
+    commandMenu: 'codex', commandRoute: 'codex',
+    installer: { shell: '/bin/sh', url: 'https://chatgpt.com/codex/install.sh', pipe: 'sh' },
+    loginArgs: ['login'], statusArgs: ['login', 'status'], credentialFiles: ['auth.json'],
+    // NO `run`, AND THAT IS THE POINT OF THE SHAPE. Codex is driven over its
+    // app-server RPC: the prompt is a turn's `input`, the system block a
+    // thread's `developerInstructions`, the resume a thread id. An engine with
+    // no command line is handed none rather than handed Claude Code's.
+    scrubPatterns: ['^ANTHROPIC_', '^CLAUDE_CODE_', '^CLAUDECODE$', '^CLAUDE_PID$', '^CLAUDE_EFFORT$', '^CLAUDE_CONFIG_DIR$', '^OPENAI_', '^CODEX_'],
+    capabilities: { nativeCommands: false, fork: false, nativeReview: true, remoteControl: false, inlineImages: true, claudeEffort: false },
+    imageInstruction: 'Each one is attached to this message as an image, and is also on disk at the absolute path below.',
+  },
+  {
+    // OPENCODE, AND IT IS NOT OFFERED TO ANYBODY YET -- see `admitted` below.
+    //
+    // THE ONE THING THAT MAKES IT DIFFERENT FROM THE OTHER TWO: it needs no
+    // sign-in at all. Measured on a real OpenCode 1.18.35 on 2026-10-07 with
+    // `auth.json` holding zero credentials, `opencode models` still listed ten
+    // models and a run on one of them finished and reported `"cost":0`. They
+    // are the OpenCode Zen free tier. So this is the first harness where the
+    // first run costs nothing and asks for nothing, which is also why
+    // `signIn` below is a real command rather than a requirement.
+    //
+    // ITS CREDENTIAL STORE IS ITS OWN AND AGENTBOX NEVER TOUCHES IT. Keys go
+    // into ~/.local/share/opencode/auth.json by `opencode auth login`, which
+    // is the same shape as `claude auth login` and `codex login` above. The
+    // scrub list is therefore WIDER than the other two: it takes out every
+    // provider key OpenCode could otherwise read out of our environment,
+    // because CLAUDE.md says no API key goes into a worker, and OpenCode is
+    // the one tool here that would happily use one if it found it.
+    id: 'opencode', label: 'OpenCode', word: 'OpenCode', binKey: 'opencodeBin',
+    homeEnv: 'OPENCODE_CONFIG', accountPrefix: 'opencode:', package: 'opencode-ai',
+    commandMenu: 'opencode', commandRoute: 'opencode',
+    casks: ['opencode', 'sst/tap/opencode'],
+    installer: { shell: '/bin/bash', url: 'https://opencode.ai/install', pipe: 'bash' },
+    loginArgs: ['auth', 'login'], statusArgs: ['auth', 'list'],
+    credentialFiles: ['auth.json'],
+    scrubPatterns: [
+      '^ANTHROPIC_', '^CLAUDE_CODE_', '^CLAUDECODE$', '^CLAUDE_PID$', '^CLAUDE_EFFORT$', '^CLAUDE_CONFIG_DIR$',
+      '^OPENAI_', '^CODEX_', '^OPENCODE_', '^OPENROUTER_', '^GEMINI_', '^GOOGLE_',
+      '^AWS_', '^AZURE_', '^GROQ_', '^MISTRAL_', '^DEEPSEEK_', '^XAI_', '^CEREBRAS_',
+      '^TOGETHER_', '^FIREWORKS_', '^DEEPINFRA_', '^BASETEN_', '^NVIDIA_', '^GITLAB_TOKEN$',
+      '_API_KEY$', '_ACCESS_TOKEN$',
+    ],
+    // NO USAGE AND NO PLAN. There is no endpoint on the server and no command
+    // on the CLI that reports what is left of anything, because OpenCode bills
+    // through whichever provider the user connected and does not know. Per-run
+    // tokens and cost DO arrive (`step-finish`), and the adapter reports those;
+    // a plan limit is declared missing rather than faked as zero.
+    capabilities: { nativeCommands: true, fork: true, nativeReview: false, remoteControl: false, inlineImages: false, claudeEffort: false, planLimits: false },
+    imageInstruction: 'Open each one with the read tool, at the absolute path below.',
+    // ADMISSION IS A SEPARATE DECISION FROM INTEGRATION, and it is not ours.
+    // docs/harnesses.md: "A provider is not offered until that path works", and
+    // "a new provider's networking or permission scope requires the
+    // corresponding product policy review before admission." The transport is
+    // verified (see main/opencode-server.mjs for what was measured and how);
+    // whether OpenCode appears in the picker is a product call, so this stays
+    // false until somebody turns it on deliberately.
+    admitted: false,
+  },
+]);
+export function harnessDefinition(id = 'claude') {
+  return HARNESS_DEFINITIONS.find(h => h.id === id) ?? null;
+}

package/shared/notify-rules.d.mts

@@ -0,0 +1,25 @@
+// 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;
+
+// `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;

package/shared/notify-rules.mjs

@@ -31,6 +31,25 @@ export function atTheApp({ focused = false, idleMs = 0 } = {}) {
   return !!focused && 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.

package/shared/provider-commands.mjs

@@ -1,5 +1,6 @@
 // A command is an operation, never prose asking a model to imitate a CLI.
 import { CLAUDE_COMMANDS, commandWords } from './claude-commands.mjs';
+import { harnessDefinition } from './harness-definitions.mjs';
 const command = (name, description, argumentHint = null, aliases = []) => ({ name, description, menuDescription: null, whole: true, argumentHint, aliases });
 export const CODEX_COMMANDS = [
  command('model','Show models or change this task’s model','[model]'),
@@ -23,12 +24,18 @@ export const LOCAL_COMMANDS = CODEX_COMMANDS.filter(c=>['model','effort','diff',
 // is refused on Codex for now, in a sentence that says why, because that call
 // has never been made against a real server here.
 const FORK = command('fork','Start a new task from this conversation','<what to try instead>');
+const COMMAND_MENUS = {
+ codex: CODEX_COMMANDS,
+ claude: [command('remote-control','Continue this conversation in Claude on another device',null,['rc']),FORK,...CLAUDE_COMMANDS.map(c=>LOCAL_COMMANDS.find(l=>l.name===c.name)??c),...LOCAL_COMMANDS.filter(l=>!CLAUDE_COMMANDS.some(c=>c.name===l.name))],
+ local: LOCAL_COMMANDS,
+};
 export function providerCommands(engine) {
  // NOT ON THE CODEX MENU, because this menu's rule is that it offers nothing
  // that engine cannot run, and Codex forking is not connected yet. Typed there
  // it gets the ordinary unavailable refusal, which points at the native Codex
  // client, where `codex fork` genuinely works.
- return engine==='codex' ? CODEX_COMMANDS : [command('remote-control','Continue this conversation in Claude on another device',null,['rc']),FORK,...CLAUDE_COMMANDS.map(c=>LOCAL_COMMANDS.find(l=>l.name===c.name)??c),...LOCAL_COMMANDS.filter(l=>!CLAUDE_COMMANDS.some(c=>c.name===l.name))];
+ const definition = harnessDefinition(engine) ?? harnessDefinition();
+ return COMMAND_MENUS[definition.commandMenu] ?? [];
 }
 export function providerCommand(text, engine) {
  if(typeof text!=='string')return null;
@@ -38,7 +45,8 @@ export function providerCommand(text, engine) {
  const cmd=providerCommands(engine).find(c=>commandWords(c).includes(word));
  if(!cmd) return {name:word,args,route:'unavailable'};
  if(cmd.name==='fork')return {name:'fork',args,route:'fork'};
- return {name:cmd.name,args,route:cmd.name==='remote-control'?'remote':engine==='codex'?'codex':LOCAL_COMMANDS.some(c=>c.name===cmd.name)?'local':'claude'};
+ const route = (harnessDefinition(engine) ?? harnessDefinition()).commandRoute;
+ return {name:cmd.name,args,route:cmd.name==='remote-control'?'remote':route==='codex'?'codex':LOCAL_COMMANDS.some(c=>c.name===cmd.name)?'local':route};
 }
 export function reviewTarget(args='') {
  args=args.trim();

package/shared/rank.d.mts

@@ -18,3 +18,5 @@ export function landingIndex(
   x: number, y: number,
 ): number;
 export function moveProduct(order: string[], slug: string, toIndex: number): string[];
+export function placedScore(place: number | null | undefined, natural: number): number;
+export function dropPlaces(rows: Array<{ id: string; score: number }>, from: number, to: number): Record<string, number> | null;

package/shared/rank.mjs

@@ -155,6 +155,56 @@ export function landingIndex(rects, x, y) {
   return rects.length;
 }
 
+/**
+ * A THREAD'S OWN PLACE, SET BY DRAGGING IT IN THE LIST (w-6e5b532a95,
+ * 2026-10-07). Her words: "sometimes there are tasks that are higher priority
+ * than other projects and it's hard to articulate. I'd rather be able to drag
+ * things around here ... and have that priority remembered and that's how the
+ * app processes it." A project's place and a thread's level could never say
+ * that one Low thread matters more today than a whole project above it.
+ *
+ * So a dragged thread carries a PLACE: a number on the same scale as the score
+ * it would otherwise have, which replaces that score outright. It is a number
+ * and not a list of ids so that everything it was not dragged past keeps
+ * sorting the way it always did: a new Urgent thread still lands by its level,
+ * next to the placed ones rather than under all of them.
+ */
+export function placedScore(place, natural) {
+  return Number.isFinite(place) ? place : natural;
+}
+
+/**
+ * The places a drop writes. `rows` is the list as drawn, top first, each with
+ * the score it sorts by (its place, or its project and level); `from` is the
+ * dragged row and `to` the row it was let go in front of, or the length for
+ * the end, both counted in `rows`. Null when it lands where it was.
+ *
+ * The dragged row goes between its new neighbours. When those two TIE (two
+ * Medium threads in one project, whose order is only which changed last) no
+ * number fits between them, so the tied rows above the drop are given places
+ * of their own first, spread in the order they were drawn. The rows below are
+ * never written.
+ */
+export function dropPlaces(rows, from, to) {
+  if (!Array.isArray(rows) || from < 0 || from >= rows.length) return null;
+  const rest = rows.filter((_, i) => i !== from);
+  const at = Math.max(0, Math.min(rest.length, to > from ? to - 1 : to));
+  if (at === from || !rest.length) return null;
+  const close = (a, b) => Math.abs(a - b) < 1e-6;
+  const below = rest[at]?.score;
+  const floor = below ?? rest[at - 1].score - 2;
+  // The run of rows just above the drop that tie with the floor.
+  let top = at;
+  while (top > 0 && close(rest[top - 1].score, floor)) top -= 1;
+  const ceiling = top > 0 ? rest[top - 1].score : floor + 2;
+  const run = rest.slice(top, at);
+  const step = (ceiling - floor) / (run.length + 2);
+  const out = {};
+  run.forEach((r, j) => { out[r.id] = floor + (run.length + 1 - j) * step; });
+  out[rows[from].id] = floor + step;
+  return out;
+}
+
 /**
  * Move one product to a new index, returning a fresh order. Products that were
  * never in the order join it on their first move, so dragging an unranked chip