agentbox-app 0.1.11 → 0.1.13

package/scripts/approval-server.sh

@@ -29,15 +29,39 @@ case "$here" in
   *app.asar.unpacked/scripts)
     res="$(cd "$here/../.." && pwd)"
     app="$(cd "$res/.." && pwd)"
-    exe="$(/usr/libexec/PlistBuddy -c 'Print :CFBundleExecutable' "$app/Info.plist" 2>/dev/null)"
-    [ -x "$app/MacOS/$exe" ] || exe="$(ls "$app/MacOS" 2>/dev/null | head -1)"
+    exe="$(/usr/libexec/PlistBuddy -c 'Print :CFBundleExecutable' "$app/Info.plist" 2>/dev/null || true)"
+    # A missing PlistBuddy leaves exe empty, and `[ -x dir/ ]` is true because
+    # a directory is executable. Require a regular file, then the one binary
+    # sitting in MacOS/.
+    if [ ! -f "$app/MacOS/$exe" ] || [ ! -x "$app/MacOS/$exe" ]; then
+      exe="$(ls "$app/MacOS" 2>/dev/null | head -1)"
+    fi
     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

@@ -58,7 +58,7 @@ export function agentImportRow(agent, { projectName = null, home = '' } = {}) {
   const inProject = projectName ? ` here in ${projectName}` : '';
   const scopeLine = agent?.scope === 'project'
     ? 'It works in this project only.'
-    : 'It works in every project on this Mac.';
+    : 'It works in every project on this computer.';
   const body = [
     `**Tell ${title} what to do first, in one sentence.**`,
     ...(line ? [line] : []),
@@ -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',
@@ -27,6 +31,7 @@ export const REQUEST_CHANNELS = {
   sendNow: 'zero:send-now',
   compose: 'zero:compose',
   schedule: 'zero:schedule',
+  snooze: 'zero:snooze',
   // Feedback to the Agentbox team, from the sidebar's Feedback card.
   sendFeedback: 'zero:send-feedback',
   // The team version: signing in, the team, sharing, routing a given task.
@@ -72,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',
@@ -90,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',
@@ -127,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. */
@@ -139,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,17 +1,19 @@
 // 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
 // cannot rot quietly.
 
-export const READ_FROM = "2.1.289";
-export const READ_AT = "2026-10-07";
+export const READ_FROM = "2.1.293";
+export const READ_AT = "2026-10-08";
 export const CLAUDE_COMMANDS = [
   {
     "name": "model",

package/shared/claude-models.generated.mjs

@@ -1,26 +1,28 @@
 // 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
 // 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.289";
-export const READ_AT = "2026-10-07";
+export const READ_FROM = "2.1.293";
+export const READ_AT = "2026-10-08";
 
 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-5","label":"Sonnet 5.5","defaultLevel":"medium"},
   {"alias":"claude-sonnet-5","id":"claude-sonnet-5","label":"Sonnet 5","defaultLevel":"high"},
-  {"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":"haiku","id":"claude-haiku-5-5","label":"Haiku 5.5","defaultLevel":"medium"},
+  {"alias":"claude-haiku-4-5","id":"claude-haiku-4-5","label":"Haiku 4.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/codex-modes.mjs

@@ -71,7 +71,7 @@ export const CODEX_MODES = {
     label: 'Full access',
     sandbox: 'danger-full-access',
     approvalPolicy: 'never',
-    what: 'Anything, anywhere on this Mac, without asking.',
+    what: 'Anything, anywhere on this computer, without asking.',
   },
 };
 

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/demo-world.mjs

@@ -214,7 +214,7 @@ function lines(now) {
     result: [
       'The clause summariser is merged and running. It read all ten contracts in the test folder and named every termination, auto renewal and liability clause in all ten, with two false positives on the longest one.',
       '',
-      'Ninety three seconds for the longest contract, four seconds for the shortest. Measured on this Mac, not estimated.',
+      'Ninety three seconds for the longest contract, four seconds for the shortest. Measured on this computer, not estimated.',
     ].join('\n'),
   });
 

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/fresh-user-home.mjs

@@ -13,7 +13,9 @@
 // would take her real setup with it, which is not a thing a test may cost. So
 // NOTHING IS DELETED, EVER. A second copy is launched inside a fresh home under
 // /tmp and all three land in there: fresh settings, no config file so it falls
-// to DEFAULTS, and an empty store at `<throwaway>/<Name>`.
+// to DEFAULTS, and an empty store at that home's defaultStoreRoot. On macOS
+// that is `<throwaway>/<Name>`. On Linux it is `<throwaway>/.local/share/<slug>`,
+// and only when the copy was not handed the real XDG_DATA_HOME.
 //
 // WHY IT DOES NOT KILL HER AGENTS, which is the whole reason it is usable.
 // `main.mjs` quits on `app.requestSingleInstanceLock`, and that lock is keyed
@@ -180,6 +182,15 @@ export const NOT_INHERITED = Object.freeze([
   // Where her own Claude Code and Codex sign-ins live, when she has moved them.
   'CLAUDE_CONFIG_DIR',
   'CODEX_HOME',
+  // The Linux store default reads XDG_DATA_HOME. A fresh copy that inherited
+  // the real one would write its empty store into her data directory, which is
+  // the 2026-09-27 bug again with a different variable. The other base
+  // directories go for the same reason. XDG_RUNTIME_DIR stays: it is this
+  // login's bus socket, not a directory we keep the inbox in.
+  'XDG_DATA_HOME',
+  'XDG_CONFIG_HOME',
+  'XDG_STATE_HOME',
+  'XDG_CACHE_HOME',
 ]);
 
 /**

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;
+}