agentbox-app 0.1.12 → 0.1.16

package/shared/phone-snapshot.mjs

@@ -0,0 +1,348 @@
+// ONE THREAD, AS HER PHONE SEES IT WITH THE MAC SHUT (docs/cloud/PHONE-PLAN.md).
+//
+// Her Mac writes this for each thread of a project she put on her phone, and
+// the phone reads it. It is what the phone's own screens already draw: the row
+// as the Mac folded it (the phone never decides a thread's state from raw
+// lines; Codex's review of the plan, finding 5), and the thread's history as
+// the window reads it (store.readHistory), which the thread view turns into
+// the conversation. Long text is cut, and only the latest lines go. Browser-
+// safe: no node imports.
+
+import { checkSetting } from './phone-settings.mjs';
+
+// How much of one thread goes up. The latest of a thread is what she reads on
+// a phone; the whole of it stays on the Mac. `bytes` is measured in UTF-8, as
+// the database measures it (Codex's review of step 1, finding 9).
+export const SNAPSHOT_LIMITS = { lines: 400, textChars: 12_000, items: 300, bytes: 900_000 };
+
+// WHAT A COPY MAY CARRY, BY NAME (Codex's review of step 1, finding 2). A copy
+// is built out of these and nothing else, never by copying a row and deleting
+// the bad parts: a lease, an epoch, who may see a team thread, a field some
+// later version adds, none of it leaves unless it is named here.
+const ROW_FIELDS = [
+  'id', 'title', 'label', 'body', 'kind', 'labels', 'priority', 'parent', 'status',
+  'result', 'note', 'answer', 'runAt', 'snoozedUntil', 'answeredThrough',
+  'engine', 'model', 'start', 'due', 'problem', 'progress', 'solution',
+  'createdAt', 'updatedAt',
+];
+// The fields a line in a thread's history may carry in its patch: what the
+// thread view draws as the conversation and its state changes.
+const LINE_FIELDS = [
+  'title', 'label', 'body', 'kind', 'labels', 'priority', 'status', 'result',
+  'note', 'answer', 'runAt', 'snoozedUntil', 'start', 'due', 'problem',
+  'progress', 'solution', 'inReplyTo',
+];
+const SOURCES = new Set(['founder', 'agent', 'system']);
+
+// KEYS AND TOKENS IN WHAT AN AGENT OR SHE WROTE, hidden. A conversation can
+// quote one ("here is the key it used"), and a copy online is no place for it.
+const SECRETS = [
+  /-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?(?:-----END [A-Z ]*PRIVATE KEY-----|$)/g,
+  /\bsk-(?:ant-|proj-)?[A-Za-z0-9_-]{20,}/g,
+  /\b(?:ghp|gho|ghu|ghs|ghr)_[A-Za-z0-9]{30,}\b/g,
+  /\bgithub_pat_[A-Za-z0-9_]{40,}\b/g,
+  /\b(?:AKIA|ASIA)[0-9A-Z]{16}\b/g,
+  /\bxox[abposr]-[A-Za-z0-9-]{10,}/g,
+  /\bAIza[0-9A-Za-z_-]{35}\b/g,
+  /\beyJ[A-Za-z0-9_-]{10,}\.eyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}/g,
+  /\b(Bearer\s+)[A-Za-z0-9._~+/-]{20,}=*/gi,
+  /\b(Basic\s+)[A-Za-z0-9+/]{12,}=*/gi,
+];
+// A VALUE GIVEN A SECRET'S NAME, whatever it looks like (Codex's second and
+// third reviews): `AWS_SECRET_ACCESS_KEY=...`, `password: hunter22`,
+// `PASSWORD=12345678`, `password="correct horse battery staple"`. The name
+// stays, so the sentence still reads; a quoted value goes whole.
+const STRONG = '[A-Za-z0-9_.-]*(?:passw(?:or)?d|passphrase|secret|api[_-]?key|access[_-]?key|private[_-]?key|credentials?|authorization|(?:auth|access|refresh|session|bearer|id)[_-]?token)[A-Za-z0-9_.-]*';
+// "token" alone is a word people use ("token: unexpected identifier"), so it
+// counts only as an ENV_STYLE name, or before a long run that looks like a key.
+const WEAK = '(?:[A-Z0-9_]*TOKEN[A-Z0-9_]*|token)';
+// A quoted value goes whole, however long, escaped quotes and all; a bare one
+// is everything up to a space, brackets included (Codex's fourth review).
+const VALUE = '(?:"((?:[^"\\\\\\n]|\\\\.)*)"|\'((?:[^\'\\\\\\n]|\\\\.)*)\'|([^\\s"\',;]+))';
+const NAMED_STRONG = new RegExp(`\\b(${STRONG})(["']?\\s*[:=]\\s*)${VALUE}`, 'gi');
+const NAMED_WEAK = new RegExp(`\\b(${WEAK})(["']?\\s*[:=]\\s*)${VALUE}`, 'g');
+const hidden = (name, sep, dq, sq, bare) => `${name}${sep}${dq !== undefined ? '"[hidden]"' : sq !== undefined ? "'[hidden]'" : '[hidden]'}`;
+function hideNamed(text) {
+  let out = text.replace(NAMED_STRONG, (m, name, sep, dq, sq, bare) => (bare === '[hidden]' ? m : hidden(name, sep, dq, sq, bare)));
+  out = out.replace(NAMED_WEAK, (m, name, sep, dq, sq, bare) => {
+    const value = dq ?? sq ?? bare ?? '';
+    // MAX_TOKENS=128000 and TOKEN_LIMIT=8192 are settings: a bare number is
+    // never taken for a key under this weaker name.
+    const envStyle = name !== 'token' && name === name.toUpperCase() && !/^[0-9]+$/.test(value);
+    const keyLike = value.length >= 16 && /[0-9]/.test(value) && !/\s/.test(value);
+    return value !== '[hidden]' && (envStyle || keyLike) ? hidden(name, sep, dq, sq, bare) : m;
+  });
+  return out;
+}
+// AND A LONG RUN OF LETTERS AND DIGITS THAT LOOKS LIKE NOTHING BUT A KEY: 32 or
+// more, upper and lower case and digits all present. A commit id or a uuid is
+// one case of hex and is left alone.
+const KEYLIKE = /\b(?=[A-Za-z0-9_-]{32,}\b)(?=[A-Za-z0-9_-]*[a-z])(?=[A-Za-z0-9_-]*[A-Z])(?=[A-Za-z0-9_-]*[0-9])[A-Za-z0-9_-]{32,}\b/g;
+export function hideSecrets(text, { home = null } = {}) {
+  let out = String(text);
+  for (const re of SECRETS) out = out.replace(re, (m, bearer) => (typeof bearer === 'string' && /^(Bearer|Basic)/i.test(bearer) ? `${bearer}[hidden]` : '[hidden]'));
+  out = hideNamed(out);
+  out = out.replace(KEYLIKE, '[hidden]');
+  // Her home folder is ~ online, as it is in a crash report (shared/crash-scrub.mjs).
+  if (home && home.length > 1) out = out.split(home).join('~');
+  return out;
+}
+
+const clip = (s, n, ctx) => {
+  const t = hideSecrets(s, ctx);
+  return t.length > n ? `${t.slice(0, n)}…` : t;
+};
+// A value of a named field: text cut and cleaned, numbers as they are, short
+// lists of words, nothing nested.
+function plain(v, n, ctx) {
+  if (typeof v === 'string') return clip(v, n, ctx);
+  if (typeof v === 'number' && Number.isFinite(v)) return v;
+  if (typeof v === 'boolean' || v === null) return v;
+  if (Array.isArray(v)) return v.filter((x) => typeof x === 'string').slice(0, 40).map((x) => clip(x, 200, ctx));
+  return undefined;
+}
+function pick(obj, fields, n, ctx) {
+  const out = {};
+  for (const f of fields) {
+    if (!obj || !(f in obj)) continue;
+    const v = plain(obj[f], n, ctx);
+    if (v !== undefined) out[f] = v;
+  }
+  return out;
+}
+
+export const bytesOf = (value) => new TextEncoder().encode(JSON.stringify(value)).length;
+
+// `item` is the folded row; `history` is store.readHistory for it. `home` is
+// her home folder, written ~ in the copy.
+export function threadSnapshot(item, history = [], limits = SNAPSHOT_LIMITS, { home = null } = {}) {
+  const ctx = { home };
+  const row = pick(item, ROW_FIELDS, limits.textChars, ctx);
+  // Who wrote each field, which is how the screens tell her words from an
+  // agent's: the source and the moment, nothing else of it.
+  if (item?.wrote && typeof item.wrote === 'object') {
+    const wrote = {};
+    for (const f of ROW_FIELDS) {
+      const w = item.wrote[f];
+      if (w && SOURCES.has(w.source) && Number.isFinite(w.ts)) wrote[f] = { ts: w.ts, source: w.source };
+    }
+    row.wrote = wrote;
+  }
+  const lines = [];
+  for (const l of Array.isArray(history) ? history : []) {
+    if (!l || l.claim || l.release || l.heartbeat || !SOURCES.has(l.source) || !Number.isFinite(l.ts)) continue;
+    const patch = pick(l.patch, LINE_FIELDS, limits.textChars, ctx);
+    if (!Object.keys(patch).length) continue;
+    lines.push({ id: row.id, ts: l.ts, source: l.source, patch });
+  }
+  // Under the database's megabyte, with room: fewer lines until it fits, and
+  // then shorter text, so one long thread never stops the rest being sent.
+  for (let keep = limits.lines, chars = limits.textChars; ;) {
+    const kept = lines.slice(-keep);
+    const snap = {
+      v: 3,
+      item: chars === limits.textChars ? row : pick(row, ROW_FIELDS, chars, ctx),
+      history: chars === limits.textChars ? kept : kept.map((l) => ({ ...l, patch: pick(l.patch, LINE_FIELDS, chars, ctx) })),
+      olderLines: lines.length - kept.length,
+    };
+    if (row.wrote && snap.item !== row) snap.item.wrote = row.wrote;
+    if (bytesOf(snap) <= limits.bytes) return snap;
+    if (keep > 1) keep = Math.floor(keep / 2);
+    else if (chars > 200) chars = Math.floor(chars / 4);
+    else return { v: 3, item: { id: row.id, title: clip(row.title ?? '', 200, ctx), status: row.status, updatedAt: row.updatedAt }, history: [], olderLines: lines.length };
+  }
+}
+
+// WHICH PROJECTS ARE ON THE PHONE OF THE PERSON SIGNED IN.
+//
+// ALL OF THEM, UNLESS SHE SAYS OTHERWISE (2026-10-15: "95% of people just want
+// all of their projects connected ... I just turn them all on"). One switch
+// for the lot, on until she turns it off, and new projects go up with the
+// rest; keeping a project on this computer only is the exception, named
+// project by project (`except`).
+//
+// Her choice is kept with her id on it (`phoneProducts` in the config:
+// { owner, all, except }), so somebody else signing in on this computer starts
+// from the default rather than from her choices (Codex's review of step 1,
+// finding 1). A choice saved in the first shape, a list of the projects she
+// turned on ({ owner, slugs }), reads as all of them except the ones that list
+// left out, so the projects she had on stay on.
+// `every` is every project here, by slug.
+// The projects that can go to a phone at all: not the walk's practice project.
+export const phoneEligible = (products) => (Array.isArray(products) ? products : []).map((p) => p?.slug).filter((s) => typeof s === 'string' && s && s !== 'practice');
+export function phoneChoiceOf(saved, personId, every = []) {
+  const mine = personId && saved && typeof saved === 'object' && saved.owner === personId ? saved : null;
+  if (!mine) return { all: true, except: [] };
+  if (mine.all === undefined && Array.isArray(mine.slugs)) {
+    const on = new Set(mine.slugs);
+    return { all: true, except: every.filter((s) => !on.has(s)) };
+  }
+  return { all: mine.all !== false, except: Array.isArray(mine.except) ? mine.except.filter((s) => typeof s === 'string' && s) : [] };
+}
+export function phoneProjectsOf(saved, personId, every = []) {
+  if (!personId) return [];
+  const { all, except } = phoneChoiceOf(saved, personId, every);
+  if (!all) return [];
+  const kept = new Set(except);
+  return every.filter((s) => typeof s === 'string' && s && !kept.has(s));
+}
+// One project on or off the phone; the rest as they were.
+export function withPhoneProject(saved, personId, slug, on, every = []) {
+  if (!personId) throw new Error('sign in first');
+  const { all, except } = phoneChoiceOf(saved, personId, every);
+  const kept = new Set(except);
+  if (on) kept.delete(slug); else kept.add(slug);
+  return { owner: personId, all, except: [...kept] };
+}
+// The whole phone on or off; which projects stay local is remembered.
+export function withPhoneAll(saved, personId, on, every = []) {
+  if (!personId) throw new Error('sign in first');
+  const { except } = phoneChoiceOf(saved, personId, every);
+  return { owner: personId, all: !!on, except };
+}
+
+// A NEW THREAD STARTED ON THE PHONE has a row there before the Mac makes it,
+// under this id, and a reply to it before then is a reply to this id. The Mac
+// remembers which real row it became (main/phone-inbox.mjs) (Codex's review of
+// step 1, finding 8). Shaped like a row id, so every screen takes it.
+export const madeHere = (commandId) => `w-${String(commandId).replace(/[^0-9a-f]/gi, '').slice(0, 10).toLowerCase()}`;
+
+// The threads of a project worth carrying: everything not yet archived, and
+// what was finished in the last fortnight, newest first, at most `items`.
+export function threadsWorthCarrying(items, { now = Date.now(), limits = SNAPSHOT_LIMITS } = {}) {
+  const fortnight = 14 * 24 * 3600_000;
+  return (Array.isArray(items) ? items : [])
+    .filter((i) => i && !i.agent && (i.status !== 'done' || now - (i.updatedAt ?? 0) < fortnight))
+    .sort((a, b) => (b.updatedAt ?? 0) - (a.updatedAt ?? 0))
+    .slice(0, limits.items);
+}
+
+// A cheap, stable fingerprint, so a thread that did not change is not sent.
+export function snapshotKey(snapshot) {
+  const text = JSON.stringify(snapshot);
+  let h = 2166136261;
+  for (let i = 0; i < text.length; i += 1) { h ^= text.charCodeAt(i); h = Math.imul(h, 16777619); }
+  return `${text.length}:${(h >>> 0).toString(36)}`;
+}
+
+// WHAT HER PHONE MAY ASK HER MAC TO DO, and nothing else. A command that is not
+// one of these, or names a project she did not put on her phone, or a thread
+// that is not in it, is refused and says why.
+// A `setting` belongs to the computer, not a project (shared/phone-settings.mjs).
+export const PHONE_COMMANDS = ['reply', 'new', 'snooze', 'close', 'stop', 'run-now', 'send-now', 'reopen', 'schedule', 'approve', 'setting'];
+
+// A PERMISSION CARD AS HER PHONE DRAWS IT: what the agent asks to do, with the
+// secrets in it hidden as a thread's words are, and the fingerprint of the card
+// her Mac drew, which her answer must carry back.
+export function phoneApproval(request, card, ctx = {}) {
+  // Her Allow signs the whole request by its digest, so the phone may carry the
+  // digest only when it drew the request whole; a card that hid, clipped or
+  // dropped anything carries none and is answered on the computer. A home path
+  // written ~ is for her eyes, not a value hidden from what she signs.
+  let lossy = false;
+  const text = (s, n) => {
+    if (hideSecrets(s) !== s) lossy = true;
+    const t = hideSecrets(s, ctx);
+    if (t.length > n) { lossy = true; return `${t.slice(0, n)}…`; }
+    return t;
+  };
+  const clean = (v, depth = 0) => {
+    if (typeof v === 'string') return text(v, 4000);
+    if (typeof v === 'number' || typeof v === 'boolean' || v === null) return v;
+    if (depth > 3) { lossy = true; return undefined; }
+    if (Array.isArray(v)) { if (v.length > 40) lossy = true; return v.slice(0, 40).map((x) => clean(x, depth + 1)); }
+    if (v && typeof v === 'object') {
+      const entries = Object.entries(v);
+      if (entries.length > 40) lossy = true;
+      return Object.fromEntries(entries.slice(0, 40).map(([k, x]) => [k, clean(x, depth + 1)]));
+    }
+    return undefined;
+  };
+  const shown = { id: String(request.id), at: Number(request.at) || 0, tool: text(String(request.tool ?? 'unknown'), 200), input: clean(request.input ?? {}) };
+  return lossy ? { ...shown, card: null, answerOnComputer: true } : { ...shown, card };
+}
+
+// WHAT SHE PICKED WITH A REPLY OR A NEW THREAD, as the window's own handlers
+// take it (main/ipc.mjs zero:answer, zero:compose): only these fields, each
+// only in its right shape. Null on a reply clears a choice, as in the window.
+const WORD = /^[A-Za-z][\w.:-]{0,79}$/;
+const word = (v, n = 80) => typeof v === 'string' && v.length <= n && WORD.test(v);
+const orNull = (ok) => (v) => v === null || ok(v);
+const CHOICES = {
+  reply: {
+    permissionMode: orNull((v) => word(v, 40)), model: orNull(word), effort: orNull((v) => word(v, 20)),
+    priority: (v) => Number.isInteger(v) && v >= 0 && v <= 10, now: (v) => v === true, unschedule: (v) => v === true,
+  },
+  new: {
+    runAt: (v) => Number.isFinite(v) && v > 0, start: (v) => v === 'later' || v === 'now',
+    engine: (v) => word(v, 40), model: word, effort: (v) => word(v, 20), priority: (v) => Number.isInteger(v) && v >= 0 && v <= 10,
+    assignee: (v) => typeof v === 'string' && v.length >= 1 && v.length <= 80, due: (v) => typeof v === 'string' && v.length <= 40,
+    visibility: (v) => ['team', 'people', 'private'].includes(v),
+    visibleTo: (v) => Array.isArray(v) && v.length <= 50 && v.every((x) => typeof x === 'string' && x.length <= 80),
+  },
+};
+export function phoneChoices(kind, p) {
+  const out = {};
+  for (const [k, ok] of Object.entries(CHOICES[kind] ?? {})) if (p && k in p && p[k] !== undefined && ok(p[k])) out[k] = p[k];
+  return out;
+}
+export function checkCommand(cmd, { projects, hasItem }) {
+  if (!cmd || !PHONE_COMMANDS.includes(cmd.kind)) return 'not something the phone may do';
+  if (cmd.kind === 'setting') return cmd.project != null || cmd.item != null ? 'a setting names no project or thread' : checkSetting(cmd.payload);
+  if (!projects.includes(cmd.project)) return 'that project is not on your phone';
+  const p = cmd.payload || {};
+  if (cmd.kind === 'new') {
+    const title = typeof p.title === 'string' ? p.title.trim() : '';
+    const body = typeof p.body === 'string' ? p.body.trim() : '';
+    if (!title && !body) return 'a new thread needs some words';
+    return null;
+  }
+  if (!cmd.item || !hasItem(cmd.project, cmd.item)) return 'that thread is not on your phone';
+  if (cmd.kind === 'reply' && !(typeof p.text === 'string' && p.text.trim())) return 'an empty reply';
+  if (cmd.kind === 'snooze' && !(Number.isFinite(p.until) && p.until >= 0)) return 'a snooze needs a time';
+  if (cmd.kind === 'schedule' && !(Number.isFinite(p.runAt) && p.runAt >= 0)) return 'a schedule needs a time';
+  if (cmd.kind === 'approve' && !(typeof p.approval === 'string' && /^[\w-]{1,80}$/.test(p.approval) && typeof p.allow === 'boolean'
+    && typeof p.card === 'string' && /^[\w+/=-]{8,200}$/.test(p.card) && (p.note === undefined || (typeof p.note === 'string' && p.note.length <= 500)))) return 'an answer needs its card';
+  return null;
+}
+
+// A TURN THE CLOUD TOOK WITH THE COMPUTER SHUT, written into the thread's copy
+// by the cloud server (cloud/gateway/phone.mjs), as the computer would have
+// written it: her reply, the agent's answer and the row waiting on her
+// (main/store.mjs recordSessionResult). The computer's own copy replaces this
+// one once it is back and has brought the run home.
+export function withCloudTurn(snapshot, { reply, answer, repliedAt, answeredAt, status = 'blocked' }, limits = SNAPSHOT_LIMITS) {
+  if (!snapshot || typeof snapshot !== 'object' || !snapshot.item?.id) return null;
+  const ctx = { home: null };
+  const id = snapshot.item.id;
+  // No reply for a new thread's first turn: her ask is already its first line.
+  const replied = reply !== null && reply !== undefined;
+  const said = clip(String(reply ?? ''), limits.textChars, ctx);
+  const result = clip(String(answer ?? ''), limits.textChars, ctx);
+  const lines = [
+    ...(replied ? [{ id, ts: repliedAt, source: 'founder', patch: { answer: said, status: 'open' } }] : []),
+    { id, ts: answeredAt, source: 'agent', patch: { result } },
+    { id, ts: answeredAt, source: 'system', patch: { status } },
+  ];
+  const wrote = { ...(snapshot.item.wrote ?? {}), ...(replied ? { answer: { ts: repliedAt, source: 'founder' } } : {}), result: { ts: answeredAt, source: 'agent' }, status: { ts: answeredAt, source: 'system' } };
+  const item = { ...snapshot.item, ...(replied ? { answer: said } : {}), result, status, updatedAt: answeredAt, wrote };
+  let history = [...(Array.isArray(snapshot.history) ? snapshot.history : []), ...lines];
+  let older = Number(snapshot.olderLines) || 0;
+  while (history.length > limits.lines || (history.length > lines.length && bytesOf({ ...snapshot, item, history }) > limits.bytes)) {
+    history = history.slice(1);
+    older += 1;
+  }
+  return { ...snapshot, item, history, olderLines: older };
+}
+
+// THE PHONE'S COPY OF A THREAD THE CLOUD STARTED FROM THE PHONE, before its
+// computer has one: the row her ask made, being worked on.
+export function newThreadSnapshot({ itemId, title, body = '', at }, limits = SNAPSHOT_LIMITS) {
+  const words = { title: String(title ?? ''), ...(body ? { body: String(body) } : {}) };
+  const said = { ts: at, source: 'founder' };
+  return threadSnapshot(
+    { id: itemId, ...words, kind: 'directive', labels: ['founder'], priority: 0, status: 'claimed', createdAt: at, updatedAt: at, wrote: { title: said, ...(body ? { body: said } : {}) } },
+    [{ ts: at, source: 'founder', patch: { ...words, status: 'open' } }],
+    limits,
+  );
+}

package/shared/picture-formats.d.mts

@@ -0,0 +1 @@
+export declare function turnedName(name: string | null | undefined): string | null;

package/shared/picture-formats.mjs

@@ -0,0 +1,13 @@
+// PICTURES THE WINDOW CANNOT DRAW, and what each is turned into so it can.
+// Chromium decodes no TIFF and no HEIC, so one pasted or dropped into a reply
+// box is turned into a PNG or a JPEG as it comes in (main/stage-attachment.mjs).
+// Both sides read this: the window to know a dropped file is worth staging,
+// the main process to turn it.
+const TURNED = [[/\.tiff?$/i, '.png'], [/\.hei[cf]$/i, '.jpg']];
+
+/** The name the picture goes on under once turned, or null when it is not one of these. */
+export function turnedName(name) {
+  const s = String(name ?? '');
+  const hit = TURNED.find(([re]) => re.test(s));
+  return hit ? s.replace(/\.[^.]+$/, hit[1]) : null;
+}

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

@@ -8,7 +8,8 @@ export function placeScore(order: string[], slug: string, direct?: ReadonlySet<s
 
 export const DEFAULT_PRIORITY: number;
 
-export function itemPriority(item: { priority?: number; wrote?: Record<string, { source?: string } | undefined> } | null | undefined): number;
+export function itemPriority(item: { priority?: number | null; wrote?: Record<string, { source?: string } | undefined> } | null | undefined): number;
+export function shownPriority(item: { priority?: number | null; wrote?: Record<string, { source?: string } | undefined> } | null | undefined, conversation?: boolean): number | null;
 export const URGENT_PRIORITY: number;
 export function isUrgent(item: { priority?: number; wrote?: Record<string, { source?: string } | undefined> } | null | undefined): boolean;
 
@@ -18,3 +19,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

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

package/shared/relay-address.mjs

@@ -0,0 +1,6 @@
+// THE RELAY EVERY COPY OF THE APP USES (relay/worker.mjs), deployed to the
+// founder's Cloudflare account on 2026-10-12. With an address here every
+// computer offers "Anywhere" in Settings, then Phone, and starts new people on
+// it; AGENTBOX_RELAY_URL or relay/relay.local.json still take precedence
+// (main/relay-address.mjs). Redeploy with `cd relay && npx wrangler deploy`.
+export const RELAY_URL = 'https://agentbox-relay.agentbox-app.workers.dev';