workoffdesk 1.0.1 → 1.0.2

package/CHANGELOG.md

@@ -1,5 +1,26 @@
 # Changelog
 
+## 1.0.2
+
+The release the iPhone app on the App Store needs: the app tells a Mac older than this to update.
+
+- An iPhone app built for others to install takes its JS updates from one server named at build time, not
+  from the server it is signed in to. The iPhone app can be tried on a Mac it simulates, without a server.
+- Notifications for an iPhone app published for others go through its publisher's relay, sealed on the Mac
+  for that one phone; the relay cannot read them. A server becomes a relay when `apns.json` names the app as
+  `relayTopic`.
+- Every conversation on the Mac is listed, and ended sessions are kept to read. The list can be grouped by
+  project, and a session pinned to the top for every device.
+- Swipe a row to end, delete or rename a session; a new name reaches Claude and Codex too.
+- A session that hits its account's limit can move to another account, now or once free.
+- The command Claude runs in the foreground can be sent to the background from the chat, and its background
+  agents are listed. A sub-agent's work can be followed from the call that started it.
+- A message is held while something is typed at Claude's prompt on the Mac, and a message taken back from
+  Claude's queue on the Mac comes back here.
+- Hold the empty box to talk; a picture pasted into the web composer is attached.
+- The site can be reached at more than one address.
+- The menu bar shows the app's mark, with a bar across it while sessions work.
+
 ## 1.0.1
 
 The first release published from GitHub Actions, with npm provenance.

package/README.md

@@ -1,4 +1,4 @@
-# workoffdesk
+# <img src="https://raw.githubusercontent.com/workoffdesk/workoffdesk/main/apps/web/public/icon.svg" alt="" width="40" align="top"> workoffdesk
 
 **Chat with the Claude Code and Codex sessions on your Mac from your phone.**
 
@@ -8,8 +8,9 @@ English · [简体中文](https://github.com/workoffdesk/workoffdesk/blob/main/R
 
 ## What makes it different
 
-- **No account, no relay of ours.** It is a small web app on your own Mac; your phone reaches it over the
-  path you choose, such as Tailscale, a Cloudflare Tunnel or your own server.
+- **No account, nothing in between.** It is a small web app on your own Mac; your phone reaches it over the
+  path you choose, such as Tailscale, a Cloudflare Tunnel or your own server. Only an iPhone app someone
+  publishes for others has its notifications passed on by the publisher's relay, sealed so it cannot read them.
 - **Sessions outlive the phone.** Each one runs in tmux on the Mac: closing the page, locking the phone or
   restarting the service does not end it.
 - **Leaving the desk, take it with you; back at it, keep going.** A Claude Code conversation running in a
@@ -148,6 +149,7 @@ Each is run as `workoffdesk <command>`.
 | `restart` | Restarts the service. Sessions keep running. |
 | `doctor` | Runs every check, prints the fix for each failure, and exits 1 while anything fails. |
 | `status --json` | The checks, the version, the releases, the address, whether the service runs, and its newest 20 warnings and errors. |
+| `activity --json` | How many sessions are working: a line now and one at each change, until the service stops. The menu bar app reads it. |
 | `claude [--resume <session id>]` | Starts Claude in this folder as a session and joins it; with `--resume`, going on with that conversation. |
 | `codex [--resume <thread id>]` | The same for Codex. |
 | `attach [id]` | Joins a session from this terminal; without an id, lists them to pick one. |

package/dist/build.json

@@ -1 +1 @@
-{"version":"1.0.1","commit":"0c91daa8df475d40277aa688bddd0ed166ec32db","dirty":false}
+{"version":"1.0.2","commit":"f5f5951ce2f9b2ccd30113b782cea86a923e3263","dirty":false}

package/dist/server/agents/claude/screen/background.js

@@ -0,0 +1,7 @@
+// Whether Claude Code offers, under the tool it runs in the foreground, to send it to the background with its
+// default key: a line of its own, the key named twice in tmux, whose prefix takes the first press. Another key
+// bound to it is one not known here, so it is not offered.
+const OFFER = /^\s*\(ctrl\+b(?: ctrl\+b \(twice\))? to run in background\)$/;
+export function canBackground(screen) {
+    return screen.split('\n').some((l) => OFFER.test(l.trimEnd()));
+}

package/dist/server/agents/claude/screen/prompt.js

@@ -21,3 +21,37 @@ const MODE = /(?:⏵⏵|⏸)\s+([a-z][a-z ]*?) on\b/;
 export function modeOn(screen) {
     return MODE.exec(screen)?.[1] ?? null;
 }
+// What is typed at the prompt (❯ at the edge, right under the prompt's rule), or null when nothing is: text
+// there that is all dimmed, if word by word, is Claude's suggestion, example, or hint for its queue.
+// Dim (2) holds until 22 or a reset turns it off, through any other change of style.
+// eslint-disable-next-line no-control-regex -- styles are escape sequences
+const STYLE = /\x1b\[([0-9;]*)m/g;
+function allDimmed(promptLine) {
+    const after = promptLine.slice(promptLine.indexOf('❯') + 1);
+    let dim = false;
+    let plain = '';
+    let from = 0;
+    for (const m of after.matchAll(STYLE)) {
+        if (!dim)
+            plain += after.slice(from, m.index);
+        for (const p of m[1].split(';')) {
+            if (p === '2')
+                dim = true;
+            else if (p === '' || p === '0' || p === '22')
+                dim = false;
+        }
+        from = m.index + m[0].length;
+    }
+    if (!dim)
+        plain += after.slice(from);
+    return !plain.replace(/\u00a0/g, ' ').trim();
+}
+export function typedOn(screen, styled) {
+    const lines = screen.replace(/\n+$/, '').split('\n');
+    const at = lines.findLastIndex((l, i) => l.startsWith('❯') && i > 0 && /^─{10,}/.test(lines[i - 1]));
+    const typed = at < 0 ? '' : lines[at].slice(1).replace(/\u00a0/g, ' ').trim();
+    if (!typed)
+        return null;
+    const promptLine = styled.split('\n').findLast((l) => l.includes('❯'));
+    return promptLine && allDimmed(promptLine) ? null : typed;
+}

package/dist/server/agents/claude/screen/screen.js

@@ -2,12 +2,19 @@ import { readFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { basename, join } from 'node:path';
 import { keysToChoose, keysToTick, parseChoices } from './choices.js';
+import { canBackground } from './background.js';
 import { isCompacting } from './compacting.js';
 import { liveText } from './live.js';
 import { parsePanel } from './panel.js';
-import { modeOn, suggestionOn } from './prompt.js';
+import { modeOn, suggestionOn, typedOn } from './prompt.js';
 // How far above the screen to look for the top edge of a dialog taller than it.
 const PANEL_ABOVE = 200;
+// Ctrl+S, and how long what it puts aside is given to leave the prompt, looked at this often.
+const STASH = '\x13';
+const STASH_SHOWS_MS = 1000;
+const STASH_LOOK_MS = 50;
+// Ctrl+B, Claude Code's key to send the tool at work to the background.
+const BACKGROUND = '\x02';
 // How much of a plan file is sent to be read on the phone.
 const PLAN_MAX = 20_000;
 // Claude Code's TUI in a tmux session, as read off its screen and answered by keys. Sessions are tmux
@@ -31,8 +38,30 @@ export class ClaudeScreen {
         ]);
         const choices = withPlan(parseChoices(screen));
         const panel = parsePanel(screen, above);
-        const live = working && !choices && !panel ? liveText(joined, cols) : null;
-        return { screen: { choices, panel, suggestion: suggestionOn(styled), mode: modeOn(screen), live }, compacting: isCompacting(screen) };
+        const free = working && !choices && !panel;
+        const live = free ? liveText(joined, cols) : null;
+        const background = free && canBackground(joined);
+        return { screen: { choices, panel, suggestion: suggestionOn(styled), mode: modeOn(screen), live, background }, compacting: isCompacting(screen) };
+    }
+    // What is typed at the prompt, or null when nothing is.
+    async typed(name) {
+        const [screen, styled] = await Promise.all([this.tmux.screen(name), this.tmux.screenStyled(name).catch(() => '')]);
+        return typedOn(screen, styled);
+    }
+    // Puts what is typed at the prompt aside with Claude Code's stash (ctrl+s), which it puts back once the
+    // next prompt is sent, so what is sent next goes in on its own. Pressed only over typed text: over an empty
+    // prompt the key brings back what was put aside before. False when it did not go aside.
+    async clearPrompt(name) {
+        if ((await this.typed(name)) === null)
+            return true;
+        await this.tmux.leaveCopyMode(name);
+        await this.tmux.sendRaw(name, STASH);
+        for (let waited = 0; waited < STASH_SHOWS_MS; waited += STASH_LOOK_MS) {
+            await new Promise((r) => setTimeout(r, STASH_LOOK_MS));
+            if ((await this.typed(name)) === null)
+                return true;
+        }
+        return false;
     }
     async choices(name, parse = parseChoices) {
         return parse(await this.tmux.screen(name));
@@ -52,6 +81,16 @@ export class ClaudeScreen {
             await this.tmux.paste(name, text);
         return true;
     }
+    // Sends the tool Claude runs in the foreground to the background with Claude Code's key, if the screen still
+    // offers it; false when it does not (the tool is over, or a dialog has the keyboard). The key goes to the
+    // pane itself, past tmux's prefix, so it is pressed once.
+    async toBackground(name) {
+        if (!(await this.read(name, true)).screen.background)
+            return false;
+        await this.tmux.leaveCopyMode(name);
+        await this.tmux.sendRaw(name, BACKGROUND);
+        return true;
+    }
     // Sends a question that takes several answers with the options at `ticked` ticked, if it is still the
     // one whose options were `labels`.
     async tick(name, ticked, labels) {

package/dist/server/agents/claude/terminals.js

@@ -1,32 +1,87 @@
 import { execFile } from 'node:child_process';
 import { open } from 'node:fs/promises';
-export const busiest = (claudes) => claudes.some((c) => c.status === 'waiting') ? 'waiting' : claudes.some((c) => c.status === 'busy') ? 'busy' : 'idle';
+import { turnInTranscript } from './transcript/turn.js';
+const busiest = (claudes) => claudes.some((c) => c.status === 'waiting') ? 'waiting' : claudes.some((c) => c.status === 'busy') ? 'busy' : 'idle';
+// What a conversation open in these terminals is doing, its transcript read only when Claude Code calls it busy.
+export async function openStatus(claudes, transcript) {
+    const status = busiest(claudes);
+    if (status !== 'busy')
+        return status;
+    const path = await transcript();
+    return path && turnInTranscript(path)?.over ? 'background' : status;
+}
 const LIST_MS = 5_000;
 // How long a Claude told to stop is given to write the rest of its transcript and go: it took under a second.
 const STOP_MS = 10_000;
 const STOP_LOOK_MS = 100;
 const STATUSES = new Set(['idle', 'busy', 'waiting']);
-const run = (bin, args, env) => new Promise((resolve, reject) => execFile(bin, args, { timeout: LIST_MS, maxBuffer: 16 * 1024 * 1024, env }, (err, stdout) => (err ? reject(err) : resolve(String(stdout)))));
+// Claude Code, or ps, did not answer in time: what is open on the Mac cannot be told, which is not that none is.
+export class MacUnanswered extends Error {
+    constructor() {
+        super('the Mac did not say in time which Claude conversations are open in its terminals');
+    }
+}
+const run = (bin, args, env) => new Promise((resolve, reject) => execFile(bin, args, { timeout: LIST_MS, maxBuffer: 16 * 1024 * 1024, env }, (err, stdout) => err ? reject(err.killed ? new MacUnanswered() : err) : resolve(String(stdout))));
+// What a program that answered, but not with a listing, is taken for; one that did not answer stays unanswered.
+const orElse = (value) => (e) => {
+    if (e instanceof MacUnanswered)
+        throw e;
+    return value(e);
+};
+const outOf = (e) => String(e.stdout ?? '');
 // Asked for again while a listing runs, the one running answers.
 const running = new Map();
+const made = new Map();
 // None when Claude Code cannot say (too old for `agents`, not installed): then nothing is known to be open.
-export function listMacClaudes(claudeBin) {
-    const now = running.get(claudeBin);
-    if (now)
-        return now;
+// MacUnanswered when it does not answer in time. recentMs: for what is only shown, one made up to that long ago
+// will do, and is answered at once while a new one is made (listing starts Claude Code, which can take seconds);
+// one not answered then is the last that was.
+export function listMacClaudes(claudeBin, recentMs = 0) {
+    return listed(claudeBin, recentMs).then((all) => all.flatMap(({ name: _, here, ...c }) => (here ? [] : [c])));
+}
+// The conversation and name of a Claude running on this Mac, WorkOffDesk's own included, by its process.
+export async function findMacClaude(claudeBin, pid) {
+    const c = (await listed(claudeBin, 0)).find((a) => a.pid === pid);
+    return c ? { sessionId: c.sessionId, name: c.name } : null;
+}
+function listed(claudeBin, recentMs) {
+    const last = made.get(claudeBin);
+    const listing = running.get(claudeBin) ?? listAgain(claudeBin);
+    if (!recentMs)
+        return listing;
+    if (last && Date.now() - last.at < recentMs)
+        return Promise.resolve(last.claudes);
+    return listing.catch(() => made.get(claudeBin)?.claudes ?? []);
+}
+function listAgain(claudeBin) {
+    const at = Date.now();
     const next = listNow(claudeBin)
-        .catch(() => [])
+        .catch(orElse(() => []))
+        .then((claudes) => {
+        made.set(claudeBin, { at, claudes });
+        return claudes;
+    })
         .finally(() => running.delete(claudeBin));
     running.set(claudeBin, next);
+    // Those answered from the last listing do not wait on this one.
+    next.catch(() => { });
     return next;
 }
 async function listNow(claudeBin) {
     const listings = await Promise.all([...(await configDirs())].map((dir) => run(claudeBin, ['agents', '--json'], dir === undefined ? undefined : { ...process.env, CLAUDE_CONFIG_DIR: dir })
         .then((out) => JSON.parse(out))
-        .catch(() => [])));
+        .catch(orElse(() => []))));
     const listed = listings.flatMap((l) => (Array.isArray(l) ? l : []));
     const found = listed.flatMap((a) => a && a.kind === 'interactive' && Number.isSafeInteger(a.pid) && typeof a.sessionId === 'string' && typeof a.cwd === 'string'
-        ? [{ pid: a.pid, sessionId: a.sessionId, cwd: a.cwd, status: STATUSES.has(a.status) ? a.status : 'busy' }]
+        ? [
+            {
+                pid: a.pid,
+                sessionId: a.sessionId,
+                cwd: a.cwd,
+                status: STATUSES.has(a.status) ? a.status : 'busy',
+                name: typeof a.name === 'string' && a.name ? a.name : null,
+            },
+        ]
         : []);
     // One dir can be named two ways (this server's own, and set by a terminal to the same path).
     const interactive = [...new Map(found.map((a) => [a.pid, a])).values()];
@@ -35,14 +90,14 @@ async function listNow(claudeBin) {
     const procs = await processes(interactive.map((a) => a.pid));
     return interactive.flatMap((a) => {
         const p = procs.get(a.pid);
-        return p && !p.inWorkOffDesk ? [{ ...a, tty: p.tty }] : [];
+        return p ? [{ ...a, tty: p.tty, here: p.inWorkOffDesk }] : [];
     });
 }
 // Where Claude Code keeps who is running: each Claude lists itself in its own config dir, and a terminal can
 // set CLAUDE_CONFIG_DIR while sharing the conversations with the rest. undefined: this server's own.
 async function configDirs() {
     const dirs = new Set([undefined]);
-    const out = await run('/bin/ps', ['-E', '-ww', '-A', '-o', 'command=']).catch((e) => String(e.stdout ?? ''));
+    const out = await run('/bin/ps', ['-E', '-ww', '-A', '-o', 'command=']).catch(orElse(outOf));
     for (const line of out.split('\n')) {
         // Claude Code's own program, or the one npm installs, which node runs.
         if (!/^(\S*\/)?(node\s+(\S*\/)?)?claude(\s|$)/.test(line))
@@ -57,7 +112,7 @@ async function configDirs() {
 // with WORKOFFDESK_SESSION, whichever WorkOffDesk on this Mac started it, and what it starts inherits it.
 // One gone since it was listed is left out.
 async function processes(pids) {
-    const out = await run('/bin/ps', ['-E', '-ww', '-o', 'pid=,tty=,command=', '-p', pids.join(',')]).catch((e) => String(e.stdout ?? ''));
+    const out = await run('/bin/ps', ['-E', '-ww', '-o', 'pid=,tty=,command=', '-p', pids.join(',')]).catch(orElse(outOf));
     const procs = new Map();
     for (const line of out.split('\n')) {
         const [, pid, tty, command] = /^\s*(\d+)\s+(\S+)\s(.*)$/.exec(line) ?? [];

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

@@ -1,25 +1,17 @@
-import { stripVTControlCharacters } from 'node:util';
 import { isOwnHookCommand } from '../hooks/hooks.js';
+import { eventOf, tagText } from './events.js';
+import { unhandled } from '../../events.js';
 const SUMMARY_MAX = 200;
 const DIFF_LINES_MAX = 300;
 const DIFF_LINE_MAX = 400;
 const RESULT_MAX = 2000;
+const INPUT_MAX = 4000;
 // What Claude Code records as the answer of a call it was stopped before running.
 const STOPPED = /^The user doesn't want to (proceed with this tool use|take this action)/;
 const clip = (s, max) => (s.length > max ? `${s.slice(0, max)}…` : s);
 const str = (v) => (typeof v === 'string' ? v : '');
-// As text, without the colours and links a terminal would have drawn from it.
-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(' ');
-}
-export function toolSummary(name, input) {
+// The text a call's summary is of, whole.
+function toolSaid(name, input) {
     const pick = (...keys) => keys.map((k) => str(input[k])).find(Boolean);
     const named = {
         Bash: () => pick('description', 'command'),
@@ -34,8 +26,15 @@ export function toolSummary(name, input) {
         Agent: () => pick('description', 'prompt'),
         Task: () => pick('description', 'prompt'),
     }[name];
-    const s = named?.() ?? Object.values(input).map(str).find(Boolean) ?? '';
-    return clip(s.split('\n')[0], SUMMARY_MAX);
+    return named?.() ?? Object.values(input).map(str).find(Boolean) ?? '';
+}
+export const toolSummary = (name, input) => clip(toolSaid(name, input).split('\n')[0], SUMMARY_MAX);
+// Where what a call was asked is not the text its summary is of.
+const WHOLE = { Bash: 'command', Agent: 'prompt', Task: 'prompt' };
+// What a call was asked to do, whole, when its summary says less.
+function toolInput(name, input, summary) {
+    const whole = str(input[WHOLE[name]]) || toolSaid(name, input);
+    return whole && whole !== summary ? clip(whole, INPUT_MAX) : undefined;
 }
 // What Claude Code prints after a command for each hook that ran, when the hook is workoffdesk's own.
 const ownHookLine = (line) => {
@@ -50,9 +49,11 @@ function taskMade(v) {
     const t = task;
     return typeof t.id === 'string' && typeof t.subject === 'string' ? { k: 'task', id: t.id, subject: t.subject, status: 'pending' } : null;
 }
-// A command Claude ran in the background, or one the user sent there while it ran.
+// A command Claude ran in the background, or one the user sent there while it ran, or an agent it started
+// there; each one's end comes as a task notification with this id.
 function backgroundStarted(v, tool) {
-    const id = v && typeof v === 'object' ? v.backgroundTaskId : null;
+    const r = v && typeof v === 'object' ? v : {};
+    const id = r.status === 'async_launched' ? r.agentId : r.backgroundTaskId;
     return typeof id === 'string' ? [{ k: 'bg', id, tool, status: 'running' }] : [];
 }
 // A change to the task list, from what Claude asked for.
@@ -102,44 +103,20 @@ function fileChange(v) {
         .filter((h) => h.lines.length);
     return { file: t.filePath, added, removed, ...(created ? { created: true } : {}), ...(all.length > DIFF_LINES_MAX ? { cut: true } : {}), hunks: kept };
 }
-function userItems(r, at) {
-    const content = r.message?.content;
-    if (r.isCompactSummary)
-        return [{ k: 'note', event: { e: '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');
-        const diff = results.length === 1 && results[0].is_error !== true ? fileChange(r.toolUseResult) : null;
-        const made = results.length === 1 && results[0].is_error !== true ? taskMade(r.toolUseResult) : null;
-        const shown = results.map((b) => {
-            const text = blocksText(b.content);
-            if (STOPPED.test(text))
-                return { k: 'result', id: b.tool_use_id, text: '', error: false, stopped: true };
-            const item = { k: 'result', id: b.tool_use_id, text: clip(text, RESULT_MAX), error: b.is_error === true };
-            if (diff)
-                item.diff = diff;
-            return Array.isArray(b.content) && b.content.some((c) => c?.type === 'image') ? { ...item, image: true } : item;
-        });
-        const started = results.length === 1 ? backgroundStarted(r.toolUseResult, results[0].tool_use_id) : [];
-        return [...shown, ...(made ? [made] : []), ...started];
-    }
-    const text = blocksText(content).trim();
-    if (!text)
-        return [];
-    if (text.startsWith('[Request interrupted'))
-        return [{ k: 'note', event: { e: 'interrupted' }, retry: true }];
-    const command = /<command-name>([^<]*)<\/command-name>/.exec(text);
-    if (command?.[1].trim() === '/compact')
-        return [];
-    if (command) {
-        const args = /<command-args>([^<]*)<\/command-args>/.exec(text)?.[1].trim();
-        return [{ k: 'note', text: [command[1].trim(), args].filter(Boolean).join(' '), command: true, at }];
-    }
-    const stdout = /^<local-command-std(?:out|err)>([\s\S]*)<\/local-command-std(?:out|err)>$/.exec(text);
-    if (stdout) {
-        const shown = stdout[1].split('\n').filter((l) => !ownHookLine(l)).join('\n').trim();
-        return shown ? [{ k: 'note', text: clip(shown, RESULT_MAX) }] : [];
-    }
-    return [{ k: 'user', text, at }];
+function resultItems(results, detail) {
+    const alone = results.length === 1 && !results[0].error;
+    const diff = alone ? fileChange(detail) : null;
+    const made = alone ? taskMade(detail) : null;
+    const shown = results.map((b) => {
+        if (STOPPED.test(b.text))
+            return { k: 'result', id: b.id, text: '', error: false, stopped: true };
+        const item = { k: 'result', id: b.id, text: clip(b.text, RESULT_MAX), error: b.error };
+        if (diff)
+            item.diff = diff;
+        return b.image ? { ...item, image: true } : item;
+    });
+    const started = results.length === 1 ? backgroundStarted(detail, results[0].id) : [];
+    return [...shown, ...(made ? [made] : []), ...started];
 }
 // The words a message sent to Claude has when the transcript records it as this item: a prompt's, or a
 // command's typed at the prompt. Null for anything a message cannot be.
@@ -148,8 +125,6 @@ export function sentWords(item) {
         return item.text;
     return item.k === 'note' && 'command' in item && item.command ? item.text : null;
 }
-const XML_ENTITIES = { '&amp;': '&', '&lt;': '<', '&gt;': '>', '&quot;': '"', '&apos;': "'" };
-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() ?? '';
 function taskNote(text) {
     const summary = tagText(text, 'summary');
     const what = /^Background command "([\s\S]*)" (?:completed|failed|was stopped)/.exec(summary)?.[1] ?? summary;
@@ -158,34 +133,6 @@ function taskNote(text) {
     const note = { k: 'note', event: { e: 'task', status, what }, detail: summary };
     return id && status ? [note, { k: 'bg', id, status }] : [note];
 }
-// Teammates' messages, which Claude Code records with no sender: it wraps them in this envelope instead.
-// A body that is a JSON object is a status update between agents (idle, shutting down), for Claude alone.
-const TEAMMATES = 'Another Claude session sent a message:\n<teammate-message ';
-function fromTeammates(text) {
-    if (!text.startsWith(TEAMMATES))
-        return null;
-    return [...text.matchAll(/<teammate-message\s[^>]*?teammate_id="([^"]*)"[^>]*>([\s\S]*?)<\/teammate-message>/g)].flatMap(([, from, body]) => {
-        const detail = body.trim();
-        return detail && !/^\{[\s\S]*\}$/.test(detail) ? [{ k: 'note', event: { e: 'peer', from }, detail }] : [];
-    });
-}
-// A prompt that did not come from the user: Claude Code records who sent it. Older versions record
-// nobody, and then the prompt is the user's, unless it is a teammate's message in its envelope.
-function sentByOther(r) {
-    const origin = r.origin && typeof r.origin === 'object' ? r.origin : null;
-    if (!origin)
-        return fromTeammates(blocksText(r.message?.content).trim());
-    if (origin.kind === 'human')
-        return null;
-    if (origin.kind === 'peer')
-        return [{ k: 'note', event: { e: 'peer', from: str(origin.name) }, detail: str(origin.body) }];
-    if (r.isMeta)
-        return [];
-    const text = blocksText(r.message?.content).trim();
-    if (origin.kind === 'task-notification')
-        return taskNote(text);
-    return text ? [{ k: 'note', text: clip(text, RESULT_MAX) }] : [];
-}
 // The plan Claude asks to go ahead with, shown whole rather than as a line: written into Claude Code's
 // plans folder in plan mode, or given to ExitPlanMode itself by older versions.
 const PLAN_FILE = /\/\.claude\/plans\/[^/]+\.md$/;
@@ -196,59 +143,75 @@ function planOf(name, input) {
         return str(input.content).trim();
     return '';
 }
-function assistantItems(r, at) {
-    const content = r.message?.content;
-    if (!Array.isArray(content))
-        return [];
-    const out = [];
-    for (const b of content) {
-        if (b?.type === 'text' && str(b.text).trim())
-            out.push({ k: 'text', text: b.text.trim(), at });
-        if (b?.type === 'tool_use' && typeof b.id === 'string') {
-            const name = str(b.name) || 'Tool';
-            const input = b.input && typeof b.input === 'object' ? b.input : {};
-            const plan = planOf(name, input);
-            out.push({ k: 'tool', id: b.id, name, summary: toolSummary(name, input), at, ...(plan && { plan }) }, ...taskItems(name, input));
-        }
-    }
-    return out;
-}
-// A message the user sent while Claude worked, which Claude took in the middle of its turn: the transcript
-// has it only as this attachment.
-function takenMidTurn(r, at) {
-    const a = r.attachment && typeof r.attachment === 'object' ? r.attachment : null;
-    if (a?.type !== 'queued_command' || a.isMeta)
-        return [];
-    const origin = a.origin && typeof a.origin === 'object' ? a.origin : null;
-    // How a background command ended, taken in mid-turn: only the end is kept, the note comes as its own prompt.
-    if (origin?.kind === 'task-notification' || a.commandMode === 'task-notification')
-        return taskNote(blocksText(a.prompt)).filter((i) => i.k === 'bg');
-    if ((a.commandMode ?? 'prompt') !== 'prompt' || (origin && origin.kind !== 'human'))
-        return [];
-    const text = blocksText(a.prompt).trim();
-    return text ? [{ k: 'user', text, at }] : [];
+function replyItems(blocks, at) {
+    return blocks.flatMap((b) => {
+        if (b.type === 'text')
+            return b.text.trim() ? [{ k: 'text', text: b.text.trim(), at }] : [];
+        const name = b.name || 'Tool';
+        const plan = planOf(name, b.input);
+        const summary = toolSummary(name, b.input);
+        const input = toolInput(name, b.input, summary);
+        return [{ k: 'tool', id: b.id, name, summary, ...(input && { input }), at, ...(plan && { plan }) }, ...taskItems(name, b.input)];
+    });
 }
 // What one transcript record shows in the conversation. Subagents' own turns, Claude's thinking and
 // text injected for Claude alone are not part of it.
 export function chatItems(v) {
-    if (!v || typeof v !== 'object')
-        return [];
-    const r = v;
-    if (r.isSidechain)
-        return [];
-    const at = typeof r.timestamp === 'string' ? r.timestamp : undefined;
-    if (r.type === 'attachment')
-        return takenMidTurn(r, at);
-    if (!r.message || typeof r.message !== 'object')
-        return [];
-    if (r.type === 'user')
-        return sentByOther(r) ?? (r.isMeta ? [] : userItems(r, at));
-    // A reply the API failed to give: what Claude Code wrote in its place says why.
-    if (r.type === 'assistant' && r.isApiErrorMessage) {
-        const event = r.error === 'rate_limit' ? { e: 'failed', limit: true } : { e: 'failed' };
-        return [{ k: 'note', event, detail: clip(blocksText(r.message.content).replace(/^API Error:\s*/, ''), RESULT_MAX), retry: true }];
+    return eventItems(eventOf(v));
+}
+function eventItems(e) {
+    const at = e.at;
+    switch (e.k) {
+        case 'claude:prompt':
+            return e.text ? [{ k: 'user', text: e.text, at }] : [];
+        // A message sent while Claude worked, which it took in the middle of its turn.
+        case 'claude:midTurnPrompt':
+            return e.text ? [{ k: 'user', text: e.text, at }] : [];
+        // How a background command ended, taken in mid-turn: only the end is kept, the note comes as its own prompt.
+        case 'claude:midTurnTaskEnd':
+            return taskNote(e.text).filter((i) => i.k === 'bg');
+        case 'claude:command':
+            return e.local || e.name === '/compact' ? [] : [{ k: 'note', text: [e.name, e.args].filter(Boolean).join(' '), command: true, at }];
+        case 'claude:commandOutput': {
+            if (e.local)
+                return [];
+            const shown = e.text.split('\n').filter((l) => !ownHookLine(l)).join('\n').trim();
+            return shown ? [{ k: 'note', text: clip(shown, RESULT_MAX) }] : [];
+        }
+        case 'claude:shell':
+            return [{ k: 'note', text: `!${e.command}`, command: true, at }];
+        case 'claude:shellOutput':
+            return e.text ? [{ k: 'note', text: clip(e.text, RESULT_MAX) }] : [];
+        case 'claude:results':
+            return resultItems(e.results, e.detail);
+        case 'claude:interrupted':
+            return [{ k: 'note', event: { e: 'interrupted' }, retry: true }];
+        case 'claude:compacted':
+            return [{ k: 'note', event: { e: 'compacted' } }];
+        case 'claude:peer':
+            return [{ k: 'note', event: { e: 'peer', from: e.from, ...(e.pid !== undefined && { pid: e.pid }) }, detail: e.body }];
+        // A body that is a JSON object is a status update between agents (idle, shutting down), for Claude alone.
+        case 'claude:teammates':
+            return e.messages.flatMap((m) => (m.body && !/^\{[\s\S]*\}$/.test(m.body) ? [{ k: 'note', event: { e: 'peer', from: m.from }, detail: m.body }] : []));
+        case 'claude:taskNotification':
+            return taskNote(e.text);
+        case 'claude:fromOther':
+            return e.text ? [{ k: 'note', text: clip(e.text, RESULT_MAX) }] : [];
+        case 'claude:reply':
+            return replyItems(e.blocks, at);
+        // A reply the API failed to give: what Claude Code wrote in its place says why.
+        case 'claude:apiError':
+            return [{ k: 'note', event: e.limit ? { e: 'failed', limit: true } : { e: 'failed' }, detail: clip(e.text.replace(/^API Error:\s*/, ''), RESULT_MAX), retry: true }];
+        case 'claude:noted':
+        case 'claude:compactBoundary':
+        case 'claude:turnOver':
+        case 'claude:queue':
+        case 'claude:title':
+        case 'claude:lastPrompt':
+        case 'claude:sidechain':
+        case 'claude:other':
+            return [];
+        default:
+            return unhandled(e);
     }
-    if (r.type === 'assistant')
-        return assistantItems(r, at);
-    return [];
 }