agentbox-app 0.1.12 → 0.1.16

package/main/artifact-path.mjs

@@ -66,28 +66,55 @@ export function artifactRoots(prod) {
 // now resolves by exact path or not at all.
 const SKIP = new Set(['node_modules', '.git', 'dist', 'build', '.next', 'sessions', 'runs', 'pending-writes', 'checkpoints']);
 
-// Hunt the file down by NAME inside one product's trees, newest match wins.
-// Workers write links relative to whatever directory they were standing in, so
-// a fixed root list will always miss some of them, and every miss cost her a
-// 10-minute detour (2026-08-05). Bounded: six levels, own product only.
-function huntByName(base, roots, fs) {
-  let best = null;
-  const walk = (dir, depth) => {
+// How long one walk of a tree answers for it. A thread asks for every name it
+// mentions the moment it opens, so the walk has to outlive that burst; a
+// picture that lands later is found by the next look, which comes after this.
+export const HUNT_FRESH_MS = 5000;
+const walks = new Map();
+
+// Every file name in one tree, read without holding the main process.
+async function walkNames(tree, fs) {
+  const names = new Map();
+  const walk = async (dir, depth) => {
     if (depth > 6) return;
     let entries;
-    try { entries = fs.readdirSync(dir, { withFileTypes: true }); } catch { return; }
+    try { entries = await fs.promises.readdir(dir, { withFileTypes: true }); } catch { return; }
+    const below = [];
     for (const e of entries) {
       if (e.name.startsWith('.')) continue;
       const full = path.join(dir, e.name);
-      if (e.isDirectory()) { if (!SKIP.has(e.name)) walk(full, depth + 1); }
-      else if (e.name === base) {
-        let m = 0;
-        try { m = fs.statSync(full).mtimeMs; } catch {}
-        if (!best || m > best.m) best = { full, m };
-      }
+      if (e.isDirectory()) { if (!SKIP.has(e.name)) below.push(walk(full, depth + 1)); }
+      else if (names.has(e.name)) names.get(e.name).push(full);
+      else names.set(e.name, [full]);
     }
+    await Promise.all(below);
   };
-  for (const root of roots) walk(root, 0);
+  await walk(tree, 0);
+  return names;
+}
+
+function namesIn(tree, fs, now) {
+  const kept = walks.get(tree);
+  if (kept && kept.fs === fs && now - kept.at < HUNT_FRESH_MS) return kept.names;
+  const names = walkNames(tree, fs);
+  walks.set(tree, { at: now, fs, names });
+  if (walks.size > 32) walks.delete(walks.keys().next().value);
+  return names;
+}
+
+// Hunt the file down by NAME inside one product's trees, newest match wins.
+// Workers write links relative to whatever directory they were standing in, so
+// a fixed root list will always miss some of them, and every miss cost her a
+// 10-minute detour (2026-08-05). Bounded: six levels, own product only.
+async function huntByName(base, trees, fs, now) {
+  let best = null;
+  for (const tree of trees) {
+    for (const full of (await namesIn(tree, fs, now)).get(base) ?? []) {
+      let m;
+      try { m = (await fs.promises.stat(full)).mtimeMs; } catch { continue; }
+      if (!best || m > best.m) best = { full, m };
+    }
+  }
   return best?.full ?? null;
 }
 
@@ -104,7 +131,7 @@ export function notFoundMessage(raw, own, product) {
 //
 // `products` is the whole list only so the card's own product can be found in
 // it. Nothing in here reads another entry.
-export function resolveArtifact({ src, product, products = [], accountRoot, storeRoot, fs = fsDefault }) {
+export async function resolveArtifact({ src, product, products = [], accountRoot, storeRoot, fs = fsDefault, now = Date.now() }) {
   if (typeof src !== 'string' || !src) return { ok: false, error: 'No file was named.' };
   const raw = decodeURIComponent(src.replace(/^file:\/\//, '')).replace(/^\.\//, '');
   const own = products.find((x) => x.slug === product) ?? null;
@@ -144,10 +171,12 @@ export function resolveArtifact({ src, product, products = [], accountRoot, stor
 
   // The hunt takes the two TREES, not the root list: designs/ and attachments/
   // sit inside the docs dir already, and walking them twice finds nothing new.
+  // A run's change record is never hunted for: `runs` is skipped, so the walk
+  // could not find it, and the open thread asks for it on every refresh.
   const base = path.basename(raw);
   const trees = own ? [own.dir, own.repoPath].filter(Boolean) : [];
-  if (base && trees.length) {
-    const found = huntByName(base, trees, fs);
+  if (base && trees.length && raw.split('/')[0] !== 'runs') {
+    const found = await huntByName(base, trees, fs, now);
     if (found) return { ok: true, path: found };
   }
 

package/main/claude-bin.mjs

@@ -1,338 +1,72 @@
-// Where Claude Code actually is, on a machine that is not hers.
+// Where Claude Code actually is, on a machine that is not ours.
 //
-// Agentbox assumed one path, `~/.local/bin/claude`, which is where Claude Code's
-// own installer puts it. That is one of several normal answers: install through
-// npm or Homebrew and the binary is somewhere else entirely. For those people
-// the app found nothing, said "missing" on a grey dot in Settings, and gave no
-// sentence and no next step. It read as broken rather than as unfinished.
+// THIS FILE IS NOW THE NAMES AND NOTHING ELSE. The search, the registry entry
+// that declares Claude Code, the measured notes about where it installs and the
+// `found` / `certain` rule all live in main/engine-bin.mjs, which does the same
+// job for every coding agent the app can run. Until 2026-10-08 this was 338
+// lines and main/codex-bin.mjs was 279, and they were two copies of one idea:
+// adding a harness meant a third file and three hundred lines of test.
 //
-// THE RULE this file exists to keep: never tell someone Claude Code is
-// missing unless we are certain it is.
-//
-// So there are two different questions here and they must never be answered by
-// the same value. `found` is whether a runnable file is really there, and it
-// decides which path gets spawned. `certain` is whether we are entitled to SAY
-// it is missing, and everything below exists to make `certain` hard to earn.
-//
-// Four steps before an absence is ever claimed, cheapest first.
-//
-// KNOWN PATHS. A filesystem check is instant, spawns nothing, and is the right
-// answer for most machines. The list is every normal home for this binary: the
-// installer's own directory, Claude Code's local install (what
-// `claude migrate-installer` leaves behind), Homebrew on Apple Silicon and on
-// Intel, MacPorts, and the default bin of every package manager that is not npm.
-//
-// VERSION MANAGER DIRECTORIES. nvm, fnm, n and asdf each keep one bin directory
-// PER INSTALLED NODE, under a name nobody can guess, so they are read rather
-// than listed. A global npm install under any of them lands there and nowhere
-// else, and this is the case the shell step used to be the only cover for.
-//
-// THE SHELL. The catch-all for installs no list can enumerate: volta, bun, a
-// custom npm prefix. It must be a LOGIN, INTERACTIVE shell, because those
-// managers put themselves on PATH from `.zprofile` and `.zshrc` and nowhere
-// else. And it is needed at all because a double-clicked Electron app inherits
-// launchd's PATH, which is /usr/bin:/bin:/usr/sbin:/sbin and has never heard of
-// any of them. That is the whole reason an npm install is obvious in a terminal
-// and invisible to the app. It is asked more than once now, because ONE probe
-// that fails to start is not a fact about anybody's Mac.
+// WHAT IS KEPT HERE is the vocabulary the rest of the app already imports --
+// main/config.mjs, main/settings.mjs, scripts/read-claude-commands.mjs,
+// scripts/read-claude-models.mjs -- plus `askShell` and `shellProbes`, which
+// several tests reach for through this file because Claude Code is the binary the
+// app will not open an inbox without.
 //
-// EVIDENCE THAT IT LIVES HERE ANYWAY. Last, and it decides nothing about which
-// binary to run: it only takes away our right to announce an absence. Claude
-// Code leaves a home folder, a settings file and a projects directory behind
-// the moment it is used once. If those are on this Mac then Claude Code is on
-// this Mac, whatever our search of PATH did or did not manage, and the honest
-// thing on the screen is silence rather than a sentence telling somebody to
-// install software they are already running. A dangling `claude` symlink counts
-// the same way, and it is a real state: the installer points ~/.local/bin/claude
-// at a versioned file and swaps that file on every update.
+// THE RULE THIS FILE ARGUED FOR AND engine-bin.mjs KEEPS: never tell somebody
+// Claude Code is missing unless we are certain it is. `found` is whether a
+// runnable file is really there, and it decides which path gets spawned.
+// `certain` is whether we are entitled to SAY it is missing.
 //
 // Nothing here overrides the config file. An explicit `claudeBin` in
-// zero.config.json wins untouched and is never searched around, because that
-// file promises explicit paths with no discovery, and a search that
-// second-guesses a written setting would break that promise.
+// zero.config.json wins untouched and is never searched around.
 
-import fs from 'node:fs';
 import os from 'node:os';
-import path from 'node:path';
-import { execFileSync } from 'node:child_process';
-
-// In order. The first that exists wins, so the installer's path stays first and
-// a machine that has always worked keeps resolving exactly as it did.
-export function candidatePaths(home = os.homedir()) {
-  return [
-    path.join(home, '.local/bin/claude'),    // the installer
-    path.join(home, '.claude/local/claude'), // claude migrate-installer
-    '/opt/homebrew/bin/claude',              // Homebrew, Apple Silicon
-    '/usr/local/bin/claude',                 // Homebrew on Intel, and npm -g
-    path.join(home, '.bun/bin/claude'),      // bun
-    path.join(home, '.volta/bin/claude'),    // volta
-    path.join(home, '.asdf/shims/claude'),   // asdf, through its shims
-    path.join(home, '.npm-global/bin/claude'), // the two npm prefixes people
-    path.join(home, '.npm-packages/bin/claude'), // actually write in a guide
-    path.join(home, '.yarn/bin/claude'),     // yarn global
-    path.join(home, 'Library/pnpm/claude'),  // pnpm's own bin on macOS
-    path.join(home, '.local/share/pnpm/claude'), // pnpm's own bin on Linux
-    path.join(home, '.deno/bin/claude'),     // deno
-    path.join(home, 'bin/claude'),           // a hand-rolled ~/bin on PATH
-    '/opt/local/bin/claude',                 // MacPorts
-    '/usr/bin/claude',                       // packaged by something system-wide
-  ];
-}
-
-// One bin directory per installed Node, under a name no list can hold. Read
-// rather than guessed, and a directory that is not there just contributes
-// nothing. This is where a global npm install under nvm, fnm, n or asdf ends
-// up, and until now only the shell could reach it.
-export function versionedPaths(home = os.homedir(), readdir = defaultReaddir) {
-  const under = (dir, tail) => readdir(path.join(home, dir)).map((v) => path.join(home, dir, v, tail));
-  return [
-    ...under('.nvm/versions/node', 'bin/claude'),
-    ...under('.local/share/fnm/node-versions', 'installation/bin/claude'),
-    ...under('Library/Application Support/fnm/node-versions', 'installation/bin/claude'),
-    ...under('n/versions/node', 'bin/claude'),
-    ...under('.asdf/installs/nodejs', 'bin/claude'),
-  ];
-}
-
-function defaultReaddir(dir) {
-  try { return fs.readdirSync(dir); } catch { return []; }
-}
-
-// THE COPY THE CLAUDE APP KEEPS FOR ITSELF, one folder per version, newest
-// first. Somebody who has only ever used Claude Code inside the Claude app has
-// this and nothing else (w-9f6975906c, measured 2026-10-05: 2.1.209 there, and
-// it shared the CLI's sign-in). It is searched LAST, after the shell, because it
-// updates when the app does and a real install is fresher.
-export function appCopyPaths(home = os.homedir(), readdir = defaultReaddir) {
-  const dir = path.join(home, 'Library/Application Support/Claude/claude-code');
-  return readdir(dir)
-    .filter((v) => /^\d+(\.\d+)*$/.test(v))
-    .sort(newestFirst)
-    .map((v) => path.join(dir, v, 'claude.app/Contents/MacOS/claude'));
-}
-
-function newestFirst(a, b) {
-  const x = a.split('.').map(Number), y = b.split('.').map(Number);
-  for (let i = 0; i < Math.max(x.length, y.length); i++) {
-    if ((x[i] ?? 0) !== (y[i] ?? 0)) return (y[i] ?? 0) - (x[i] ?? 0);
-  }
-  return 0;
-}
-
-// WHAT CLAUDE CODE LEAVES BEHIND. Any one of these means it has run on this
-// Mac. None of them is a binary and none of them is ever spawned; they exist
-// only to stop the app announcing an absence it cannot support.
-export function evidencePaths(home = os.homedir()) {
-  return [
-    path.join(home, '.claude.json'),               // its own config file
-    path.join(home, '.claude/settings.json'),
-    path.join(home, '.claude/projects'),           // one folder per project it has opened
-    path.join(home, '.claude/statsig'),
-    path.join(home, '.claude/.credentials.json'),  // it has been logged in
-    path.join(home, '.claude/history.jsonl'),
-    path.join(home, '.local/share/claude'),        // the installer's version store
-  ];
-}
-
-// A path that is a symlink to nothing. `existsSync` follows the link and says
-// false, which is indistinguishable from nothing being there at all, and the
-// two mean opposite things: an update that has swapped the versioned file out
-// from under ~/.local/bin/claude leaves exactly this for a moment.
-function defaultDangles(p) {
-  try { return !!fs.lstatSync(p) && !fs.existsSync(p); } catch { return false; }
-}
-
-export function installEvidence({ home = os.homedir(), exists = fs.existsSync, dangles = defaultDangles } = {}) {
-  for (const p of evidencePaths(home)) if (exists(p)) return p;
-  for (const p of candidatePaths(home)) if (dangles(p)) return p;
-  return null;
-}
+import {
+  ENGINES, findEngine, resolveEngine, forgetEngine, installEvidence as evidenceFor,
+  versionedBinPaths, askShell, shellProbes,
+} from './engine-bin.mjs';
 
-export const INSTALL_URL = 'https://code.claude.com/docs/en/setup';
+export { askShell, shellProbes };
 
-// The shells worth asking, in order, and never the same one twice. Hers first
-// because it is the one that has her PATH in it; the other two because a
-// $SHELL that will not start is a fact about $SHELL and not about Claude Code.
-export function shellProbes(env = process.env) {
-  const preferred = env.SHELL || '/bin/zsh';
-  const out = [[preferred, '-lic', 4000], [preferred, '-lc', 2500]];
-  for (const other of ['/bin/zsh', '/bin/bash']) {
-    if (other !== preferred) out.push([other, '-lic', 2500]);
-  }
-  return out;
-}
+const CLAUDE = ENGINES.claude;
 
-// Ask the user's own login shell, and go on asking until one of them answers.
-// Anything that is not an absolute path to a file that exists is treated as no
-// path: `command -v` also prints shell functions and aliases, and a function
-// name handed to spawn is a crash with a worse message than "not found".
-//
-// `answered` is the strict half. It is true only when every probe that ran came
-// back with a real exit status, and at least one did. One shell that timed out
-// alongside one that said no is not a machine we know anything about.
-//
-// `bin` is a parameter rather than the word `claude` baked into the command
-// because Codex is a second engine (her ask, 2026-08-25) and it is found in the
-// same way: same shells, same "two different silences" rule, same refusal to
-// read a shell function name as a path. It is DEFAULTED, so every existing
-// caller and every existing test asks about Claude Code as it always did, and
-// that matters more here than it would anywhere else: this is the binary the
-// app will not open an inbox without.
-/**
- * WHAT MAY BE HANDED TO A LOGIN SHELL, AND WHY THIS IS CHECKED AT ALL.
- *
- * The probe below interpolates `bin` into a string a LOGIN, INTERACTIVE shell
- * executes, with her profile loaded, as her. Both callers today pass a literal
- * ('claude' here, 'codex' in main/codex-bin.mjs), so nothing is exploitable
- * now. But the entire direction of the second-engine work is a binary somebody
- * can configure, and a `codexBin` read out of zero.config.json reaching this
- * argument is one plausible slice away; at that point `command -v x; curl | sh`
- * is a string in a file that runs itself.
- *
- * This function looks up program NAMES, so a name is all it takes. An allowlist
- * rather than quoting, because quoting is a thing a later edit can undo without
- * noticing and a shape check is not.
- */
-const PROGRAM_NAME = /^[A-Za-z0-9][A-Za-z0-9._+-]*$/;
+export const INSTALL_URL = CLAUDE.installUrl;
 
-export function askShell({ env = process.env, exists = fs.existsSync, run = defaultRun, bin = 'claude' } = {}) {
-  if (typeof bin !== 'string' || !PROGRAM_NAME.test(bin)) {
-    throw new Error(`askShell looks up a program name, and ${JSON.stringify(bin)} is not one`);
-  }
-  let said = false;
-  let inconclusive = false;
-  for (const [shell, flags, timeout] of shellProbes(env)) {
-    let out = '';
-    try {
-      out = run(shell, [flags, `command -v ${bin}`], timeout);
-    } catch (e) {
-      // TWO DIFFERENT SILENCES, AND ONLY ONE OF THEM IS AN ANSWER.A shell that
-      // ran and exited non-zero has told us claude is not on PATH, and that is
-      // an answer. A shell that could not be started, or that ran past the
-      // timeout, has told us nothing at all, and reporting nothing as "not
-      // installed" is what put a line about missing software on the screen of
-      // people who have it.
-      if (exitedSayingNo(e)) said = true; else inconclusive = true;
-      continue;
-    }
-    const line = String(out).split('\n').map((s) => s.trim()).filter(Boolean).pop();
-    if (line && line.startsWith('/') && exists(line)) return { path: line, answered: true };
-    said = true;
-  }
-  return { path: null, answered: said && !inconclusive };
+/** Every normal home for this binary, in order; the first that exists wins. */
+export function candidatePaths(home = os.homedir()) {
+  return CLAUDE.candidates(home, () => []);
 }
 
-// The shell ran to completion and returned a non-zero exit code, which for
-// `command -v` is how "not on PATH" is spelt. A timeout (SIGTERM, ETIMEDOUT)
-// and a shell that does not exist (ENOENT) both arrive here too, and neither
-// of them is a fact about Claude Code.
-function exitedSayingNo(e) {
-  if (!e || typeof e !== 'object') return false;
-  if (e.signal || e.code === 'ETIMEDOUT' || e.code === 'ENOENT') return false;
-  return typeof e.status === 'number';
+/** One bin directory per installed Node, read rather than guessed. */
+export function versionedPaths(home = os.homedir(), readdir = undefined) {
+  return versionedBinPaths('claude', home, readdir);
 }
 
-// askShell used to answer with a path or null, and both a real answer and a
-// failed probe were null. Anything still handing back the old shape is read as
-// an answer, because that is what it always meant.
-function shellSaid(result) {
-  if (typeof result === 'string') return { path: result, answered: true };
-  if (!result || typeof result !== 'object') return { path: null, answered: true };
-  return { path: result.path ?? null, answered: result.answered !== false };
+/** The copy the Claude desktop app keeps for itself, newest version first. */
+export function appCopyPaths(home = os.homedir(), readdir = undefined) {
+  return CLAUDE.appCopies(home, readdir);
 }
 
-function defaultRun(shell, args, timeout = 4000) {
-  return execFileSync(shell, args, {
-    encoding: 'utf8',
-    // stdin ignored on purpose: an interactive shell handed a live terminal can
-    // sit waiting for input, and this runs on the boot path.
-    stdio: ['ignore', 'pipe', 'ignore'],
-    timeout,
-  });
+/** What Claude Code leaves behind. None of it is ever spawned. */
+export function evidencePaths(home = os.homedir()) {
+  return CLAUDE.evidence(home, {});
 }
 
-// The whole search, as a pure function of its inputs so a test can put Claude
-// Code anywhere without touching the machine it runs on.
-//
-// Returns { path, found, certain, from, searched, evidence }. `found` is the
-// only claim about the world: it means a file is really there. `certain` says
-// whether we are allowed to tell somebody it is NOT there, so a screen can stay
-// quiet rather than announce an absence it has not established. They come apart
-// in exactly one case that is not a failure, and it is the case worth keeping
-// honest: she has set `claudeBin` to a path that does not exist, so the path
-// stays HERS (anything that spawns it should fail naming the path she chose,
-// not one we picked) while the screen says it was not found and offers the
-// install link, the same as any other machine.
-export function findClaudeBin({
-  configured = null,
-  home = os.homedir(),
-  exists = fs.existsSync,
-  shellLookup = askShell,
-  readdir = defaultReaddir,
-  dangles = defaultDangles,
-} = {}) {
-  if (configured) {
-    return {
-      path: configured, found: exists(configured), certain: true, from: 'settings',
-      searched: [], evidence: null,
-    };
-  }
-
-  const searched = [...candidatePaths(home), ...versionedPaths(home, readdir)];
-  for (const candidate of searched) {
-    if (exists(candidate)) return { path: candidate, found: true, certain: true, from: 'disk', searched, evidence: null };
-  }
-
-  const fromShell = shellSaid(shellLookup());
-  if (fromShell.path) return { path: fromShell.path, found: true, certain: true, from: 'shell', searched, evidence: null };
-
-  for (const candidate of appCopyPaths(home, readdir)) {
-    if (exists(candidate)) return { path: candidate, found: true, certain: true, from: 'app', searched, evidence: null };
-  }
-
-  // NOT FOUND, AND WHETHER THAT IS KNOWN. Every cheap path missed and every
-  // shell we could reach missed, so the last question is whether this Mac shows
-  // any sign of Claude Code anyway. If it does, we looked in the wrong places
-  // rather than at an empty machine, and nothing may be said out loud.
-  const evidence = installEvidence({ home, exists, dangles });
-  return {
-    path: null,
-    found: false,
-    certain: fromShell.answered && !evidence,
-    from: null,
-    searched,
-    evidence,
-  };
+export function installEvidence({ home = os.homedir(), exists, dangles } = {}) {
+  return evidenceFor('claude', { home, env: {}, exists, dangles });
 }
 
-/* ------------------------------- the cache -------------------------------- */
-// Only the SHELL step is remembered, and only briefly. Nothing else is: the
-// path checks are stat calls, and caching them is how the settings screen ends
-// up telling someone to install Claude Code and then still saying "not found"
-// after they have. The sentence on that screen makes a promise and a cached
-// answer breaks it.
-//
-// The shell is the one part worth holding, because it is up to three
-// subprocesses and a screen she toggles a switch on reads settings again on
-// every write. Thirty seconds is long enough that a burst of writes pays for it
-// once, and short enough that it is never the reason someone is still stuck.
-
-const SHELL_TTL = 30_000;
-let shellAnswer = null;
-let shellAskedAt = 0;
-
-function rememberedShellLookup(now, lookup) {
-  if (shellAskedAt && now - shellAskedAt < SHELL_TTL) return shellAnswer;
-  shellAnswer = lookup();
-  shellAskedAt = now;
-  return shellAnswer;
+/** The whole search. See main/engine-bin.mjs for what each answer means. */
+export function findClaudeBin(where = {}) {
+  return findEngine('claude', where);
 }
 
-export function resolveClaudeBin(configured = null, { now = Date.now(), shellLookup = askShell, ...where } = {}) {
-  return findClaudeBin({ ...where, configured, shellLookup: () => rememberedShellLookup(now, shellLookup) });
+/** The same search with the shell step held for thirty seconds. */
+export function resolveClaudeBin(configured = null, where = {}) {
+  return resolveEngine('claude', configured, where);
 }
 
 export function forgetClaudeBin() {
-  shellAnswer = null;
-  shellAskedAt = 0;
+  forgetEngine('claude');
 }

package/main/claude-input.mjs

@@ -1,4 +1,5 @@
 import { randomUUID } from 'node:crypto';
+import { Name } from '../shared/product-name.mjs';
 
 // THE SESSION STOPPED LISTENING BEFORE IT TOOK THIS MESSAGE. Not a refusal:
 // the turn closed, or the process went, in the seconds between her pressing
@@ -16,12 +17,29 @@ function turnClosed(message) {
 // before the session is closed anyway. Measured wakes arrive in about a second.
 const WAKE_GRACE_MS = 2 * 60 * 1000;
 
-export function claudeStreamArgs(args) {
+// Said to the agent, never shown to the person: the trace keeps no user turns.
+// Paths are cut to their last part: a cloud run's relay uploads any file its
+// input names outside the task folder (main/cloud/run.mjs `filesNamedIn`).
+export function stillRunningNote(tasks) {
+  const plain = (text) => String(text).replace(/(^|[\s"'`(=:])\/(?:[^\s"'`<>()[\]{},;\\]*\/)+/g, '$1');
+  const names = tasks.map((t) => `"${plain(t.description || t.task_id).slice(0, 120)}"`).join(', ');
+  return `This is ${Name}, not the person. Your turn ended with ${tasks.length === 1 ? 'this' : 'these'} still running in the background: ${names}. `
+    + 'Your run stays open, and your answer is not delivered, until nothing you started is still running. '
+    + 'Stop any you no longer need. If you are waiting on one, say what for in one line and end your turn.';
+}
+
+// THE PROMPT LEAVES THE LINE WHEN REPLIES ARRIVE ON STDIN. Both the print flag
+// and the input-format flags are read off the engine's `run` definition, so an
+// engine of this family that spells either of them differently is a definition
+// and not a change here. An engine with no `input` cannot take corrections on
+// stdin, and gets its line back as it was.
+export function streamInputArgs(run, args) {
+  if (!run?.input) return [...args];
   const copy = [...args];
-  const index = copy.indexOf('-p');
+  const index = copy.indexOf(run.print);
   if (index < 0) throw Error('Missing print prompt');
   copy.splice(index + 1, 1);
-  return [...copy, '--input-format', 'stream-json', '--replay-user-messages'];
+  return [...copy, ...run.input];
 }
 
 // Replay-user-messages acknowledges the exact UUID when Claude consumes it.
@@ -39,13 +57,35 @@ export function attachClaudeInput(child) {
   // end of the run, and closing there killed the suite it was waiting on
   // (tests/an-agent-waiting-on-its-own-tests-does-not-come-back-to-you).
   let waiting = [], wakeTimer = null;
+  // Jobs the agent has been told are still out, and the messages that told it.
+  // A forgotten job holds a finished answer until Claude Code's own limit
+  // stops it, thirty minutes and more
+  // (tests/a-command-an-agent-left-running-does-not-hold-its-answer-back).
+  const named = new Set(), ours = new Set();
   // Input only ever closes at a result with nothing out, so a closed input is
   // the one proof the run reached its end. A session that exits with input
   // still open was stopped part-way, whatever its last turn said
   // (tests/a-worker-whose-helpers-are-still-working-does-not-come-back-to-you).
   let ended = false;
+  // A TURN IS RUNNING between its `system/init` and its result. A message
+  // written while none is starts the next one, and a turn that starts while
+  // one waits takes it with it, so either way it is being answered, though
+  // Claude replays it only when that turn first speaks. Send now must not cut
+  // that turn: it was the answer (w-0202576e73).
+  let inTurn = false;
   const closeInput = () => { closed = true; ended = true; clearTimeout(wakeTimer); child.stdin.end(); };
   const mayClose = () => !held && atResult && !pending.size && !waiting.length;
+  // Not into a session she is driving, and not when her own message is about
+  // to start the next turn. Kept out of `pending`, so it never holds input open.
+  const nameWhatIsStillOut = () => {
+    if (closed || held || pending.size || !waiting.some((t) => t?.task_id && !named.has(t.task_id))) return;
+    for (const t of waiting) if (t?.task_id) named.add(t.task_id);
+    const uuid = randomUUID();
+    ours.add(uuid);
+    try {
+      child.stdin.write(JSON.stringify({ type: 'user', uuid, message: { role: 'user', content: stillRunningNote(waiting) }, parent_tool_use_id: null, session_id: '' }) + '\n');
+    } catch { /* the input is gone; `fail` hears it */ }
+  };
   const fail = reason => {
     closed = true;
     for (const request of pending.values()) {
@@ -75,12 +115,20 @@ export function attachClaudeInput(child) {
         }
       }
       if (event.type === 'system' && event.subtype === 'bridge_state') child.emit('bridge-state', event);
-      if (event.type === 'assistant') atResult = false;
+      // A cloud run whose input the sandbox closed at the end of its turn
+      // while this Mac slept (main/cloud/run.mjs): the end of the run, as if
+      // closed here. A reply still waiting is kept for the next run.
+      if (event.type === 'system' && event.subtype === 'agentbox_input_closed_in_cloud' && !closed) closeInput();
+      if (event.type === 'system' && event.subtype === 'init') {
+        inTurn = true;
+        for (const request of pending.values()) request.taken = true;
+      }
+      if (event.type === 'assistant') { atResult = false; inTurn = true; }
       if (event.type === 'user' && !event.parent_tool_use_id && typeof event.uuid === 'string' && !seenUsers.has(event.uuid)) {
         seenUsers.add(event.uuid);
         const content = event.message?.content;
         const text = typeof content === 'string' ? content : Array.isArray(content) ? content.filter(b => b.type === 'text').map(b => b.text).join('\n') : '';
-        if (held && !pending.has(event.uuid) && text && !event.isMeta) child.emit('remote-user', event);
+        if (held && !pending.has(event.uuid) && !ours.has(event.uuid) && text && !event.isMeta) child.emit('remote-user', event);
         if (text) { atResult = false; child.emit('input-turn', event); }
       }
       if (event.type === 'user' && pending.has(event.uuid)) {
@@ -103,7 +151,9 @@ export function attachClaudeInput(child) {
       }
       if (event.type === 'result') {
         atResult = true;
+        inTurn = false;
         if (mayClose()) closeInput();
+        else if (waiting.length) nameWhatIsStillOut();
       }
     }
   });
@@ -130,7 +180,7 @@ export function attachClaudeInput(child) {
   // ONLY WHILE A MESSAGE OF HERS IS WAITING. The cut turn ends in a result,
   // and with nothing pending that result closes the input and ends the run.
   child.interrupt = () => {
-    if (closed || !pending.size) return Promise.resolve({ interrupted: false });
+    if (closed || ![...pending.values()].some(request => !request.taken)) return Promise.resolve({ interrupted: false });
     child.lastInterruptAt = Date.now();
     return child.control({ subtype: 'interrupt' }).then(() => ({ interrupted: true }));
   };
@@ -147,7 +197,7 @@ export function attachClaudeInput(child) {
   child.steer = text => new Promise((resolve, reject) => {
     if (closed || !child.stdin.writable) return reject(turnClosed('The turn has ended. Send the message again to continue it.'));
     const uuid = randomUUID();
-    pending.set(uuid, { resolve, reject });
+    pending.set(uuid, { resolve, reject, taken: !inTurn });
     try {
       child.stdin.write(JSON.stringify({ type: 'user', uuid, message: { role: 'user', content: text }, parent_tool_use_id: null, session_id: '' }) + '\n');
     } catch (error) {