agentbox-app 0.1.12 → 0.1.16

package/main/agent-sessions.mjs

@@ -1,120 +1,60 @@
-// HER CLAUDE CODE THREADS, WHICH ARE THE AGENTS SHE MEANT.
+// Claude Code conversation threads for the import card. These are separate from
+// the `.md` agent definitions that agent-files.mjs reads, and the card shows both.
 //
-// That sentence retires the assumption `agent-files.mjs` was built on. That
-// module reads `.md` agent DEFINITIONS, which is a real thing Claude Code has
-// and is not what she is looking at when she says "my agents". the four
-// definition files on this Mac were last edited on 23 and 30 March, and she had
-// four threads going the evening she complained.
+// A thread lives in one of two places:
 //
-// So the import gets a second source, and this is it. Nothing here replaces the
-// files; a definition and a thread are different objects and the card shows
-// both.
+//   <claude data folder>/projects/<folder>/<id>.jsonl   a terminal or editor
+//       session, one JSON object per line (data folders: main/agent-homes.mjs)
+//   ~/Library/Application Support/Claude/claude-code-sessions/**/local_<id>.json
+//       the desktop app's small record about a session, with a real `title`
 //
-// WHERE A THREAD LIVES. Two places, because she named two:
-//
-//   ~/.claude/projects/<folder>/<id>.jsonl     every terminal session
-//   ~/Library/Application Support/Claude/
-//     claude-code-sessions/**/local_<id>.json  the desktop app
-//
-// The terminal store is the transcript itself, one JSON object per line. The
-// desktop store is a small record ABOUT the session, and it is the richer of
-// the two because the app writes a real `title` into it. Measured 2026-08-29:
-// 2,444 transcripts in 240 folders, and 38 desktop records whose newest is
-// 7 July, so on her Mac today the terminal side is all of it.
-//
-// THE HARD PART IS NOT FINDING THEM, IT IS THROWING THEM AWAY. hundreds exist
-// and a handful are relevant.
-//
-// The line that separates them is not a heuristic, which is the good news. Every
-// transcript row carries an `entrypoint`, and it says who started the session.
-// Counted over all 2,212 transcripts in her store on 2026-08-29:
-//
-//   2,158  sdk-cli         something started it: Agentbox's own workers, Agentbox's
-//                          chats, and our measurement scripts running twenty
-//                          agents at a time in temp folders
-//      53  cli             she opened a terminal and typed
-//       1  claude-desktop  she used the desktop app
-//
-// So 54 of 2,212 were started by a person, and those 54 are the handful she
-// means. Her own test is one of them: `~/Desktop/dev/zero`, 8:38 PM, "this is a
-// test", `entrypoint: "cli"`.
-//
-// A FIRST DRAFT OF THIS GUESSED INSTEAD, and the guess is worth keeping written
-// down because it looked like it worked. It dropped anything opening with the
-// work item brief and anything running in a temp folder, which on that evening
-// removed 126 and 171 rows and left a believable list. It would have kept every
-// chat Agentbox itself runs in a product folder, because those open with her own
-// question and run somewhere real. `entrypoint` was on the row the whole time.
+// Most transcripts on a machine running Agentbox were started by Agentbox. The
+// `entrypoint` on every transcript row says who started the session, so the
+// filter reads that rather than guessing from the prompt or the folder.
 
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
+import { claudeDataDirs } from './agent-homes.mjs';
+import { howTheChatEnded } from '../shared/agent-import.mjs';
 
-/**
- * "Recent = last few days", in days.
- *
- *  Seven rather than three, and the number is measured rather than chosen.
- *  Counting only the threads a person started, her Mac on 2026-08-29 has 2 in
- *  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.
- *
- *  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
+/** How many days back counts as recent. 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
- *  turn is at the top of the file by construction, and the files are not small:
- *  the largest in her store on 2026-08-29 is 13MB, and there are hundreds. */
+/** How much of a transcript is read to find its first human turn, which is at
+ *  the top of the file. Transcripts run to many megabytes. */
 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. */
+/** How far past the head one cut-off first message may be followed. A
+ *  screenshot pasted into the first message is written into that row as
+ *  base64, so the row can be hundreds of KB. Eight MB matches the Codex
+ *  reader's ceiling (main/codex-threads.mjs). */
 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
- *  crawl.
- *
- *  It is a cap on reading, never on looking. The walk stats every file, which
- *  is cheap, throws away everything older than the cutoff, and sorts what is
- *  left newest first before it opens anything. An earlier draft capped the walk
- *  itself and the bug is worth keeping written down: the cap was reached in
- *  directory order, so on her Mac it stopped after 1,500 of 2,444 files and
- *  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. */
+/** How much of a transcript's end is read for its title and last reply. */
+const TAIL_BYTES = 256 * 1024;
+/** The longest last reply kept, from its end, which is where the answer is. */
+const SAID_CHARS = 8000;
+/** The longest first prompt kept for an imported row's opening message. */
+const FIRST_CHARS = 4000;
+
+/** A cap on how many threads are kept, so opening the card is not a disk
+ *  crawl. It caps reading, never looking: the terminal walk stats every file
+ *  and sorts newest first before it opens any, so the cap only drops older
+ *  threads. */
 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.
+// The card shows "Looking" while this runs.
 const READ_BUDGET_MS = 3000;
 
-/* ------------------------- WHAT IS NOT HERS TO IMPORT ---------------------- */
-
-/**
- * A FOLDER NOBODY WORKS IN.
- *
- *  `/private/var/folders/19/.../T/speedsize-6AGMVw-run-12` is a real cwd of a
- *  real Claude Code session, and it is one of twenty a measurement script of
- *  ours started in a loop. 258 of her 448 recent threads are that. Nobody opens
- *  a temp directory to work, so a thread that ran in one is not a thread she
- *  would recognise, and offering it is how a list of hundreds happens. */
+/** A temp folder, where nobody works. Agentbox's own scripts and workers run
+ *  Claude Code sessions there, so a thread from one is not the person's. */
 export function isScratchFolder(folder, home = os.homedir()) {
   const p = String(folder ?? '');
   if (!p) return true;
-  // A FOLDER INSIDE YOUR OWN HOME IS YOURS, whatever the disk path says. This
-  // is the rule the temp-path list is a proxy for, and it has to be stated
-  // first, because a Mac can put a home directory anywhere and the tests put
-  // one under `/var/folders` on purpose.
+  // A folder inside the home folder is the person's, whatever the path. This
+  // check comes first because a Mac can put a home folder anywhere, and the
+  // tests put one under `/var/folders`.
   const here = path.resolve(String(home ?? ''));
   if (here && (p === here || p.startsWith(`${here}/`))) return false;
   return /^\/private\/tmp(\/|$)/.test(p)
@@ -123,14 +63,10 @@ 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. */
+/** The same rule read off the folder Claude Code filed the transcript in, so
+ *  a temp-folder transcript is refused without being opened. Claude Code names
+ *  that folder after the working folder with every character that is not a
+ *  letter or digit turned into `-`, so `/private/tmp/w-1` is `-private-tmp-w-1`. */
 export function isScratchProjectDir(name, home = os.homedir()) {
   const n = String(name ?? '');
   const here = path.resolve(String(home ?? '')).replace(/[^a-zA-Z0-9]/g, '-');
@@ -138,60 +74,42 @@ export function isScratchProjectDir(name, home = os.homedir()) {
   return /^-(private-)?(tmp|var-folders)(-|$)/.test(n);
 }
 
-/**
- * THE ONES A PERSON STARTED, which is the whole filter.
- *
- *  `cli` is a terminal she opened. `claude-desktop` is the desktop app, which
- *  she named. Everything else was started by software, and on this Mac that is
- *  overwhelmingly Agentbox itself: its workers, its chats, and the scripts we run
- *  to measure it. Offering those on an import card would be offering to bring
- *  the inbox into the inbox.
- *
- *  An entrypoint we have never seen is treated as not hers. The cost of being
- *  wrong that way is one missing row on a card; the other way is the hundreds
- *  she is complaining about. */
+/** Entrypoints a person starts. `cli` is a terminal, `claude-desktop` the
+ *  desktop app, and `claude-vscode` the Claude Code extension in VS Code,
+ *  Cursor and Windsurf. Everything else, mostly `sdk-cli`, was started by
+ *  software, usually Agentbox's own workers and chats. An unknown entrypoint
+ *  counts as not the person's: a missing row costs less than hundreds of
+ *  wrong ones. `remote*` sessions run in the cloud, not on this disk. */
+const BY_HAND = new Set(['cli', 'claude-desktop', 'claude-vscode']);
 export function startedByHand(entrypoint) {
-  return entrypoint === 'cli' || entrypoint === 'claude-desktop';
+  return BY_HAND.has(entrypoint);
+}
+
+/** Which of the three places a person starts Claude Code a session came from. */
+export function sourceOf(entrypoint) {
+  if (entrypoint === 'claude-desktop') return 'desktop';
+  return entrypoint === 'claude-vscode' ? 'editor' : 'terminal';
 }
 
-/**
- * A SUBAGENT IS NOT A THREAD SHE OPENED. Claude Code files them under
- *  `<session>/subagents/`, one per fan-out, so the parent already stands for
- *  them and listing both says the same work twice. */
+/** Claude Code files subagent transcripts under `<session>/subagents/`. The
+ *  parent session already stands for that work. */
 export function isSubagentPath(file) {
   return /(^|\/)subagents\//.test(String(file ?? ''));
 }
 
-/* ------------------------------ WHAT IT IS CALLED -------------------------- */
-
-/**
- * Lines a person did not type, which a transcript's first turn is often made
- *  of: the slash command wrapper, the resume caveat, and anything the harness
- *  injected. A thread named `<command-name>/clear</command-name>` is a thread
- *  she cannot recognise. */
+/** Lines Claude Code writes into a first turn that a person did not type: the
+ *  slash command wrapper, the resume caveat and injected reminders. */
 const NOT_TYPED = [
   /^<command-name>/, /^<command-message>/, /^<command-args>/, /^<local-command/,
   /^<system-reminder>/, /^<user-memory/, /^Caveat: The messages below/,
   /^This session is being continued from/, /^\[Request interrupted/,
 ];
 
-/**
- * THE NAME ON THE ROW, out of the first thing she actually typed.
- *
- *  A terminal transcript has no title in it: measured 2026-08-29, ZERO of her
- *  495 recent files carry a `summary` row, so there is nothing to read but the
- *  conversation. The first human sentence is what the desktop app titles from
- *  too, and it is the line she would know the thread by.
- *
- *  SEVERAL MESSAGES ARE OFFERED, NOT ONE, and that is a fix rather than a
- *  flourish. A session that opens with a slash command has the wrapper as its
- *  first user message and her actual words in the second, so reading only the
- *  first left four of her own threads in an outside repo nameless and
- *  therefore off the card. The first message that is something a person typed
- *  wins; a thread with no such message has no name and is dropped, which is the
- *  right outcome for a session that was never spoken to.
- *
- *  Markdown is flattened rather than rendered, because this lands in a list. */
+/** The row's name, from the first line a person typed. Terminal transcripts
+ *  carry no title, so the conversation is all there is. Takes several messages
+ *  because a session that opens with a slash command has the wrapper first and
+ *  the person's words second. Returns '' when nobody typed anything, and the
+ *  caller drops that thread. */
 export function threadTitle(texts, max = 72) {
   for (const text of Array.isArray(texts) ? texts : [texts]) {
     const got = titleFromOne(text, max);
@@ -204,7 +122,7 @@ function titleFromOne(text, max) {
   const raw = String(text ?? '').replace(/\r/g, '');
   for (const line of raw.split('\n')) {
     // `[Image #1]` and `[Pasted text #1 +40 lines]` are Claude Code's stand-ins
-    // for what was pasted, not words she typed.
+    // for what was pasted.
     const t = line.replace(/\[(?:Image|Pasted text) #\d+[^\]]*\]/g, '').trim();
     if (!t) continue;
     if (NOT_TYPED.some((re) => re.test(t))) return '';
@@ -222,27 +140,17 @@ function titleFromOne(text, max) {
   return '';
 }
 
-/**
- * `/Users/you/Desktop/dev/zero` → `~/Desktop/dev/zero`. Same reason as the
- * one in agent-files.mjs: a path carrying her account name reads like a
- * system string rather than a folder she knows. */
+/** Writes a folder under home as `~/...`. */
 export function shortFolder(folder, home = os.homedir()) {
   const here = path.resolve(home);
   const full = path.resolve(String(folder ?? '') || here);
   return full === here || full.startsWith(`${here}/`) ? `~${full.slice(here.length)}` : full;
 }
 
-/* ------------------------------ THE TERMINAL SIDE -------------------------- */
-
-/**
- * The head of a transcript, and out of it the three things a row needs: who
- *  started the session, which folder it ran in, and the first thing the person
- *  typed.
- *
- *  Read as a fixed head rather than a whole file. `entrypoint` and `cwd` are on
- *  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. */
+/** Reads a transcript's head for who started the session, which folder it ran
+ *  in and the first messages the person typed. `entrypoint` and `cwd` are on
+ *  every message row and the first human turn comes first, so a fixed head is
+ *  enough. */
 export function readTranscriptHead(file, bytes = HEAD_BYTES, most = FIRST_TURN_BYTES) {
   let fd = null;
   try {
@@ -250,16 +158,18 @@ export function readTranscriptHead(file, bytes = HEAD_BYTES, most = FIRST_TURN_B
     const buf = Buffer.alloc(bytes);
     const n = fs.readSync(fd, buf, 0, bytes, 0);
     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.
+    // The last line of a full-size read is usually cut in half, so it is set
+    // aside. When the whole file fit, the last line is complete and is kept.
     const lines = text.split('\n');
-    const cut = lines.pop();
+    const cut = n < bytes ? null : lines.pop();
     let cwd = null;
     let entrypoint = null;
+    let firstAt = 0;
     const said = [];
     const take = (line) => {
       let row;
       try { row = JSON.parse(line); } catch { return; }
+      if (!firstAt && row.timestamp) firstAt = Date.parse(row.timestamp) || 0;
       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) {
@@ -272,29 +182,81 @@ export function readTranscriptHead(file, bytes = HEAD_BYTES, most = FIRST_TURN_B
       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))
+    // If the cut line is the first user message, cut because a screenshot was
+    // pasted into it, read it to its end, up to `most`. Only when nothing typed
+    // was found and the session is not known to be the app's own, so worker
+    // transcripts are never read past their head.
+    if (!said.length && n === bytes && cut && /"type"\s*:\s*"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 };
+    return { cwd, entrypoint, said, firstAt };
   } catch {
-    return { cwd: null, entrypoint: null, said: [] };
+    return { cwd: null, entrypoint: null, said: [], firstAt: 0 };
   } finally {
     if (fd !== null) { try { fs.closeSync(fd); } catch { /* nothing to do */ } }
   }
 }
 
-/**
- * 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. */
+/** A `user` line a person typed, as opposed to a tool result, a reminder or a
+ *  command's wrapper. Only these end the agent's reply. */
+function typedTurn(row) {
+  if (row?.type !== 'user' || row.toolUseResult || row.isMeta || row.isCompactSummary) return false;
+  return threadTitle(messageText(row)) !== '';
+}
+
+/** Reads a transcript's end for Claude Code's own title (`ai-title`, the last
+ *  one wins) and the agent's last reply, every text block of it since the last
+ *  thing a person typed. */
+export function readTranscriptTail(file, bytes = TAIL_BYTES) {
+  let fd = null;
+  try {
+    fd = fs.openSync(file, 'r');
+    const size = fs.fstatSync(fd).size;
+    const from = Math.max(0, size - bytes);
+    const buf = Buffer.alloc(size - from);
+    const n = fs.readSync(fd, buf, 0, buf.length, from);
+    const lines = buf.slice(0, n).toString('utf8').split('\n');
+    if (from > 0) lines.shift();
+    let aiTitle = '';
+    let reply = '';
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      let row;
+      try { row = JSON.parse(line); } catch { continue; }
+      if (row.type === 'ai-title' && row.aiTitle) aiTitle = String(row.aiTitle);
+      else if (typedTurn(row)) reply = '';
+      else if (row.type === 'assistant') {
+        const text = messageText(row).trim();
+        if (text) reply = reply ? `${reply}\n\n${text}` : text;
+      }
+    }
+    return { aiTitle, lastSaid: reply.slice(-SAID_CHARS) };
+  } catch {
+    return { aiTitle: '', lastSaid: '' };
+  } finally {
+    if (fd !== null) { try { fs.closeSync(fd); } catch { /* nothing to do */ } }
+  }
+}
+
+/** What a finished read knows about how a chat ended, for its row and the
+ *  setup card. */
+function endOf(file) {
+  const { aiTitle, lastSaid } = file ? readTranscriptTail(file) : { aiTitle: '', lastSaid: '' };
+  return { aiTitle, lastSaid, ...howTheChatEnded(lastSaid) };
+}
+
+/** The first message a person typed, whole, for an imported row's opening. */
+function firstTyped(said) {
+  for (const text of said) {
+    if (threadTitle(text)) return String(text).trim().slice(0, FIRST_CHARS);
+  }
+  return '';
+}
+
+/** The bytes from `from` up to the next newline or the end of the file, or
+ *  null if neither comes within `budget` bytes. */
 function restOfLine(fd, from, budget) {
   const parts = [];
   let at = from;
@@ -310,9 +272,7 @@ function restOfLine(fd, from, budget) {
   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. */
+/** A row's content is either a string or a list of blocks. */
 function messageText(row) {
   const c = row?.message?.content;
   if (typeof c === 'string') return c;
@@ -325,77 +285,125 @@ function messageText(row) {
   return '';
 }
 
-/**
- * Every terminal thread, newest first, with the three kinds of noise gone.
- *
- *  `skipped` comes back with it because the counts are the argument for the
- *  filters, and a session that changes one of them should be able to see what
- *  it changed rather than take this comment's word for it. */
-function readTerminalThreads({ home, cutoff, max, skipIds = new Set() }) {
-  const root = path.join(home, '.claude', 'projects');
-  const skipped = { old: 0, scratch: 0, started: 0, subagent: 0, empty: 0, unread: 0, desktopDupe: 0 };
+/** `skipped` counts why each transcript was left out, so a change to a filter
+ *  can be measured. */
+function readTerminalThreads({ home, dirs, cutoff, max, budgetMs = READ_BUDGET_MS, skipIds = new Set() }) {
+  const skipped = { old: 0, scratch: 0, started: 0, subagent: 0, empty: 0, unread: 0, desktopDupe: 0, copy: 0 };
   const out = [];
-  const all = [];
-  walkTranscripts(root, all);
-  // Stat everything, keep the recent, newest first, and only then start opening
-  // files. This is the order that makes `max` safe: whatever it cuts off is
-  // older than everything it kept.
+  // Every data folder is pooled and sorted newest first before any file is
+  // opened, so `max` and the time budget only ever cut off older sessions.
   const recent = [];
-  for (const file of all) {
-    let when = 0;
-    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 });
+  for (const dir of dirs) {
+    const root = path.join(dir, 'projects');
+    const all = [];
+    walkTranscripts(root, all);
+    for (const file of all) {
+      let when = 0;
+      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);
-  // 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.
+  // One session is one row even when two data folders hold a copy. Newest
+  // first, so the copy kept is the one still being written to.
+  const seenIds = new Set();
+  // The cap counts threads kept, not files opened: on a machine running many
+  // workers, the newest thousand transcripts can all be Agentbox's own.
   const started = Date.now();
   let opened = 0;
+  // The moment the read gave up at, zero when it read the whole window. A
+  // name is only known once the file is open, so a search that stopped in
+  // August must not answer "no such chat" as if it had looked at September.
+  let reached = 0;
+  let lastOpened = 0;
+  // The desktop app's own record wins over its transcript, but how the chat
+  // ended is only in the transcript.
+  const desktopFiles = new Map();
   for (const { file, when } of recent) {
-    if (out.length >= max || Date.now() - started > READ_BUDGET_MS) {
+    if (out.length >= max || Date.now() - started > budgetMs) {
       skipped.unread = recent.length - opened;
+      reached = lastOpened;
       break;
     }
     opened += 1;
+    lastOpened = when;
     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
-    // one desktop thread in her store. Its own record wins, because the app
-    // wrote a real title into it and this side would have to guess one.
-    if (skipIds.has(id)) { skipped.desktopDupe += 1; continue; }
-    const { cwd, entrypoint, said } = readTranscriptHead(file);
+    // The desktop app writes a thread twice, as a transcript here and as its
+    // own record joined by `cliSessionId`. Its record wins because it has a
+    // real title.
+    if (skipIds.has(id)) {
+      skipped.desktopDupe += 1;
+      if (!desktopFiles.has(id)) desktopFiles.set(id, file);
+      continue;
+    }
+    if (seenIds.has(id)) { skipped.copy += 1; continue; }
+    const { cwd, entrypoint, said, firstAt } = readTranscriptHead(file);
+    // Only a readable copy counts, so a newer copy cut off mid-write does not
+    // hide a good older one.
+    if (cwd || entrypoint) seenIds.add(id);
     if (!startedByHand(entrypoint)) { skipped.started += 1; continue; }
     if (isScratchFolder(cwd, home)) { skipped.scratch += 1; continue; }
     const title = threadTitle(said);
     if (!title) { skipped.empty += 1; continue; }
     out.push({
       id,
-      source: entrypoint === 'claude-desktop' ? 'desktop' : 'terminal',
+      source: sourceOf(entrypoint),
       folder: cwd,
       folderName: path.basename(cwd),
       short: shortFolder(cwd, home),
       title,
       when,
       path: file,
+      firstSaid: firstTyped(said),
+      startedAt: firstAt || when,
     });
   }
-  return { threads: out, skipped };
+  return { threads: out, skipped, reached, desktopFiles };
+}
+
+/** How many of the newest threads get their end read, and for how long. The
+ *  head walk above has its own budget, so this one only ever adds detail to
+ *  threads already listed. */
+const ENDS_MOST = 120;
+const ENDS_BUDGET_MS = 2000;
+
+function withEnds(threads, desktopFiles) {
+  const started = Date.now();
+  return threads.map((t, i) => {
+    const file = t.source === 'desktop' ? desktopFiles.get(t.id) ?? null : t.path;
+    if (i >= ENDS_MOST || Date.now() - started > ENDS_BUDGET_MS || !file) {
+      // Not "finished": nothing is known of how it ended until it is picked.
+      return { ...t, waiting: false, ask: '', lastSaid: '', endUnknown: true };
+    }
+    const end = endOf(file);
+    const firstSaid = t.firstSaid ?? firstTyped(readTranscriptHead(file).said);
+    return {
+      ...t,
+      title: t.source === 'desktop' ? t.title : threadTitle(end.aiTitle) || t.title,
+      waiting: end.waiting,
+      ask: end.ask,
+      lastSaid: end.lastSaid,
+      firstSaid,
+    };
+  });
+}
+
+/** The chats somebody picked, with the end read for any the list left unread
+ *  (past its cap, or found by name). Codex and desktop chats come read. */
+export function readChatEnds(threads) {
+  return threads.map((t) => {
+    if (t.source === 'codex' || t.source === 'desktop' || !t.path) return t;
+    if (t.lastSaid !== undefined && !t.endUnknown) return t;
+    const { endUnknown, ...rest } = t;
+    return withEnds([rest], new Map())[0];
+  });
 }
 
-/**
- * Every transcript under the projects root, subagent folders included so the
- *  filter above can count them rather than the walk hiding them. Unbounded on
- *  purpose: this only lists names, and the cap that matters is on opening. */
+/** Lists every transcript, subagents included so the caller can count them.
+ *  Not capped: listing names is cheap, and the cap is on opening. */
 function walkTranscripts(dir, into, depth = 4) {
   if (depth < 0) return;
   let entries = [];
@@ -407,30 +415,17 @@ function walkTranscripts(dir, into, depth = 4) {
   }
 }
 
-/* ------------------------------- THE DESKTOP SIDE -------------------------- */
-
-/** Where the desktop app keeps what it knows about a session. */
 export function desktopSessionsDir(home = os.homedir()) {
   return path.join(home, 'Library', 'Application Support', 'Claude', 'claude-code-sessions');
 }
 
-/**
- * THE DESKTOP APP'S THREADS, which are the easy half.
- *
- *  Its record is small and it carries a real `title` the app wrote, plus the
- *  folder, the branch and the moment of the last turn. So there is no
- *  transcript to read and no name to guess: measured on her Mac 2026-08-29, 38
- *  records, every one of them titled, for example "Fix duplicate cowork task
- *  display issue".
- *
- *  Archived ones are left out. She archived them, which is the desktop app's
- *  word for done with. */
+/** The desktop app's record carries a real `title`, the folder and the time of
+ *  the last turn, so no transcript is read. Archived sessions are left out. */
 function readDesktopThreads({ home, cutoff, max }) {
   const root = desktopSessionsDir(home);
   const skipped = { old: 0, scratch: 0, archived: 0, empty: 0 };
   const out = [];
-  // Every id this side owns, recent or not, so the transcript walk can leave
-  // them alone rather than draw the same thread under a worse name.
+  // Every id this side owns, recent or not, so the transcript walk skips them.
   const owned = new Set();
   const files = [];
   walkDesktop(root, files, max);
@@ -454,6 +449,7 @@ function readDesktopThreads({ home, cutoff, max }) {
       title,
       when,
       path: file,
+      startedAt: Number(rec?.createdAt || when),
     });
   }
   return { threads: out, skipped, owned };
@@ -471,41 +467,96 @@ function walkDesktop(dir, into, max, depth = 3) {
   }
 }
 
-/* ---------------------------------- BOTH ----------------------------------- */
-
-/**
- * BOTH SOURCES, NEWEST FIRST, THE HANDFUL SHE MEANT.
- *
- *  `days` is her "last few days" and it is a parameter rather than a constant
- *  because the number is the one thing on this card somebody may want to argue
- *  about. Everything else here is a fact about the file.
- *
- *  One row per thread and no folding by folder: the folder is on the row and
- *  the card groups by it, the same way it already groups agent files. */
+/** Terminal, editor and desktop threads a person started, newest first, one
+ *  row per thread. */
 export function readSessionThreads({
   home = os.homedir(),
+  // The app passes the data folders it found with its own environment and
+  // settings. The default is the folders under `home`, ignoring whatever
+  // CLAUDE_CONFIG_DIR the calling process has.
+  dirs = claudeDataDirs({ home }),
   days = RECENT_DAYS,
   now = Date.now(),
   max = MAX_READS,
+  // The card's list keeps the three seconds it was measured for; a search is
+  // allowed longer, reaching back a year with somebody waiting on it.
+  budgetMs = READ_BUDGET_MS,
+  // Whether to read each listed chat's end too: its own title, its last reply
+  // and whether it is waiting on you. The year-long search does not need it.
+  ends = true,
 } = {}) {
   const cutoff = now - Math.max(0, Number(days) || 0) * 86400 * 1000;
-  // The desktop side goes first so its ids are known before the transcripts are
-  // walked, which is what stops one thread appearing twice.
+  // The desktop side goes first so its ids are known before the transcripts
+  // are walked, which stops one thread appearing twice.
   const desk = readDesktopThreads({ home, cutoff, max });
-  const term = readTerminalThreads({ home, cutoff, max, skipIds: desk.owned });
-  const threads = [...term.threads, ...desk.threads].sort((a, b) => b.when - a.when);
+  const term = readTerminalThreads({ home, dirs, cutoff, max, budgetMs, skipIds: desk.owned });
+  const listed = [...term.threads, ...desk.threads].sort((a, b) => b.when - a.when);
+  const threads = ends ? withEnds(listed, term.desktopFiles) : listed;
   return {
     threads,
     skipped: { ...term.skipped, desktopOld: desk.skipped.old, archived: desk.skipped.archived },
+    /** Zero when the whole window was read. See `reached` above. */
+    reached: term.reached,
+  };
+}
+
+/* -------------------- AND THE ONE THE NEW-CHATS WATCH USES ------------------ */
+// The watch (main/new-chats-watch.mjs) runs every minute on the main process,
+// so it reads only the folders the projects point at, which also leaves out
+// Agentbox's own runs in their task folders, only files changed since the
+// switch went on, and each file once until it changes.
+
+const PROJECT_CHATS_KEPT = 2000;
+const projectChats = new Map();
+const slugOf = (folder) => String(folder ?? '').replace(/[^a-zA-Z0-9]/g, '-');
+const sameFolder = (a, b) => String(a ?? '').replace(/\/+$/, '') === String(b ?? '').replace(/\/+$/, '');
+
+function readOneChat(file, { id, folder, home, when }) {
+  const { cwd, entrypoint, said, firstAt } = readTranscriptHead(file);
+  if (!startedByHand(entrypoint) || !sameFolder(cwd, folder)) return null;
+  const title = threadTitle(said);
+  if (!title) return null;
+  const end = endOf(file);
+  return {
+    id, source: sourceOf(entrypoint), folder: cwd, folderName: path.basename(cwd), short: shortFolder(cwd, home),
+    title: threadTitle(end.aiTitle) || title, when, path: file,
+    waiting: end.waiting, ask: end.ask, lastSaid: end.lastSaid, firstSaid: firstTyped(said), startedAt: firstAt || when,
   };
 }
 
-/**
- * THE FOLDERS THOSE THREADS RAN IN, each with its own threads under it.
- *
- *  The import card is already a section per place the rows can land, so this is
- *  the shape it wants. Sorted by the newest thread in each, because the folder
- *  she touched an hour ago is the one she is looking for. */
+export function readProjectChats({ home = os.homedir(), dirs = claudeDataDirs({ home }), folders = [], since = 0 } = {}) {
+  const out = [];
+  const seen = new Set();
+  for (const dir of dirs) {
+    for (const folder of folders) {
+      const at = path.join(dir, 'projects', slugOf(folder));
+      let names = [];
+      try { names = fs.readdirSync(at); } catch { continue; }
+      for (const name of names) {
+        if (!name.endsWith('.jsonl')) continue;
+        const id = name.slice(0, -'.jsonl'.length);
+        if (seen.has(id)) continue;
+        const file = path.join(at, name);
+        let st;
+        try { st = fs.statSync(file); } catch { continue; }
+        if (st.mtimeMs < since) continue;
+        const kept = projectChats.get(file);
+        let thread = kept?.thread ?? null;
+        if (!kept || kept.size !== st.size || kept.mtimeMs !== st.mtimeMs) {
+          thread = readOneChat(file, { id, folder, home, when: st.mtimeMs });
+          projectChats.delete(file);
+          projectChats.set(file, { size: st.size, mtimeMs: st.mtimeMs, thread });
+          if (projectChats.size > PROJECT_CHATS_KEPT) projectChats.delete(projectChats.keys().next().value);
+        }
+        if (thread) { seen.add(id); out.push(thread); }
+      }
+    }
+  }
+  return out.sort((a, b) => b.when - a.when);
+}
+
+/** Groups threads by folder, each folder sorted by its newest thread. Expects
+ *  the threads newest first, as readSessionThreads returns them. */
 export function threadsByFolder(threads = []) {
   const byFolder = new Map();
   for (const t of threads) {