agentbox-app 0.1.6 → 0.1.11

package/main/agent-sessions.mjs

@@ -58,8 +58,12 @@ import path from 'node:path';
  *  the last three days and 9 in the last seven, in two folders she works in.
  *  Three days is a card with tonight's test on it and almost nothing else; the
  *  filters have already done the work that "a few" was standing in for, so the
- *  window can afford to be the generous reading. */
-export const RECENT_DAYS = 7;
+ *  window can afford to be the generous reading.
+ *
+ *  Ten since the launch list (w-db6f5e331e, 2026-10-05): "showing your recently
+ *  active agents over the last 10 days". Codex reads the same number
+ *  (main/codex-threads.mjs), so the two halves of the card agree. */
+export const RECENT_DAYS = 10;
 
 /**
  * How much of a transcript is read to find its first human turn. The first
@@ -67,6 +71,15 @@ export const RECENT_DAYS = 7;
  *  the largest in her store on 2026-08-29 is 13MB, and there are hundreds. */
 const HEAD_BYTES = 96 * 1024;
 
+/**
+ * How far past the head one cut-off first message may be followed
+ *  (w-24edc04548, 2026-10-05). A screenshot pasted into the first message is
+ *  written into that row as base64, so the row outgrows the head: three of her
+ *  ten days' terminal threads opened with rows of 240KB, 294KB and 486KB, were
+ *  cut, lost their name and fell off the card. Eight megabytes is the Codex
+ *  reader's own ceiling (main/codex-threads.mjs) and several screenshots. */
+const FIRST_TURN_BYTES = 8 * 1024 * 1024;
+
 /**
  * A stop on how many transcripts are OPENED, for the same reason the folder
  *  scan in agent-files.mjs has one: opening a card may not turn into a disk
@@ -80,6 +93,10 @@ const HEAD_BYTES = 96 * 1024;
  *  whether tonight's thread survived was down to where its folder sorted. A
  *  cap that can drop the newest thread on the machine is not a safety rail. */
 const MAX_READS = 1200;
+// How long the conversation read may take, in ms (w-ec62ab6b38). The card that
+// uses it says "Looking" meanwhile; three seconds reaches two thirds of her
+// week's 9,073 transcripts and all of a normal Mac's.
+const READ_BUDGET_MS = 3000;
 
 /* ------------------------- WHAT IS NOT HERS TO IMPORT ---------------------- */
 
@@ -106,6 +123,21 @@ export function isScratchFolder(folder, home = os.homedir()) {
     || /^\/var\/folders(\/|$)/.test(p);
 }
 
+/**
+ * THE SAME RULE, READ OFF THE FOLDER CLAUDE CODE FILED THE TRANSCRIPT IN, so
+ *  it can be applied before the file is opened (w-24edc04548, 2026-10-05).
+ *  Claude Code names that folder after the working folder with every other
+ *  character turned into `-`, so `/private/tmp/w-1` is `-private-tmp-w-1`.
+ *  Of her 12,272 transcripts touched in ten days about 12,000 were in temp
+ *  folders, and opening each one only to refuse it spent the card's three
+ *  seconds before it reached her oldest threads. */
+export function isScratchProjectDir(name, home = os.homedir()) {
+  const n = String(name ?? '');
+  const here = path.resolve(String(home ?? '')).replace(/[^a-zA-Z0-9]/g, '-');
+  if (here.length > 1 && (n === here || n.startsWith(`${here}-`))) return false;
+  return /^-(private-)?(tmp|var-folders)(-|$)/.test(n);
+}
+
 /**
  * THE ONES A PERSON STARTED, which is the whole filter.
  *
@@ -171,7 +203,9 @@ export function threadTitle(texts, max = 72) {
 function titleFromOne(text, max) {
   const raw = String(text ?? '').replace(/\r/g, '');
   for (const line of raw.split('\n')) {
-    const t = line.trim();
+    // `[Image #1]` and `[Pasted text #1 +40 lines]` are Claude Code's stand-ins
+    // for what was pasted, not words she typed.
+    const t = line.replace(/\[(?:Image|Pasted text) #\d+[^\]]*\]/g, '').trim();
     if (!t) continue;
     if (NOT_TYPED.some((re) => re.test(t))) return '';
     const clean = t
@@ -209,7 +243,7 @@ export function shortFolder(folder, home = os.homedir()) {
  *  every message row and the first human turn is the first message, so all
  *  three are at the top, and the alternative is reading gigabytes to fill in a
  *  list. Her largest transcript is 13MB and there are hundreds. */
-export function readTranscriptHead(file, bytes = HEAD_BYTES) {
+export function readTranscriptHead(file, bytes = HEAD_BYTES, most = FIRST_TURN_BYTES) {
   let fd = null;
   try {
     fd = fs.openSync(file, 'r');
@@ -218,22 +252,37 @@ export function readTranscriptHead(file, bytes = HEAD_BYTES) {
     const text = buf.slice(0, n).toString('utf8');
     // The last line of a fixed read is usually cut in half. Dropping it costs
     // nothing, because what is wanted is at the top.
-    const lines = text.split('\n').slice(0, -1);
+    const lines = text.split('\n');
+    const cut = lines.pop();
     let cwd = null;
     let entrypoint = null;
     const said = [];
-    for (const line of lines) {
-      if (!line.trim()) continue;
+    const take = (line) => {
       let row;
-      try { row = JSON.parse(line); } catch { continue; }
+      try { row = JSON.parse(line); } catch { return; }
       if (!cwd && typeof row.cwd === 'string' && row.cwd) cwd = row.cwd;
       if (!entrypoint && typeof row.entrypoint === 'string' && row.entrypoint) entrypoint = row.entrypoint;
       if (row.type === 'user' && said.length < 5) {
         const t = messageText(row);
         if (t.trim()) said.push(t);
       }
+    };
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      take(line);
       if (cwd && entrypoint && said.length >= 5) break;
     }
+    // UNLESS THE HALF LINE IS HER FIRST MESSAGE, cut because a screenshot was
+    // pasted into it. Then it is read to its end, once, up to `most`. Only a
+    // cut row that names itself a user message near its start qualifies, and
+    // only when nothing she said was found and the session is not already
+    // known to be the app's own, so the thousands of worker transcripts are
+    // never read past their head.
+    if (!said.length && n === bytes && cut && /"type":"user"/.test(cut.slice(0, 2048))
+      && (!entrypoint || startedByHand(entrypoint))) {
+      const rest = restOfLine(fd, n, most - n);
+      if (rest) take(Buffer.concat([buf.subarray(buf.lastIndexOf(0x0a, n - 1) + 1, n), rest]).toString('utf8'));
+    }
     return { cwd, entrypoint, said };
   } catch {
     return { cwd: null, entrypoint: null, said: [] };
@@ -242,6 +291,25 @@ export function readTranscriptHead(file, bytes = HEAD_BYTES) {
   }
 }
 
+/**
+ * The bytes from `from` up to the next newline, or null if there is none
+ *  within `budget` bytes: a line that long is given up on, not read whole. A
+ *  file that ends without a newline ends the line too. */
+function restOfLine(fd, from, budget) {
+  const parts = [];
+  let at = from;
+  const chunk = Buffer.alloc(256 * 1024);
+  while (at - from < budget) {
+    const n = fs.readSync(fd, chunk, 0, Math.min(chunk.length, budget - (at - from)), at);
+    if (n <= 0) return Buffer.concat(parts);
+    const nl = chunk.subarray(0, n).indexOf(0x0a);
+    if (nl >= 0) { parts.push(Buffer.from(chunk.subarray(0, nl))); return Buffer.concat(parts); }
+    parts.push(Buffer.from(chunk.subarray(0, n)));
+    at += n;
+  }
+  return null;
+}
+
 /**
  * The words out of one transcript row, whichever of the two shapes it is in.
  *  Content is a string on the plain ones and a list of blocks on the rest. */
@@ -278,11 +346,27 @@ function readTerminalThreads({ home, cutoff, max, skipIds = new Set() }) {
     try { when = fs.statSync(file).mtimeMs; } catch { continue; }
     if (when < cutoff) { skipped.old += 1; continue; }
     if (isSubagentPath(file.slice(root.length))) { skipped.subagent += 1; continue; }
+    if (isScratchProjectDir(path.relative(root, file).split(path.sep)[0], home)) { skipped.scratch += 1; continue; }
     recent.push({ file, when });
   }
   recent.sort((a, b) => b.when - a.when);
-  if (recent.length > max) skipped.unread = recent.length - max;
-  for (const { file, when } of recent.slice(0, max)) {
+  // THE CAP COUNTS WHAT IS KEPT, NOT WHAT IS OPENED (w-ec62ab6b38, 2026-09-28).
+  // On a busy machine the last seven days held 9,073 transcripts, the newest
+  // 1,200 were opened, and every one of those was started by agentbox itself,
+  // so a conversation started by hand was never looked at and the import card
+  // said there was nothing, as if the app were not looking in Claude Code at
+  // all. Somebody running dozens of agents fills this folder with ours. So it
+  // opens newest first until it has `max` of the person's own, or until
+  // READ_BUDGET_MS has gone, whichever is first. Reading all 9,073 heads took
+  // 5.0s there.
+  const started = Date.now();
+  let opened = 0;
+  for (const { file, when } of recent) {
+    if (out.length >= max || Date.now() - started > READ_BUDGET_MS) {
+      skipped.unread = recent.length - opened;
+      break;
+    }
+    opened += 1;
     const id = path.basename(file, '.jsonl');
     // THE DESKTOP APP WRITES A THREAD TWICE, once as a transcript here and once
     // as its own record, joined by `cliSessionId`. Measured 2026-08-29 on the

package/main/agent-updates.mjs

@@ -0,0 +1,114 @@
+// Release discovery is read-only. An updater is a dedicated PTY command,
+// started only by the app's Update now action, never by a poll or terminal open.
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import {execFile} from 'node:child_process';
+import {promisify} from 'node:util';
+import {TaskTerminals,terminalEnv} from './task-terminals.mjs';
+const exec=promisify(execFile);
+const valid=v=>typeof v==='string'&&/^\d+\.\d+\.\d+$/.test(v);
+export function newerVersion(installed,latest){
+ if(!valid(installed)||!valid(latest))return false;
+ const a=installed.split('.').map(Number),b=latest.split('.').map(Number);
+ for(let i=0;i<3;i++){if(b[i]!==a[i])return b[i]>a[i];}return false;
+}
+export function updatePlan({engine,bin,real,home=os.homedir(),channel='latest'}){
+ if(!['claude','codex'].includes(engine)||!path.isAbsolute(bin||'')||!real)return null;
+ const name=engine==='claude'?'Claude Code':'Codex';
+ const brew=real.match(/^(\/opt\/homebrew|\/usr\/local)\/Caskroom\/(claude-code(?:@latest)?|codex)\//);
+ if(brew&&((engine==='claude'&&brew[2].startsWith('claude-code'))||(engine==='codex'&&brew[2]==='codex')))
+  return {name,file:`${brew[1]}/bin/brew`,args:['upgrade','--cask',brew[2]],feed:`https://formulae.brew.sh/api/cask/${brew[2]}.json`,format:'brew'};
+ const pkg=engine==='claude'?'@anthropic-ai/claude-code':'@openai/codex';
+ const tail=`/lib/node_modules/${pkg}/`;
+ const at=real.indexOf(tail);
+ if(at>0){const prefix=real.slice(0,at);return {name,file:path.join(prefix,'bin/npm'),args:['install','--global','--prefix',prefix,`${pkg}@${channel}`],env:{PATH:`${prefix}/bin:${process.env.PATH||''}`},feed:`https://registry.npmjs.org/${pkg}/${channel}`,format:'npm'};}
+ if(engine==='claude'&&real.startsWith(path.join(home,'.local/share/claude/versions')+'/'))return {name,file:bin,args:['update'],feed:`https://downloads.claude.ai/claude-code-releases/${channel}`,format:'text'};
+ const standalone=real.match(/^(.*)\/packages\/standalone\/(?:releases|current)\//);
+ if(engine==='codex'&&standalone)return {name,file:'/bin/bash',args:['-o','pipefail','-c','/usr/bin/curl -fsSL --connect-timeout 10 --max-time 60 https://chatgpt.com/codex/install.sh | /bin/sh'],env:{CODEX_HOME:standalone[1],CODEX_INSTALL_DIR:path.dirname(bin)},feed:'https://releases.openai.com/codex/channels/latest',format:'codex'};
+ return null;
+}
+const json=file=>{try{return JSON.parse(fs.readFileSync(file,'utf8'))}catch{return {}}};
+export async function installedAgent(engine,config){
+ const bin=engine==='codex'?config.codexBin:config.claudeBin;
+ if(!bin)throw Error('This agent is not installed.');
+ const home=config.home||os.homedir();
+ const settings=engine==='claude'?json(path.join(process.env.CLAUDE_CONFIG_DIR||path.join(home,'.claude'),'settings.json')):{};
+ const env=terminalEnv();
+ // Version inspection must not itself auto-update anything.
+ const {stdout}=await exec(bin,['--version'],{timeout:8000,maxBuffer:16384,env:{...env,DISABLE_AUTOUPDATER:'1'}});
+ const version=stdout.match(/\b\d+\.\d+\.\d+(?:-[\w.-]+)?\b/)?.[0];
+ const channel=settings.autoUpdatesChannel==='stable'?'stable':'latest';
+ return {engine,bin,real:fs.realpathSync(bin),home,version,channel,disabled:settings.env?.DISABLE_UPDATES==='1'||process.env.DISABLE_UPDATES==='1'};
+}
+export async function latestRelease(plan){
+ const r=await fetch(plan.feed,{signal:AbortSignal.timeout(10000),headers:{Accept:plan.format==='text'?'text/plain':'application/json'}});
+ if(!r.ok)throw Error('Release check failed.');
+ const body=await r.text();if(body.length>2_000_000)throw Error('Release response too large.');
+ const data=plan.format==='text'?null:JSON.parse(body);
+ const version=plan.format==='text'?body.trim():plan.format==='codex'?String(data.version||data.tag_name||'').replace(/^(rust-v|v)/,''):data.version;
+ if(!valid(version))throw Error('Release version could not be read.');return version;
+}
+export class AgentUpdates{
+ constructor({installation,latest=latestRelease,refresh=async()=>{},terminals,now=()=>Date.now()}={}){
+  this.installation=installation;this.latest=latest;this.refresh=refresh;this.now=now;this.entries=new Map();this.checks=new Map();this.starts=new Map();this.finishes=new Map();this.plans=new Map();
+  this.terminals=terminals||new TaskTerminals({sweepMs:0});
+  this.terminals.resolve=engine=>{const p=this.plans.get(engine);if(!p)throw Error('Click Update now first.');return {cwd:p.home,command:{file:p.file,args:p.args,env:p.env},notice:`Updating ${p.name}.`}};
+ }
+ status(engine){return this.entries.get(engine)||{engine,state:'unknown'};}
+ check(engine,force=false){
+  if(!['claude','codex'].includes(engine))return Promise.reject(Error('Unknown agent.'));
+  if(this.starts.has(engine)||this.status(engine).state==='running')return Promise.resolve(this.status(engine));
+  if(this.checks.has(engine))return this.checks.get(engine);
+  const saved=this.status(engine);if(!force&&saved.checkedAt&&this.now()-saved.checkedAt<3600000)return Promise.resolve(saved);
+  const work=(async()=>{let result;try{
+   const install=await this.installation(engine);const plan=install.disabled?null:updatePlan(install);
+   if(!plan)result={engine,state:'unsupported',message:'Update this installation using its own installer.'};
+   else{const latest=await this.latest(plan);result={engine,state:newerVersion(install.version,latest)?'available':'current',installed:install.version,latest};if(!valid(install.version))throw Error('Installed version could not be read.');}
+  }catch{result={engine,state:'unknown',message:'Could not check for updates. Your current models are still available.'};}
+  result.checkedAt=this.now();if(this.starts.has(engine)||this.status(engine).state==='running')return this.status(engine);this.entries.set(engine,result);return result;})().finally(()=>this.checks.delete(engine));
+  this.checks.set(engine,work);return work;
+ }
+ start(engine){
+  if(this.starts.has(engine))return this.starts.get(engine);
+  if(this.status(engine).state==='running')return Promise.resolve(this.status(engine));
+  // Validate again at click time: an installation may have changed since
+  // the picker opened. Never trust a command or a release passed by the UI.
+  const work=(async()=>{
+   const install=await this.installation(engine);const plan=install.disabled?null:updatePlan(install);
+   if(!plan)throw Error('This installation must be updated using its own installer.');
+   const target=await this.latest(plan);
+   if(!valid(install.version))throw Error('Installed version could not be read.');
+   if(!newerVersion(install.version,target)){
+    await this.refresh(engine);const current={engine,state:'current',installed:install.version,latest:target,checkedAt:this.now(),message:'Up to date. Available models refreshed.'};this.entries.set(engine,current);return current;
+   }
+   this.plans.set(engine,{...plan,home:install.home});this.terminals.close(engine);
+   this.terminals.open(engine);
+   const running={engine,state:'running',installed:install.version,latest:target};this.entries.set(engine,running);
+   const finished=this.terminals.get(engine).exitPromise.then(async()=>{
+    try{
+     if(this.terminals.get(engine).exitCode!==0)throw Error('Update did not finish. You can retry.');
+     const after=await this.installation(engine);
+     if(!valid(after.version)||newerVersion(after.version,target))throw Error('The installed version is still older. Check the terminal output before retrying.');
+     await this.refresh(engine);
+     this.entries.set(engine,{engine,state:'current',installed:after.version,latest:target,checkedAt:this.now(),message:'Updated. Available models refreshed.'});
+    }catch(error){this.entries.set(engine,{...running,state:'failed',message:error.message});}
+   });this.finishes.set(engine,finished);return running;
+  })().catch(error=>{this.entries.set(engine,{engine,state:'failed',message:error.message});throw error;}).finally(()=>this.starts.delete(engine));
+  this.starts.set(engine,work);return work;
+ }
+ settled(engine){return this.finishes.get(engine)||Promise.resolve();}
+ terminal(engine,p){
+  // Opening the viewer is never an install action, including after it ended.
+  if(!this.plans.has(engine))throw Error('Click Update now first.');
+  switch(p.action){
+   case 'open':return this.terminals.read(engine,0);
+   case 'read':return this.terminals.read(engine,p.offset);
+   case 'write':return this.terminals.write(engine,p.data);
+   case 'resize':return this.terminals.resize(engine,p.cols,p.rows);
+   case 'close':return this.terminals.close(engine);
+   default:throw Error('Unknown terminal action.');
+  }
+ }
+ shutdown(){return this.terminals.shutdown();}
+}

package/main/agents.mjs

@@ -18,7 +18,7 @@ import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
 import { NAME, Name, WAS } from '../shared/product-name.mjs';
 import {
-  WORK_CHARS, agentKey, changedFile, fullSubject, saidCount, sameInstant, threadWindow, workSubject, workVerb,
+  WORK_CHARS, agentKey, changedFile, commandWork, fullSubject, isBookkeeping, saidCount, sameInstant, threadWindow, workSubject, workVerb,
 } from '../shared/agents.mjs';
 
 const run = promisify(execFile);
@@ -64,7 +64,7 @@ function stillTheSame(rec, proc) {
 }
 
 /* ------------------------------- the sources ----------------------------- */
-// TWO SOURCES, UNIONED, because on 2026-08-16 neither one alone saw her
+// TWO SOURCES, UNIONED, because when measured neither one alone saw the whole
 // machine. `claude agents --json` (the public scripting flag) listed 3 sessions
 // while 16 were live with sockets bound; the per-session state files listed
 // those 16 and none of the 3. They disagree about which sessions they know, and
@@ -125,35 +125,29 @@ function scrubbed(env) {
 // Claude Code already writes three facts into the same transcript this function
 // is already reading, and they were simply being skipped:
 //
-//   ai-title    a one-line title the session wrote for ITSELF. Measured across
-// her 14 outside sessions 2026-08-17: 14 of 14 had one, inside the
-// 96KB tail. session-71's is "Agentbox product not displaying in
-// the app", which is the exact sentence she could not remember.
-// last-prompt the last thing SHE typed into that session. "okay no worries.
-// just make sure that auth persists across sessions…"
+//   ai-title    a one-line title the session wrote for ITSELF. Every session
+//               measured had one inside the 96KB tail, and it is usually the
+//               sentence a person would use to recall the session.
+//   last-prompt the last thing the user typed into that session.
 //   tool_use    the files it has been editing, reading and writing.
 //
 // So the reading is one pass over a tail that was already being read, and the
 // card goes from three lines about a pid to what the work actually is.
 //
-// WHAT WAS MISSING WAS THE BEGINNING. Measured over all 16 of her live sessions
-// on 2026-08-17, reading every human turn in 117MB of transcript:
-//
-// The conversation she needs to recall fits on a card. The agent's side is what
-// is megabytes.
+// WHAT WAS MISSING WAS THE BEGINNING. The human side of a conversation fits on
+// a card. The agent's side is what is megabytes.
 //
 // AND THE TAIL CANNOT SEE IT. The opening turn lands between 11KB and 614KB in
-// (her pasted images are single transcript lines of hundreds of KB), and 96KB
+// (pasted images are single transcript lines of hundreds of KB), and 96KB
 // off the end reaches none of it. Measured: a 1MB head plus a 512KB tail still
-// saw only 72 of her 155 turns — 46% — and one of the two it missed on
-// session-71 was the one she is complaining about.
+// saw only 46% of the human turns.
 //
 // So the whole file is read, ONCE, and then only what has been appended since.
-// Measured on her machine: the first pass over all 15 transcripts, 117MB, costs
-// 353ms in total and never happens again for that session; after it, a refresh
-// reads only the bytes that arrived. This is the same read the tail was already
-// doing, moved from "the last 96KB" to "everything, once" — no model sees any
-// of it, which was her condition.
+// Measured: the first pass over 15 transcripts, 117MB, costs 353ms in total
+// and never happens again for that session; after it, a refresh reads only the
+// bytes that arrived. This is the same read the tail was already doing, moved
+// from "the last 96KB" to "everything, once". No model sees any of it, by
+// design.
 const CHUNK_BYTES = 4 << 20;
 const historyCache = new Map(); // sessionId -> { file, size, mtimeMs, offset, ...facts }
 const dirCache = new Map();    // sessionId -> transcript path
@@ -186,11 +180,11 @@ function transcriptPath(sessionId, cwd) {
 const NOTHING = { lastActiveAt: 0, lastSaid: '', saidAt: 0, saidOpen: false, about: '', lastAsked: '', touched: [], asked: [] };
 
 // HOW MUCH OF THE LAST REPLY IS KEPT. The card quotes the end of it, so this is
-// a bound on the accumulator and not on what she reads. Her longest single
-// reply on this machine is under 6KB.
+// a bound on the accumulator and not on what the user reads. A human reply is
+// rarely anywhere near 6KB.
 const SAID_CHARS = 8000;
 
-// WHAT COUNTS AS SOMETHING SHE TYPED. A Claude Code transcript calls a great
+// WHAT COUNTS AS SOMETHING THE USER TYPED. A Claude Code transcript calls a great
 // many things a `user` message that no human wrote: every tool result comes
 // back as one, every system reminder is one, every slash command expands into
 // one. Reading those onto the card would fill her recall with the machine
@@ -198,7 +192,7 @@ const SAID_CHARS = 8000;
 //
 // So a turn is hers only when it is a `user` line that is not flagged meta, is
 // not a compaction summary, carries no tool result, and whose text does not
-// open with a tag. Checked against all 155 real turns in her 16 sessions.
+// open with a tag. Checked against 155 real human turns.
 //
 // THE CARD AND THE CONVERSATION READ THE SAME LINE DIFFERENTLY, which is why
 // this is two functions and not one. A card quotes a sentence, so it flattens
@@ -210,9 +204,12 @@ const RELAY_MARK = `Relayed from ${NAME},`;
 // WRITTEN UNDER THE CURRENT NAME, RECOGNISED UNDER EVERY NAME THIS APP HAS
 // HAD. A transcript is a file on her disk and it outlives a rename, so a
 // marker matched on the current name alone stops matching the day the name
-// changes, and the app's own preamble starts reading as something she typed.
-const RELAY_MARKERS = [RELAY_MARK, ...WAS.map((was) => `Relayed from ${was},`)];
-const wasRelayed = (line) => RELAY_MARKERS.some((m) => line.startsWith(m));
+// changes, and the app's own preamble starts reading as something the user typed.
+// The letter case is ignored as well: the name was written lowercase until
+// 2026-10-02, and those transcripts say "Relayed from agentbox,".
+const RELAY_MARKERS = [RELAY_MARK, ...WAS.map((was) => `Relayed from ${was},`)].map((m) => m.toLowerCase());
+const wasRelayed = (line) => RELAY_MARKERS.some((m) => line.toLowerCase().startsWith(m));
+export { wasRelayed as __wasRelayed };
 
 function herTurnRaw(obj) {
   if (obj.type !== 'user' || obj.isMeta || obj.isCompactSummary || obj.toolUseResult) return '';
@@ -225,10 +222,10 @@ function herTurnRaw(obj) {
   const clean = String(text).trim();
   const flat = clean.replace(/\s+/g, ' ');
   // AND NEVER AGENTBOX'S OWN PREAMBLE. `fromTheApp` puts a sentence of context in
-  // front of what she typed, and today Claude Code stamps the result `isMeta`
+  // front of what the user typed, and today Claude Code stamps the result `isMeta`
   // so this never sees it. If a future one records it as a plain user turn
-  // instead, the card would quote Agentbox talking to an agent back at her as her
-  // own words. `spoke` already holds what she actually typed.
+  // instead, the card would quote Agentbox talking to an agent back at the user
+  // as their own words. `spoke` already holds what the user actually typed.
   if (!flat || flat.startsWith('<') || flat.startsWith('[Request interrupted') || wasRelayed(flat)) return '';
   return clean;
 }
@@ -431,7 +428,7 @@ function fingerprint(agents) {
   // a tick and pushing on it re-renders her window for nothing. The first moves
   // only when the session's status moves, and since a row's LIST depends on it:
   // a session that went busy and back to idle between two readings shows the
-  // same `status` both times, and without this the row she replied to would sit
+  // same `status` both times, and without this the row the user replied to would sit
   // in In progress until some other push happened to come. AND WHEN IT LAST
   // SAID SOMETHING, which is the fact this list existed to notice and did
   // not.An agent that answers her while she is looking at its card moves
@@ -591,12 +588,12 @@ function defaultSocket(pid) {
 // Nothing here claims her authority.
 //
 // What it does say is the part the wrapper cannot: WHERE the message came from
-// and WHAT it is about. MEASURED on session-46, which is the session in her
-// screenshot. There was no response to see, and one sentence of context is the
-// whole of the difference.
+// and WHAT it is about. MEASURED on a session that had given no response
+// without it; one sentence of context is the whole of the difference.
 //
-// HER OWN TEXT IS UNCHANGED AND IS WHAT THE CARD QUOTES: `spoke` records what
-// she typed, never this, so nothing she never wrote is ever drawn as her words.
+// THE USER'S OWN TEXT IS UNCHANGED AND IS WHAT THE CARD QUOTES: `spoke` records
+// what the user typed, never this, so nothing the user never wrote is ever drawn
+// as their words.
 export function fromTheApp(message) {
   return [
     `${RELAY_MARK} the inbox your user reads. A person typed this, not an agent,`,
@@ -622,7 +619,7 @@ export async function reply(pid, text, { timeoutMs = 3000 } = {}) {
   const before = await watermark(agent);
   try {
     // What goes on the wire says who is asking; what is matched and recorded
-    // below stays HER words, so `heldNotice` cannot start matching every
+    // below stays the user's words, so `heldNotice` cannot start matching every
     // message by its shared opening and the card cannot quote a preamble.
     await writeToSocket(agent.socket, fromTheApp(message), tokenFor(pid));
   } catch (err) {
@@ -787,7 +784,7 @@ function heldNotice(agent, sinceSize, message) {
     const content = String(obj?.content ?? '');
     if (!HOLD_LINE.test(content)) continue;
     if (opening && !content.includes(opening.slice(0, 40))) continue;
-    // Said in her words, not the CLI's. What she can DO about it is the point:
+    // Said in plain words, not the CLI's. What the user can DO about it is the point:
     // the message is sitting in that session's own window waiting for a yes.
     return `${agent.name} held your message for approval in its own window, so it has not read it yet.`;
   }
@@ -846,8 +843,8 @@ export function reveal(pid) {
 // the one surface built to make her trust the app. readline hands the lines
 // back a chunk at a time and the app draws in between.
 //
-// NO MODEL SEES ANY OF IT, which was her condition on the whole feature, and
-// nothing is written anywhere: this opens a file she already has and reads it.
+// NO MODEL SEES ANY OF IT, which is a condition of the whole feature, and
+// nothing is written anywhere: this opens a file the user already has and reads it.
 
 // One turn is capped here rather than where it is drawn, so a pasted 600KB
 // blob never becomes 600KB of React. It is far more than anybody reads and far
@@ -894,7 +891,13 @@ function workedOn(obj, events, byId, dir = '') {
   const at = Date.parse(obj.timestamp ?? 0) || 0;
   for (const c of obj.message.content) {
     if (c.type !== 'tool_use') continue;
-    const subject = workSubject(c.input, dir, os.homedir());
+    // The store's own records are how a session talks to the app, not work it
+    // did, and a thread that opens on them reads as noise (w-0bd0d8b2ef).
+    if (isBookkeeping(c.name)) continue;
+    // WHAT A COMMAND DID, IN WORDS, when the whole of it is recognised; null on
+    // anything else, and the line is then the command it always was.
+    const plain = c.name === 'Bash' ? commandWork(c.input?.command, dir, os.homedir()) : null;
+    const subject = plain ? plain.subject : workSubject(c.input, dir, os.homedir());
     const whole = fullSubject(c.input);
     // THE FILE IT CHANGED, WHOLE, so the thread can offer it as a chip into the
     // code. Empty on everything that did not write a file, which is most calls:
@@ -903,10 +906,13 @@ function workedOn(obj, events, byId, dir = '') {
     const event = {
       kind: 'work',
       at,
-      verb: workVerb(c.name),
+      verb: plain ? plain.verb : workVerb(c.name),
       subject,
       ...(changed ? { file: changed } : {}),
-      full: whole && whole.replace(/\s+/g, ' ').trim() !== subject ? cappedHead(whole) : '',
+      // A line put in words always carries the command, even when the words name
+      // nothing ("Checked what changed"): the words replaced the only copy of it
+      // on the screen, so it has to stay one press behind them.
+      full: plain || (whole && whole.replace(/\s+/g, ' ').trim() !== subject) ? cappedHead(whole) : '',
       output: '',
       lines: 0,
       failed: false,
@@ -1057,11 +1063,11 @@ export async function conversation({ pid, sessionId, cwd, spoke = [], whole = fa
       const its = saidByIt(obj);
       if (its) addTurn(turns, 'it', its, at);
       // THE WORK GOES IN THE THREAD, IN THE ORDER IT HAPPENED, and it ends the
-      // message above it. Her shape says each thing it ran sits BETWEEN the
+      // message above it. The chosen shape says each thing it ran sits BETWEEN the
       // messages, so a reply that stopped twice for a tool is three things on
       // the screen in the order they occurred rather than one bubble with the
       // work swept behind it. This is the one place the fold is deliberately
-      // broken, and breaking it is the shape she picked.
+      // broken, and breaking it is the shape that was chosen.
       workedOn(obj, turns, byId, dir);
     }
   } catch {

package/main/analytics.mjs

@@ -204,3 +204,30 @@ export function createAnalytics({ config, version, dir, client, env = process.en
     async shutdown() { try { await posthog?.shutdown?.(); } catch {} },
   };
 }
+
+// "USED TODAY", ONCE PER CALENDAR DAY (2026-10-06). Retention is read from
+// whether an install was used on a day, and `app_opened` cannot say that: a Mac
+// app left open for a week sends it once. This is touched at launch and every
+// time the window comes forward, and sends only on the first touch of each
+// local day. Kept in memory: a relaunch on the same day may send it again,
+// which PostHog's per-install, per-day counting absorbs.
+export function createDailyCount(track) {
+  let last = null;
+  return (now) => {
+    const d = new Date(now);
+    const day = `${d.getFullYear()}-${d.getMonth()}-${d.getDate()}`;
+    if (day === last) return;
+    last = day;
+    track('day_active');
+  };
+}
+
+// WHAT AN AGENT'S RUN REPORTS WHEN IT ENDS: how long, whether it failed, and
+// which engine. Nothing about the task it was on.
+export function runEndedProps(session, now) {
+  return {
+    seconds: Math.round((now - (session.startedAt ?? now)) / 1000),
+    failed: !!session.exitFailed,
+    engine: session.engine,
+  };
+}

package/main/approval-prompt-server.mjs

@@ -26,7 +26,7 @@ import { answerIsHers, appendSpoolLine, cardDigest, readSpoolJson, removeSpoolEn
 
 const SPOOL = process.env.ZERO_APPROVALS_DIR;
 
-// THE KEY THAT SAYS AN ANSWER IS HERS, AND IT IS SAFE TO HAND US.
+// THE KEY THAT SAYS AN ANSWER IS THE USER'S, AND IT IS SAFE TO HAND US.
 //
 // This process is the worker's own child, so its environment is the worker's to
 // read and anything secret given here is a secret the forger has. This is the
@@ -93,7 +93,7 @@ async function decide(args) {
         // against the command THIS PROCESS is still holding. `request` here is
         // that memory: it was built from the tool call and has never been read
         // back off the disk, so comparing it against the digest she signed is
-        // the whole check. A mismatch is a deny -- she said yes to something
+        // the whole check. A mismatch is a deny -- the user said yes to something
         // else -- and it is loud, because only a rewrite can produce it.
         const mine = cardDigest(request);
         if (!mine || answer.card !== mine) {

package/main/artifact-path.mjs

@@ -125,6 +125,17 @@ export function resolveArtifact({ src, product, products = [], accountRoot, stor
     }
   } else {
     for (const root of roots) candidates.push(path.join(root, raw));
+    // AND THE WORKER'S OWN CHECKOUT, when the path names its task. Every run
+    // works in `<repo>/.claude/worktrees/<task id>` (./task-folders.mjs), so
+    // `designs/w-1b574413db/a1.png` is relative to that folder, and the hunt
+    // below never finds it because it skips every folder starting with a dot.
+    // Only a task the path itself names: a bare `shots/a.png` must not reach
+    // into some other task's checkout (2026-10-04, w-7fe215448b).
+    if (own?.repoPath) {
+      for (const segment of raw.split('/')) {
+        if (/^w-[0-9a-f]{6,}$/i.test(segment)) candidates.push(path.join(own.repoPath, '.claude', 'worktrees', segment, raw));
+      }
+    }
   }
 
   for (const full of candidates) {