agentbox-app 0.1.7 → 0.1.12

package/main/task-commands.mjs

@@ -26,10 +26,10 @@ const exec = promisify(execFile);
  * a chat of its own, that takes over and nothing forks twice.
  */
 /**
- * A row name out of the sentence she typed after `/fork`: her first sentence,
+ * A row name out of the sentence typed after `/fork`: its first sentence,
  * or the first sixty characters of it, so the inbox line says which fork this
  * is rather than which row it came from. Whitespace flattened because a title
- * is one line and she can paste a paragraph.
+ * is one line and a paragraph can be pasted.
  */
 export function forkTitle(words, cap = 60) {
   const flat = String(words ?? '').replace(/\s+/g, ' ').trim();
@@ -45,18 +45,16 @@ function forkTask(sup, productSlug, id, item, engine, op, publish) {
   }
   // NAMING THE KEY, because the menu closes at the space and plain return then
   // writes a newline, the way it does on every other reply here. Without that
-  // sentence she types the words, presses return, and is back to a key that
-  // does nothing (hers, 2026-09-23: "Fork does nothing when I type /fork then
-  // hit return").
+  // sentence the user types the words, presses return, and is back to a key
+  // that does nothing, so a bare /fork looks as if it did nothing.
   if (!op.args) return publish('failed', 'Say what the fork should try, as in /fork try it without the modal, then press command and return.', op.name);
   const chat = sup.rowSessionFor(item, sup.store.listProducts().find((p) => p.slug === productSlug));
   if (!chat?.sessionId) return publish('failed', 'This task has no saved conversation to fork yet. Send a message first.', op.name);
   const made = sup.store.composeItem(productSlug, {
-    // THE FORK IS NAMED AFTER WHAT SHE ASKED IT TO TRY, not after the row it
-    // came from. Naming it `<parent title> · fork` put two rows in her inbox
-    // whose names differ by one word at the end, and the first thing she said
-    // after using it was that she could not tell which agent she was talking to
-    // (2026-09-23). The instruction is the only thing that distinguishes them,
+    // THE FORK IS NAMED AFTER WHAT IT WAS ASKED TO TRY, not after the row it
+    // came from. Naming it `<parent title> · fork` put two rows in the inbox
+    // whose names differ by one word at the end, so there was no telling which
+    // agent was which. The instruction is the only thing that distinguishes them,
     // so it is what the row is called; the parent is still on the row as the
     // `fork:` label, which is where the machinery reads it anyway.
     title: forkTitle(op.args),

package/main/task-folders.mjs

@@ -1,8 +1,7 @@
 // ONE FOLDER PER TASK, OWNED BY THE APP RATHER THAN BY THE AGENT IN IT.
 //
-// the founder, 2026-09-22, choosing between letting Claude Code make its own
-// worktree and doing it ourselves: "the app makes the folder for both agents".
-// The two engines are not equal here. Claude Code has isolation built in
+// Between letting Claude Code make its own worktree and doing it ourselves, the
+// app makes the folder for both agents. The two engines are not equal here. Claude Code has isolation built in
 // (`--worktree`), makes the folder under `.claude/worktrees/`, locks it, reuses
 // it by name and deletes it when it leaves nothing behind. Codex has none of
 // that, only `--cd` for choosing where to work. So the rules have to live on
@@ -11,7 +10,7 @@
 // exactly where Claude Code would, so a person who opens the repository in a
 // terminal sees the layout they already know.
 //
-// WHAT WAS MEASURED, ON HER MAC, 2026-09-22. This repository had 25 leftover
+// WHAT WAS MEASURED, 2026-09-22. This repository had 25 leftover
 // agent copies holding 26 GB: twelve with edits committed nowhere, twelve on
 // branches never merged, one safe to delete. Isolation was a rule in the worker
 // brief; the rule's first half (make a copy) was kept and its second half (fold
@@ -51,6 +50,9 @@ const BRANCH_PREFIX = `${nameSlug}/`;
 /** Ids are `w-` plus hex today. This is the guard for the day they are not. */
 const SAFE_NAME = /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/;
 
+/** What an unfinished folder is called. A task name may never start with a dot. */
+const BUILDING = '.building-';
+
 const git = (cwd, args) => execFileSync('git', args, {
   cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'],
 }).trim();
@@ -81,6 +83,32 @@ export function taskFolderPath(repoPath, id) {
   return path.join(real(repoPath), ...WORKTREES, safeTaskName(id));
 }
 
+/**
+ * WHERE A FOLDER IS BUILT, WHICH IS NEVER WHERE IT IS RUN IN.
+ *
+ * Making one is a worktree plus a block clone of the checkout. It used to be
+ * built AT the path a session runs in, so for the whole of that a directory sat
+ * there, registered with git and holding almost none of the code. MEASURED on
+ * astral-video, the repository this happened in, 2026-10-01: the build takes 115
+ * seconds now that the checkout is 14 GB, and the path a session runs in
+ * appeared 2.7 seconds in. That is 112 seconds of a folder that looked ready and
+ * was not, against a supervisor tick of fifteen seconds, so seven ticks could
+ * read it. Everything that asks whether a row's folder is ready asks the disk,
+ * which means for those 112 seconds every one of them said yes:
+ * the supervisor started a session in a half written folder, and when the build
+ * finished it started a second session on the same row (2026-09-30,
+ * w-4d722ecf92, where the second one's claim came back refused and the first
+ * one's folder was deleted under it a minute in).
+ *
+ * Built here and MOVED into place once it is finished and checked, so a
+ * directory at the real path means a folder that is complete. That makes every
+ * existing question correct without any of them learning a new one, and it
+ * leaves the rollback below nothing to delete but its own unfinished copy.
+ */
+export function buildingFolderPath(repoPath, id) {
+  return path.join(real(repoPath), ...WORKTREES, `${BUILDING}${safeTaskName(id)}`);
+}
+
 export function taskBranch(id) { return `${BRANCH_PREFIX}${safeTaskName(id)}`; }
 
 /** The repository root, or null when this is not a checkout at all. */
@@ -156,20 +184,52 @@ export function ensureTaskFolder(dir, id, { pid = process.pid, dependencies = tr
 
   hideFromTheCheckout(root);
 
+  // EVERY STEP BELOW HAPPENS SOMEWHERE ELSE, and the folder appears at its own
+  // path in one move at the end. `buildingFolderPath` is why. A build the app
+  // died in the middle of leaves an unfinished copy there, which nobody wants
+  // and which would refuse the next attempt, so it goes first.
+  const staging = buildingFolderPath(root, name);
+  clearUnfinished(root, staging);
+
   const branchExists = tryGit(root, ['rev-parse', '--verify', '-q', `refs/heads/${branch}`]).ok;
   const from = branchExists ? branch : baseRef(root);
-  if (!cloneCheckout(root, folder, branch, from, branchExists)) {
-    const add = branchExists
-      ? tryGit(root, ['worktree', 'add', folder, branch])
-      : tryGit(root, ['worktree', 'add', '-b', branch, folder, baseRef(root)]);
+  if (!cloneCheckout(root, staging, branch, from, branchExists)) {
+    // The fast path may have created the branch and then failed the copy.
+    // The branch stays: this file never deletes one. The slow path uses it
+    // when it is already there, which is what `worktree add -b` would refuse.
+    const existsNow = tryGit(root, ['rev-parse', '--verify', '-q', `refs/heads/${branch}`]).ok;
+    const add = existsNow
+      ? tryGit(root, ['worktree', 'add', staging, branch])
+      : tryGit(root, ['worktree', 'add', '-b', branch, staging, baseRef(root)]);
     if (!add.ok) throw Error(`Could not make a folder for ${name}: ${add.out}`);
-    if (dependencies) cloneDependencies(root, folder);
+    if (dependencies) cloneDependencies(root, staging);
+  }
+
+  // `worktree move` rather than a rename, so git's own record of where this
+  // worktree lives moves with it. It refuses if anything is already at the
+  // destination, which is the last guard against walking over a live folder.
+  const moved = tryGit(root, ['worktree', 'move', staging, folder]);
+  if (!moved.ok) {
+    clearUnfinished(root, staging);
+    throw Error(`Could not make a folder for ${name}: ${moved.out}`);
   }
 
   lock(root, folder, pid);
   return { path: folder, branch, created: true };
 }
 
+/**
+ * Throw away an unfinished copy. Nothing is ever lost here: a staging folder
+ * has never been handed to anybody, so the most it can hold is a checkout that
+ * did not finish. The branch is left alone, as everywhere else in this file.
+ */
+function clearUnfinished(root, staging) {
+  if (!fs.existsSync(staging) && !record(root, staging)) return;
+  tryGit(root, ['worktree', 'remove', '--force', staging]);
+  try { fs.rmSync(staging, { recursive: true, force: true }); } catch { /* already gone */ }
+  tryGit(root, ['worktree', 'prune']);
+}
+
 /**
  * MAKING THE FOLDER WITHOUT PAYING FOR IT TWICE.
  *
@@ -188,7 +248,20 @@ export function ensureTaskFolder(dir, id, { pid = process.pid, dependencies = tr
  * commit, down to an empty `git status`, the folder is thrown away and the
  * ordinary checkout runs. A fast folder that is subtly not the code would be
  * far worse than a slow one.
+ *
+ * THE COPY IS THE PLATFORM'S OWN CLONE. macOS `cp -c` is APFS clonefile.
+ * GNU `cp -a --reflink=auto` shares blocks where the filesystem can and
+ * copies where it cannot. `-c` is not an option there, and a copy that
+ * failed used to leave the branch the fast path had just created, so the
+ * ordinary checkout then died with "a branch named … already exists".
  */
+function copyTree(from, to) {
+  const args = process.platform === 'darwin'
+    ? ['-c', '-R', from, to]
+    : ['-a', '--reflink=auto', from, to];
+  execFileSync('cp', args, { stdio: ['ignore', 'ignore', 'pipe'] });
+}
+
 function cloneCheckout(root, folder, branch, from, branchExists) {
   // TRACKED CONTENT ONLY, on both sides of this. Her checkout permanently
   // carries a couple of untracked files (a scratch `:memory:.ses`, a folder of
@@ -210,17 +283,19 @@ function cloneCheckout(root, folder, branch, from, branchExists) {
   try {
     for (const entry of fs.readdirSync(root)) {
       if (entry === '.git' || entry === WORKTREES[0]) continue;
-      execFileSync('cp', ['-c', '-R', path.join(root, entry), folder], { stdio: ['ignore', 'ignore', 'pipe'] });
+      copyTree(path.join(root, entry), folder);
     }
     if (!tryGit(folder, ['reset', '-q', 'HEAD']).ok) throw Error('the index would not fill in');
     const after = tryGit(folder, ['status', '--porcelain', '--untracked-files=no']);
     if (!after.ok || after.out.length > 0) throw Error('the clone did not match the commit');
     return true;
   } catch {
-    // Back to nothing, so the ordinary path starts from a clean sheet.
-    tryGit(root, ['worktree', 'remove', '--force', folder]);
-    try { fs.rmSync(folder, { recursive: true, force: true }); } catch { /* already gone */ }
-    tryGit(root, ['worktree', 'prune']);
+    // Back to nothing, so the ordinary path starts from a clean sheet. What is
+    // thrown away here is the UNFINISHED COPY and never a folder anybody is in:
+    // `folder` is the staging path, which no session has ever been given. It
+    // used to be the real one, and a `remove --force` of that is how a running
+    // agent lost the ground under it.
+    clearUnfinished(root, folder);
     return false;
   }
 }
@@ -257,7 +332,7 @@ function cloneDependencies(root, folder) {
   const to = path.join(folder, 'node_modules');
   if (!fs.existsSync(from) || fs.existsSync(to)) return false;
   try {
-    execFileSync('cp', ['-c', '-R', from, to], { stdio: ['ignore', 'ignore', 'pipe'] });
+    copyTree(from, to);
     return true;
   } catch {
     try { fs.rmSync(to, { recursive: true, force: true }); } catch { /* nothing to undo */ }
@@ -390,7 +465,10 @@ export function listTaskFolders(dir) {
   if (!root) return [];
   const home = path.join(root, ...WORKTREES);
   return registered(root)
-    .filter((w) => path.dirname(w.path) === home && !w.prunable)
+    // A folder still being built is not one of hers: it has no row standing in
+    // it and nothing in it is wanted, so it may never be listed, shown or swept.
+    .filter((w) => path.dirname(w.path) === home && !w.prunable
+      && !path.basename(w.path).startsWith(BUILDING))
     .map((w) => {
       const { dirty, merged } = folderState(root, w.path);
       let touchedAt = null;

package/main/task-remote-control.mjs

@@ -18,9 +18,9 @@ export async function taskRemoteControl(sup,product,id,action='status') {
  if(sup._engineFor(item)==='codex')throw Error('Remote Control is currently available for Claude Code conversations only.');
  if(action==='dismiss')return current()?.state==='failed'&&!current()?.mayBeActive?publish('off'):current();
  if(current()?.state==='connecting'||current()?.state==='disconnecting')return current();
- // Typing the command IS the decision, so it never stops at a card asking again.
- // Her words, w-79bffd7ec3: "should trigger it to turn on or off, depending on
- // its current state, without multiple confirmations."
+ // Typing the command IS the decision, so it never stops at a card asking again
+ // (w-79bffd7ec3): it turns remote control on or off depending on its current
+ // state, with no further confirmation.
  if(action==='toggle')action=['connected','ready','reconnecting'].includes(current()?.state)||current()?.mayBeActive?'disable':'enable';
  if(action==='enable'&&['connected','ready','reconnecting'].includes(current()?.state))return current();
  let session=sup.sessions.get(id);

package/main/task-terminals.mjs

@@ -32,6 +32,17 @@ export function terminalPlace({store,supervisor,product,id,agent}){
   return {cwd,notice};
 }
 export function terminalFolder(args){return terminalPlace(args).cwd;}
+// The shell a person actually has. `$SHELL` when that file exists, then
+// zsh, bash, and sh. A machine with no zsh used to spawn `/bin/zsh` and
+// the terminal never came up.
+export function loginShell(env=process.env,exists=fs.existsSync){
+  const preferred=env.SHELL;
+  if(preferred&&exists(preferred))return preferred;
+  for(const candidate of ['/bin/zsh','/bin/bash','/bin/sh']){
+    if(exists(candidate))return candidate;
+  }
+  return preferred||'/bin/sh';
+}
 // Enumerate only descendants of our own shell, including background process
 // groups. Kill children before shell; closing a pane never calls this.
 export function disposeTerminalProcess(pty){
@@ -69,7 +80,7 @@ const IDLE_MS=600000;
 const SWEEP_MS=60000;
 const MAX_TERMINALS=20;
 export class TaskTerminals {
-  constructor({spawn,resolve,disposeProcess=disposeTerminalProcess,env=terminalEnv(),shell=process.env.SHELL||'/bin/zsh',idleMs=IDLE_MS,sweepMs=SWEEP_MS,now=()=>Date.now()}={}){
+  constructor({spawn,resolve,disposeProcess=disposeTerminalProcess,env=terminalEnv(),shell=loginShell(),idleMs=IDLE_MS,sweepMs=SWEEP_MS,now=()=>Date.now()}={}){
     this.spawn=spawn??((...args)=>require('node-pty').spawn(...args));this.resolve=resolve;this.disposeProcess=disposeProcess;this.env=env;this.shell=shell;this.sessions=new Map();
     this.idleMs=idleMs;this.now=now;
     // Keys whose shell this class ended on its own, and WHY. The next open on
@@ -133,7 +144,8 @@ export class TaskTerminals {
     }
     const place=this.resolve(key);
     const cwd=typeof place==='string'?place:place.cwd;
-    const pty=this.spawn(this.shell,['-l'],{cwd,env:this.env,cols:80,rows:24,name:'xterm-256color'});
+    const command=place?.command;
+    const pty=this.spawn(command?.file??this.shell,command?.args??['-l'],{cwd,env:{...this.env,...command?.env},cols:80,rows:24,name:'xterm-256color'});
     let resolveExit;const exitPromise=new Promise(resolve=>{resolveExit=resolve;});
     const session={token:randomUUID(),pty,cwd,buffer:'',offset:0,exitCode:null,exited:false,exitPromise,lastReadAt:this.now()};this.sessions.set(key,session);
     /*