workoffdesk 1.0.0 → 1.0.2

package/dist/server/agents/claude/transcript/events.js

@@ -0,0 +1,158 @@
+import { stripVTControlCharacters } from 'node:util';
+const str = (v) => (typeof v === 'string' ? v : '');
+const object = (v) => (v && typeof v === 'object' ? v : null);
+// As text, without the colours and links a terminal would have drawn from it.
+export function blocksText(content) {
+    if (typeof content === 'string')
+        return stripVTControlCharacters(content);
+    if (!Array.isArray(content))
+        return '';
+    return content
+        .map((b) => (b?.type === 'text' ? stripVTControlCharacters(str(b.text)) : b?.type === 'image' ? '[image]' : ''))
+        .filter(Boolean)
+        .join(' ');
+}
+// Only what was typed: the text blocks, without pictures.
+const typedText = (content) => typeof content === 'string' ? content : Array.isArray(content) ? content.flatMap((b) => (b?.type === 'text' && typeof b.text === 'string' ? [b.text] : [])).join(' ') : '';
+// Text as it was pasted at the prompt, which Claude Code records wrapped in a tag naming the paste.
+const unpasted = (text) => text.replace(/<pasted_content id="([^"]*)">\n*([\s\S]*?)\n*<\/pasted_content id="\1">/g, '$2');
+const XML_ENTITIES = { '&amp;': '&', '&lt;': '<', '&gt;': '>', '&quot;': '"', '&apos;': "'" };
+export const tagText = (text, tag) => new RegExp(`<${tag}>([\\s\\S]*?)</${tag}>`).exec(text)?.[1].replace(/&(?:amp|lt|gt|quot|apos);/g, (e) => XML_ENTITIES[e]).trim() ?? '';
+const INTERRUPTED = '[Request interrupted';
+const COMMAND = /<command-name>([^<]*)<\/command-name>/;
+const COMMAND_OUTPUT = /^<local-command-std(?:out|err)>([\s\S]*?)(?:<\/local-command-std(?:out|err)>)?$/;
+function commandOf(text, local) {
+    const command = COMMAND.exec(text);
+    if (command)
+        return { k: 'claude:command', name: command[1].trim(), args: tagText(text, 'command-args'), local };
+    const output = COMMAND_OUTPUT.exec(text);
+    return output ? { k: 'claude:commandOutput', text: output[1], local } : null;
+}
+// Teammates' messages, which older Claude Code records with no sender: it wraps them in this envelope instead.
+const TEAMMATES = 'Another Claude session sent a message:\n<teammate-message ';
+const teammates = (text) => [...text.matchAll(/<teammate-message\s[^>]*?teammate_id="([^"]*)"[^>]*>([\s\S]*?)<\/teammate-message>/g)].map(([, from, body]) => ({ from, body: body.trim() }));
+// What the person's own record says, once it is known to be theirs.
+function personSaid(r) {
+    const content = r.message?.content;
+    if (r.isCompactSummary)
+        return { k: 'claude:compacted' };
+    if (Array.isArray(content) && content.some((b) => b?.type === 'tool_result')) {
+        const results = content
+            .filter((b) => b?.type === 'tool_result' && typeof b.tool_use_id === 'string')
+            .map((b) => ({
+            id: b.tool_use_id,
+            text: blocksText(b.content),
+            error: b.is_error === true,
+            image: Array.isArray(b.content) && b.content.some((c) => c?.type === 'image'),
+        }));
+        return { k: 'claude:results', results, detail: r.toolUseResult };
+    }
+    const text = unpasted(blocksText(content)).trim();
+    if (text.startsWith(INTERRUPTED))
+        return { k: 'claude:interrupted' };
+    const command = commandOf(text, false);
+    if (command)
+        return command;
+    if (text.startsWith('<bash-input>'))
+        return { k: 'claude:shell', command: tagText(text, 'bash-input') };
+    if (text.startsWith('<bash-stdout>'))
+        return { k: 'claude:shellOutput', text: [tagText(text, 'bash-stdout'), tagText(text, 'bash-stderr')].filter(Boolean).join('\n') };
+    return { k: 'claude:prompt', text, words: unpasted(typedText(content)) };
+}
+// A user record: the person's, or one Claude Code records who sent. Older versions record nobody, and then it
+// is the person's, unless it is teammates' messages in their envelope.
+function userEvent(r) {
+    const origin = object(r.origin);
+    if (!origin) {
+        const text = blocksText(r.message?.content).trim();
+        if (text.startsWith(TEAMMATES))
+            return { k: 'claude:teammates', messages: teammates(text) };
+        return r.isMeta ? { k: 'claude:noted' } : personSaid(r);
+    }
+    if (origin.kind === 'peer') {
+        const pid = origin.verifiedPeerPid;
+        return { k: 'claude:peer', from: str(origin.name), body: str(origin.body), ...(Number.isSafeInteger(pid) && { pid: pid }) };
+    }
+    if (r.isMeta)
+        return { k: 'claude:noted' };
+    if (origin.kind === 'human')
+        return personSaid(r);
+    const text = blocksText(r.message?.content).trim();
+    return origin.kind === 'task-notification' ? { k: 'claude:taskNotification', text } : { k: 'claude:fromOther', text };
+}
+function replyEvent(r) {
+    const content = r.message?.content;
+    if (r.isApiErrorMessage)
+        return { k: 'claude:apiError', limit: r.error === 'rate_limit', text: blocksText(content) };
+    const blocks = (Array.isArray(content) ? content : []).flatMap((b) => {
+        if (b?.type === 'text' && typeof b.text === 'string')
+            return [{ type: 'text', text: b.text }];
+        if (b?.type === 'tool_use' && typeof b.id === 'string')
+            return [{ type: 'tool_use', id: b.id, name: str(b.name), input: object(b.input) ?? {} }];
+        return [];
+    });
+    return { k: 'claude:reply', blocks };
+}
+function systemEvent(r) {
+    if (r.subtype === 'stop_hook_summary')
+        return { k: 'claude:turnOver' };
+    if (r.subtype === 'compact_boundary')
+        return { k: 'claude:compactBoundary', manual: object(r.compactMetadata)?.trigger === 'manual' };
+    if (r.subtype === 'local_command')
+        return commandOf(str(r.content).trim(), true) ?? { k: 'claude:other' };
+    return { k: 'claude:other' };
+}
+// A message the person sent while Claude worked, which Claude took in the middle of its turn.
+function midTurnEvent(r) {
+    const a = object(r.attachment);
+    if (a?.type !== 'queued_command' || a.isMeta)
+        return { k: 'claude:other' };
+    const origin = object(a.origin);
+    if (origin?.kind === 'task-notification' || a.commandMode === 'task-notification')
+        return { k: 'claude:midTurnTaskEnd', text: blocksText(a.prompt) };
+    if ((a.commandMode ?? 'prompt') !== 'prompt' || (origin && origin.kind !== 'human'))
+        return { k: 'claude:other' };
+    return { k: 'claude:midTurnPrompt', text: unpasted(blocksText(a.prompt)).trim() };
+}
+const QUEUE_OPS = ['enqueue', 'dequeue', 'remove', 'popAll'];
+function kindOf(r) {
+    if (r.isSidechain)
+        return { k: 'claude:sidechain' };
+    switch (r.type) {
+        case 'user':
+            return object(r.message) ? userEvent(r) : { k: 'claude:other' };
+        case 'assistant':
+            return object(r.message) ? replyEvent(r) : { k: 'claude:other' };
+        case 'system':
+            return systemEvent(r);
+        case 'attachment':
+            return midTurnEvent(r);
+        case 'queue-operation': {
+            const op = QUEUE_OPS.find((o) => o === r.operation);
+            if (!op)
+                return { k: 'claude:other' };
+            return typeof r.content === 'string' ? { k: 'claude:queue', op, text: r.content } : { k: 'claude:queue', op };
+        }
+        case 'custom-title':
+            return { k: 'claude:title', by: 'person', text: str(r.customTitle) };
+        case 'ai-title':
+            return { k: 'claude:title', by: 'claude', text: str(r.aiTitle) };
+        case 'last-prompt':
+            return { k: 'claude:lastPrompt', text: str(r.lastPrompt) };
+        default:
+            return { k: 'claude:other' };
+    }
+}
+export function eventOf(v) {
+    const r = object(v);
+    if (!r)
+        return { k: 'claude:other' };
+    const event = kindOf(r);
+    return typeof r.timestamp === 'string' ? { ...event, at: r.timestamp } : event;
+}
+// What a record says beside its kind: the folder it was written in, and whether a program rather than a person
+// ran the conversation.
+export function envelopeOf(v) {
+    const r = object(v);
+    return { cwd: typeof r?.cwd === 'string' && r.cwd ? r.cwd : null, automated: r?.entrypoint === 'sdk-cli' };
+}

package/dist/server/agents/claude/transcript/transcriptFile.js

@@ -1,5 +1,5 @@
-import { readdir, open, stat } from 'node:fs/promises';
-import { join } from 'node:path';
+import { readdir, readFile, open, stat } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
 import { chatItems } from './chat.js';
 // A session's transcript file read for the chat: from where the phone's copy ends, back from where it
 // starts, its last reply, and where it is.
@@ -8,9 +8,11 @@ const MAX_READ = 4 * 1024 * 1024;
 // About a screenful of turns many times over, little enough to come at once on a slow phone.
 const PAGE_TURNS = 100;
 const CHUNK = 256 * 1024;
-function lineItems(l) {
+// sidechain: the file is a sub-agent's, whose records are all marked as not its parent's, and are its own here.
+function lineItems(l, sidechain = false) {
     try {
-        return chatItems(JSON.parse(l));
+        const r = JSON.parse(l);
+        return chatItems(sidechain && r && typeof r === 'object' ? { ...r, isSidechain: false } : r);
     }
     catch {
         return [];
@@ -65,13 +67,17 @@ export async function linesFrom(path, from, maxRead = MAX_READ) {
 export async function readChat(path, from, o = {}) {
     const size = (await stat(path)).size;
     if (from === 0 || from > size)
-        return readChatBefore(path, size, { turns: o.turns });
+        return readChatBefore(path, size, { turns: o.turns, sidechain: o.sidechain });
     const fh = await open(path, 'r');
     try {
         const buf = Buffer.alloc(Math.min(size - from, o.maxRead ?? MAX_READ));
         await fh.read(buf, 0, buf.length, from);
         const end = buf.lastIndexOf(0x0a) + 1;
-        const items = buf.subarray(0, end).toString('utf8').split('\n').flatMap(lineItems);
+        const items = buf
+            .subarray(0, end)
+            .toString('utf8')
+            .split('\n')
+            .flatMap((l) => lineItems(l, o.sidechain));
         return { items, from, next: from + end, skipped: false };
     }
     finally {
@@ -133,7 +139,7 @@ export async function readChatBefore(path, before, o = {}) {
             next ??= start + line.length + 1;
             if (count >= turns || (from !== undefined && next - start > maxRead))
                 break;
-            const items = lineItems(line.toString('utf8'));
+            const items = lineItems(line.toString('utf8'), o.sidechain);
             taken.push(items);
             count += items.filter((i) => i.k !== 'result').length;
             from = start;
@@ -147,11 +153,17 @@ export async function readChatBefore(path, before, o = {}) {
 }
 const REPLY_TAIL = 256 * 1024;
 const REPLY_CHARS = 120;
-// What Claude said last, or the error its turn ended in, as a line of plain words for a list to show under the session's name: the
-// Markdown it writes in is dropped. Only the end of the transcript is read; null when nothing is there.
-export async function lastReply(path, tail = REPLY_TAIL) {
+// What a list shows of a conversation, from the end of its transcript. reply: what Claude said last, or the
+// error its turn ended in, as a line of plain words (the Markdown it writes in is dropped). at: when the last
+// thing in it happened. Each null when nothing is there.
+export async function lastSaid(path, tail = REPLY_TAIL) {
     const size = (await stat(path)).size;
     const { items } = await readChat(path, Math.max(0, size - tail));
+    const dated = items.findLast((i) => 'at' in i && i.at);
+    const at = dated && 'at' in dated && dated.at ? Date.parse(dated.at) : NaN;
+    return { reply: replyOf(items), at: Number.isFinite(at) ? at : null };
+}
+function replyOf(items) {
     const last = items.findLast((i) => i.k === 'text' || (i.k === 'note' && 'event' in i && i.event.e === 'failed'));
     if (!last)
         return null;
@@ -192,3 +204,31 @@ export async function findTranscript(root, sessionId) {
     }
     return null;
 }
+// A sub-agent a conversation started, by the id of the call that started it: its transcript, beside
+// <session id>/subagents/agent-<id>.meta.json, which names the call, under the conversation's own folder.
+export async function findSubagent(root, sessionId, toolUseId) {
+    const parent = await findTranscript(root, sessionId);
+    if (!parent)
+        return null;
+    const dir = join(dirname(parent), sessionId, 'subagents');
+    let names;
+    try {
+        names = await readdir(dir);
+    }
+    catch {
+        return null;
+    }
+    for (const n of names.filter((n) => /^agent-[A-Za-z0-9]+\.meta\.json$/.test(n))) {
+        try {
+            const meta = JSON.parse(await readFile(join(dir, n), 'utf8'));
+            if (!meta || typeof meta !== 'object' || meta.toolUseId !== toolUseId)
+                continue;
+            const description = meta.description;
+            return { path: join(dir, n.replace(/\.meta\.json$/, '.jsonl')), description: typeof description === 'string' ? description : '' };
+        }
+        catch {
+            // being written, or not a sub-agent's
+        }
+    }
+    return null;
+}

package/dist/server/agents/claude/transcript/transcripts.js

@@ -1,6 +1,9 @@
 import { open, readdir, readFile, stat } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { basename, join } from 'node:path';
+import { envelopeOf, eventOf } from './events.js';
+import { unhandled } from '../../events.js';
+import { findTranscript } from './transcriptFile.js';
 const HEAD_BYTES = 256 * 1024;
 const TAIL_BYTES = 64 * 1024;
 const TITLE_MAX = 60;
@@ -21,21 +24,53 @@ export function listRecentClaudeSessions(root, limit = 50) {
 async function listRecent(root, limit) {
     const files = await transcriptFiles(root);
     files.sort((a, b) => b.mtimeMs - a.mtimeMs);
-    const out = [];
-    const count = { people: 0, programs: 0 };
+    const kept = { people: [], programs: [] };
+    // Nothing was said in a file after it was last written, so once a file was written before the limit-th
+    // latest message of each kind, no file after it can be among them.
+    const latest = (list) => (list.length < limit ? -Infinity : list[limit - 1].lastActivity);
     for (const f of files.slice(0, limit * 6)) {
-        if (count.people >= limit && count.programs >= limit)
+        if (f.mtimeMs < latest(kept.people) && f.mtimeMs < latest(kept.programs))
             break;
-        const parsed = await parsedOnce(f);
-        if (!parsed || isScratch(parsed.cwd))
-            continue;
-        const kind = parsed.automated ? 'programs' : 'people';
-        if (count[kind] >= limit)
+        const r = await rowOf(f);
+        if (!r || isScratch(r.cwd))
             continue;
-        count[kind]++;
-        out.push({ sessionId: basename(f.path, '.jsonl'), ...parsed, lastActivity: Math.round(f.mtimeMs) });
+        const list = kept[r.automated ? 'programs' : 'people'];
+        list.push(r);
+        list.sort((a, b) => b.lastActivity - a.lastActivity);
+        list.splice(limit);
     }
-    return out;
+    return [...kept.people, ...kept.programs].sort((a, b) => b.lastActivity - a.lastActivity);
+}
+// Every conversation Claude Code still keeps, newest first, programs' too. Asked again while a listing runs, the
+// one running answers.
+let listingAll = null;
+export function listAllClaudeSessions(root) {
+    listingAll ??= listAll(root).finally(() => {
+        listingAll = null;
+    });
+    return listingAll;
+}
+async function listAll(root) {
+    const all = [];
+    for (const f of await transcriptFiles(root)) {
+        const r = await rowOf(f);
+        if (r && !isScratch(r.cwd))
+            all.push(r);
+    }
+    return all.sort((a, b) => b.lastActivity - a.lastActivity);
+}
+// One conversation Claude Code still keeps, as the lists have it, however old; null when it keeps none by that id.
+export async function oneClaudeSession(root, sessionId) {
+    const path = await findTranscript(root, sessionId);
+    const st = path ? await stat(path).catch(() => null) : null;
+    return path && st ? rowOf({ path, size: st.size, mtimeMs: st.mtimeMs }) : null;
+}
+async function rowOf(f) {
+    const parsed = await parsedOnce(f);
+    if (!parsed)
+        return null;
+    const { saidAt, ...shown } = parsed;
+    return { sessionId: basename(f.path, '.jsonl'), ...shown, lastActivity: saidAt ?? Math.round(f.mtimeMs) };
 }
 // A conversation in a temporary folder is a throwaway run (a test, a probe), not work to come back to.
 const SCRATCH_ROOTS = ['/tmp/', '/private/tmp/', '/var/folders/', '/private/var/folders/', join(tmpdir(), '/')];
@@ -89,7 +124,7 @@ async function transcriptFiles(root) {
 // What a transcript was read as, kept while the file stays as it was: the list is asked for often, and
 // reading the head and tail of hundreds of files each time took seconds.
 const parsedCache = new Map();
-const PARSED_KEPT = 2000;
+const PARSED_KEPT = 20_000;
 async function parsedOnce(f) {
     const kept = parsedCache.get(f.path);
     if (kept && kept.size === f.size && kept.mtimeMs === f.mtimeMs)
@@ -104,34 +139,92 @@ async function parsedOnce(f) {
     }
     return parsed;
 }
+// saidAt: when the last message was said, by the person or Claude; null when no message carries a time.
 async function parseTranscript(path, size) {
     const records = await readRecords(path, size);
     if (!records.length)
         return null;
-    let cwd = null;
+    const cwds = [];
     let customTitle = null;
     let aiTitle = null;
     let firstPrompt = null;
     let lastPrompt = null;
     let automated = false;
+    let saidAt = null;
     for (const r of records) {
-        if (!cwd && typeof r.cwd === 'string' && r.cwd)
-            cwd = r.cwd;
-        if (r.entrypoint === 'sdk-cli')
+        const e = eventOf(r);
+        const envelope = envelopeOf(r);
+        if (envelope.cwd)
+            cwds.push(envelope.cwd);
+        if (envelope.automated)
             automated = true;
-        if (r.type === 'custom-title' && typeof r.customTitle === 'string' && r.customTitle.trim())
-            customTitle = truncate(r.customTitle.replace(/\s+/g, ' ').trim());
-        if (r.type === 'ai-title' && typeof r.aiTitle === 'string' && r.aiTitle.trim())
-            aiTitle = r.aiTitle.trim();
-        const said = r.type === 'user' && !r.isMeta && !r.isCompactSummary ? promptText(r.message?.content) : r.type === 'last-prompt' ? promptText(r.lastPrompt) : null;
+        if (e.at && isSaid(e)) {
+            const at = Date.parse(e.at);
+            if (Number.isFinite(at) && at > (saidAt ?? -Infinity))
+                saidAt = at;
+        }
+        if (e.k === 'claude:title' && e.text.trim()) {
+            if (e.by === 'person')
+                customTitle = truncate(e.text.replace(/\s+/g, ' ').trim());
+            else
+                aiTitle = e.text.trim();
+        }
+        const said = e.k === 'claude:prompt' ? promptText(e.words) : e.k === 'claude:lastPrompt' ? promptText(e.text) : null;
         if (said)
             lastPrompt = said;
-        if (!firstPrompt && r.type === 'user')
-            firstPrompt = promptText(r.message?.content);
+        if (!firstPrompt && e.k === 'claude:prompt')
+            firstPrompt = said;
     }
     const title = customTitle ?? aiTitle ?? (firstPrompt ? truncate(firstPrompt) : basename(path, '.jsonl').slice(0, 8));
-    return { cwd, title, lastPrompt: lastPrompt && truncate(lastPrompt, LAST_PROMPT_MAX), automated };
+    return { cwd: conversationFolder(cwds), title, lastPrompt: lastPrompt && truncate(lastPrompt, LAST_PROMPT_MAX), automated, saidAt };
+}
+// Whether an event is something said, by the person or Claude, rather than a note or a record of Claude Code's.
+function isSaid(e) {
+    switch (e.k) {
+        case 'claude:prompt':
+        case 'claude:shell':
+        case 'claude:shellOutput':
+        case 'claude:results':
+        case 'claude:interrupted':
+        case 'claude:compacted':
+        case 'claude:teammates':
+        case 'claude:taskNotification':
+        case 'claude:fromOther':
+        case 'claude:reply':
+        case 'claude:apiError':
+            return true;
+        case 'claude:command':
+        case 'claude:commandOutput':
+            return !e.local;
+        case 'claude:noted':
+        case 'claude:peer':
+        case 'claude:compactBoundary':
+        case 'claude:turnOver':
+        case 'claude:queue':
+        case 'claude:midTurnPrompt':
+        case 'claude:midTurnTaskEnd':
+        case 'claude:title':
+        case 'claude:lastPrompt':
+        case 'claude:sidechain':
+        case 'claude:other':
+            return false;
+        default:
+            return unhandled(e);
+    }
+}
+// The folder a conversation last ran in, from the folders its records were written in, oldest first. Within a
+// run each is the run's folder or one inside it (a cd); one that is neither starts an earlier run elsewhere.
+function conversationFolder(cwds) {
+    let folder = null;
+    for (const cwd of cwds.toReversed()) {
+        if (folder === null || within(folder, cwd))
+            folder = cwd;
+        else if (!within(cwd, folder))
+            break;
+    }
+    return folder;
 }
+const within = (inner, outer) => inner === outer || inner.startsWith(outer.endsWith('/') ? outer : `${outer}/`);
 async function readRecords(path, size) {
     const fh = await open(path, 'r');
     try {
@@ -166,12 +259,7 @@ function parseLines(text) {
     }
     return out;
 }
-function promptText(content) {
-    const raw = typeof content === 'string'
-        ? content
-        : Array.isArray(content)
-            ? content.filter((b) => b?.type === 'text' && typeof b.text === 'string').map((b) => b.text).join(' ')
-            : '';
+function promptText(raw) {
     // An agent runner's wake names its issue on a line of its own; that, not its template, says what it is.
     const issue = /^- issue:\s*(.+)$/m.exec(raw)?.[1];
     const text = (issue ?? raw.replace(/^#{1,6}\s+/gm, '')).replace(/\s+/g, ' ').trim();

package/dist/server/agents/claude/transcript/turn.js

@@ -1,100 +1,69 @@
 import { closeSync, fstatSync, openSync, readSync } from 'node:fs';
+import { turnSays } from '../../turnSays.js';
+import { eventOf } from './events.js';
 // What Claude Code's transcript says of the turn it is on, read from its end: whether the turn is over, and
 // what Claude still holds in its own queue. A message typed while it works waits there (enqueue) until it is
 // taken into the turn under way (remove), starts a turn of its own (dequeue) or is pulled back into the
 // prompt to be changed (popAll).
 // The end of the transcript read for it: what was typed long before was taken long ago.
 const TAIL_BYTES = 256 * 1024;
-const INTERRUPTED = '[Request interrupted';
-const COMMAND = /<command-name>/;
-const COMMAND_OUTPUT = /^<local-command-std(out|err)>/;
-// The entries of the lines, but for commands Claude Code ran on its own (/model, /effort): each is written as
-// the command and its output, and is no part of any turn. A command whose prompt goes to Claude (/review)
-// has no output of its own and stays, as the prompt of its turn.
-function entries(lines, wanted) {
+// The events of the lines, but for commands Claude Code ran on its own at the prompt (/model, /effort): each
+// is the command and what it printed, and no part of any turn. A command whose prompt goes to Claude (/review)
+// prints nothing of its own and stays, as the prompt of its turn.
+function events(lines, wanted) {
     const out = [];
     for (const line of lines) {
         if (!wanted(line))
             continue;
+        let v;
         try {
-            const e = JSON.parse(line);
-            if (!e || typeof e !== 'object')
-                continue;
-            if (userSays(e, COMMAND_OUTPUT)) {
-                const command = out.findLastIndex((x) => userSays(x, COMMAND));
-                if (command >= 0)
-                    out.splice(command, 1);
-                continue;
-            }
-            out.push(e);
+            v = JSON.parse(line);
         }
         catch {
-            // a line cut off by the end of what was read, or one being written
+            continue; // a line cut off by the end of what was read, or one being written
         }
+        const e = eventOf(v);
+        if (e.k === 'claude:commandOutput' && !e.local) {
+            const command = out.findLastIndex((x) => x.k === 'claude:command' && !x.local);
+            if (command >= 0)
+                out.splice(command, 1);
+            continue;
+        }
+        out.push(e);
     }
     return out;
 }
-const texts = (content) => typeof content === 'string'
-    ? [content]
-    : Array.isArray(content)
-        ? content.flatMap((b) => (b?.type === 'text' && typeof b.text === 'string' ? [b.text] : []))
-        : [];
-const userSays = (e, text) => e.type === 'user' && texts(e.message?.content).some((t) => text.test(t));
 // The messages Claude still holds, oldest first, by the queue operations since the last turn began: what
 // was held before then was taken by then.
 export function heldByClaude(lines) {
     const held = [];
-    for (const e of entries(lines, (l) => l.includes('"queue-operation"') || l.includes('"user"'))) {
-        if (startsTurn(e))
+    for (const e of events(lines, (l) => l.includes('"queue-operation"') || l.includes('"user"'))) {
+        if (turnSays(e) === 'starts')
             held.length = 0;
-        if (e.type !== 'queue-operation')
+        if (e.k !== 'claude:queue')
             continue;
-        if (e.operation === 'enqueue')
-            held.push(typeof e.content === 'string' ? e.content : '');
-        else if (e.operation === 'dequeue')
+        if (e.op === 'enqueue')
+            held.push(e.text ?? '');
+        else if (e.op === 'dequeue')
             held.shift();
-        else if (e.operation === 'popAll')
+        else if (e.op === 'popAll')
             held.length = 0;
-        else if (e.operation === 'remove') {
-            const i = held.indexOf(e.content);
+        else {
+            const i = e.text === undefined ? -1 : held.indexOf(e.text);
             held.splice(i < 0 ? 0 : i, 1);
         }
     }
     return held;
 }
-// A prompt: what a turn begins with, as against the answer to a call, a note or Esc.
-function startsTurn(e) {
-    if (e.type !== 'user' || e.isMeta === true)
-        return false;
-    const c = e.message?.content;
-    if (Array.isArray(c) && c.every((b) => b?.type === 'tool_result'))
-        return false;
-    return !texts(c).some((t) => t.startsWith(INTERRUPTED));
-}
-// What an entry says of the turn: that it ended there, that the turn goes on, or nothing.
-function said(e) {
-    if (e.type === 'system')
-        return e.subtype === 'stop_hook_summary' ? 'over' : null;
-    if (e.type === 'queue-operation')
-        return e.operation === 'dequeue' ? 'going' : null;
-    if (e.type === 'assistant')
-        return e.isApiErrorMessage === true ? 'over' : 'going';
-    if (e.type === 'user') {
-        if (e.isMeta === true)
-            return null;
-        return texts(e.message?.content).some((t) => t.startsWith(INTERRUPTED)) ? 'over' : 'going';
-    }
-    return null;
-}
 // Whether the turn the lines end in is over, and when it ended; null when they hold no turn.
 export function lastTurn(lines) {
-    const all = entries(lines, () => true);
+    const all = events(lines, () => true);
     for (let i = all.length - 1; i >= 0; i--) {
-        const s = said(all[i]);
-        if (s === 'going')
+        const s = turnSays(all[i]);
+        if (s === 'starts' || s === 'going')
             return { over: false };
         if (s === 'over') {
-            const at = typeof all[i].timestamp === 'string' ? Date.parse(all[i].timestamp) : NaN;
+            const at = Date.parse(all[i].at ?? '');
             return { over: true, at: Number.isFinite(at) ? at : 0 };
         }
     }
@@ -120,11 +89,21 @@ export function transcriptTail(path) {
             closeSync(fd);
     }
 }
+// The messages pulled back out of Claude's queue into its prompt at the Mac, each with when: from there they are
+// the person's to change, send or drop, so none of them goes on as it was sent.
+function pulledBack(lines) {
+    return events(lines, (l) => l.includes('"popAll"')).flatMap((e) => e.k === 'claude:queue' && e.op === 'popAll' && e.text !== undefined ? [{ text: e.text, at: Date.parse(String(e.at)) }] : []);
+}
 // heldByClaude for a transcript on disk; none when it cannot be read.
 export function heldInTranscript(path) {
     const lines = transcriptTail(path);
     return lines ? heldByClaude(lines) : [];
 }
+// Claude's queue in a transcript on disk: what it holds, and what was pulled back out of it.
+export function queueInTranscript(path) {
+    const lines = transcriptTail(path) ?? [];
+    return { held: heldByClaude(lines), pulled: pulledBack(lines) };
+}
 // lastTurn for a transcript on disk, where a turn that ended with a message still in Claude's own queue goes
 // on with it; null when it cannot be read.
 export function turnInTranscript(path) {

package/dist/server/agents/codex/agent.js

@@ -64,8 +64,12 @@ export class CodexAgent {
     // The threads people had on this Mac, newest first, as the app server lists them: it reads every session file
     // to answer, which takes seconds.
     async listThreads(params) {
-        const { data } = await (await this.link()).request('thread/list', params, LIST_MS);
-        return Array.isArray(data) ? data : [];
+        return (await this.listThreadPage(params)).data;
+    }
+    // One page of threads, and the cursor of the next; null when it is the last.
+    async listThreadPage(params) {
+        const { data, nextCursor } = await (await this.link()).request('thread/list', params, LIST_MS);
+        return { data: Array.isArray(data) ? data : [], next: typeof nextCursor === 'string' && nextCursor ? nextCursor : null };
     }
     // One thread's metadata, read without loading it; undefined when there is no such thread.
     async readThread(threadId) {
@@ -123,6 +127,9 @@ export class CodexAgent {
             throw e;
         }
     }
+    async rename(threadId, name) {
+        await (await this.link()).request('thread/name/set', { threadId, name });
+    }
     close() {
         this.closed = true;
         this.rpc?.close();