workoffdesk 0.0.0-stage → 1.0.0

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

@@ -0,0 +1,254 @@
+import { stripVTControlCharacters } from 'node:util';
+import { isOwnHookCommand } from '../hooks/hooks.js';
+const SUMMARY_MAX = 200;
+const DIFF_LINES_MAX = 300;
+const DIFF_LINE_MAX = 400;
+const RESULT_MAX = 2000;
+// 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) {
+    const pick = (...keys) => keys.map((k) => str(input[k])).find(Boolean);
+    const named = {
+        Bash: () => pick('description', 'command'),
+        Read: () => pick('file_path'),
+        Edit: () => pick('file_path'),
+        Write: () => pick('file_path'),
+        NotebookEdit: () => pick('notebook_path'),
+        Grep: () => pick('pattern'),
+        Glob: () => pick('pattern'),
+        WebFetch: () => pick('url'),
+        WebSearch: () => pick('query'),
+        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);
+}
+// What Claude Code prints after a command for each hook that ran, when the hook is workoffdesk's own.
+const ownHookLine = (line) => {
+    const ran = /^\w+ \[(.*)\] completed successfully$/.exec(line);
+    return ran !== null && isOwnHookCommand(ran[1]);
+};
+// A task TaskCreate made: Claude Code gives it its id only in the result.
+function taskMade(v) {
+    const task = v && typeof v === 'object' ? v.task : null;
+    if (!task || typeof task !== 'object')
+        return null;
+    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.
+function backgroundStarted(v, tool) {
+    const id = v && typeof v === 'object' ? v.backgroundTaskId : null;
+    return typeof id === 'string' ? [{ k: 'bg', id, tool, status: 'running' }] : [];
+}
+// A change to the task list, from what Claude asked for.
+function taskItems(name, input) {
+    if (name === 'TaskUpdate' && typeof input.taskId === 'string') {
+        const item = { k: 'task', id: input.taskId };
+        if (typeof input.subject === 'string')
+            item.subject = input.subject;
+        if (typeof input.status === 'string')
+            item.status = input.status;
+        return [item];
+    }
+    const stopped = name === 'TaskStop' ? input.task_id : name === 'KillShell' || name === 'KillBash' ? input.shell_id : undefined;
+    if (typeof stopped === 'string')
+        return [{ k: 'bg', id: stopped, status: 'killed' }];
+    if (name === 'TodoWrite' && Array.isArray(input.todos)) {
+        const items = input.todos.flatMap((t) => t && typeof t === 'object' && typeof t.content === 'string' && typeof t.status === 'string' ? [{ subject: t.content, status: t.status }] : []);
+        return [{ k: 'todos', items }];
+    }
+    return [];
+}
+// Claude Code records what a file tool changed beside its result, for the record's one result.
+function fileChange(v) {
+    if (!v || typeof v !== 'object')
+        return null;
+    const t = v;
+    if (typeof t.filePath !== 'string' || !t.filePath)
+        return null;
+    const created = t.type === 'create' && typeof t.content === 'string';
+    const hunks = created
+        ? [{ oldStart: 0, newStart: 1, lines: t.content.replace(/\n$/, '').split('\n').map((l) => `+${l}`) }]
+        : (Array.isArray(t.structuredPatch) ? t.structuredPatch : []).flatMap((h) => h && typeof h === 'object' && Array.isArray(h.lines) && h.lines.every((l) => typeof l === 'string')
+            ? [{ oldStart: Number(h.oldStart) || 0, newStart: Number(h.newStart) || 0, lines: h.lines }]
+            : []);
+    const all = hunks.flatMap((h) => h.lines);
+    const added = all.filter((l) => l.startsWith('+')).length;
+    const removed = all.filter((l) => l.startsWith('-')).length;
+    if (!added && !removed)
+        return null;
+    let room = DIFF_LINES_MAX;
+    const kept = hunks
+        .map((h) => {
+        const lines = h.lines.slice(0, Math.max(0, room)).map((l) => clip(l, DIFF_LINE_MAX));
+        room -= lines.length;
+        return { ...h, lines };
+    })
+        .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 }];
+}
+// 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.
+export function sentWords(item) {
+    if (item.k === 'user')
+        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;
+    const status = tagText(text, 'status');
+    const id = tagText(text, 'task-id');
+    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$/;
+function planOf(name, input) {
+    if (name === 'ExitPlanMode')
+        return str(input.plan).trim();
+    if (name === 'Write' && PLAN_FILE.test(str(input.file_path)))
+        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 }] : [];
+}
+// 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 }];
+    }
+    if (r.type === 'assistant')
+        return assistantItems(r, at);
+    return [];
+}

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

@@ -0,0 +1,194 @@
+import { readdir, open, stat } from 'node:fs/promises';
+import { 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.
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+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) {
+    try {
+        return chatItems(JSON.parse(l));
+    }
+    catch {
+        return [];
+    }
+}
+// Each item of a transcript line under a name that stays the same however the file is read: the line's
+// uuid and the item's place in it; a line without one is named by where it starts.
+export function idItems(line, at) {
+    let v;
+    try {
+        v = JSON.parse(line);
+    }
+    catch {
+        return [];
+    }
+    const uuid = v && typeof v === 'object' && typeof v.uuid === 'string' ? v.uuid : `b${at}`;
+    return chatItems(v).map((item, n) => ({ id: `${uuid}:${n}`, item }));
+}
+// The whole lines from byte `from`, each with where it starts, up to maxRead bytes, and where the next
+// read starts. A line still being written is left for the next read.
+export async function linesFrom(path, from, maxRead = MAX_READ) {
+    const fh = await open(path, 'r');
+    try {
+        const size = (await fh.stat()).size;
+        if (from >= size)
+            return { lines: [], next: Math.min(from, size), size };
+        let buf = Buffer.alloc(0);
+        let end = 0;
+        // A line longer than maxRead (a picture pasted into the prompt) is read whole on its own.
+        for (let want = maxRead; !end && buf.length < size - from; want *= 2) {
+            buf = Buffer.alloc(Math.min(size - from, want));
+            await fh.read(buf, 0, buf.length, from);
+            end = buf.lastIndexOf(0x0a) + 1;
+        }
+        const lines = [];
+        for (let s = 0; s < end;) {
+            const e = buf.indexOf(0x0a, s);
+            if (e > s)
+                lines.push({ at: from + s, line: buf.subarray(s, e).toString('utf8') });
+            s = e + 1;
+        }
+        return { lines, next: from + end, size };
+    }
+    finally {
+        await fh.close();
+    }
+}
+// The items added to the transcript since byte `from`, where reading really started (not `from` when it
+// started over: what was read before is void), and where the next read starts. Only whole lines are
+// taken; one still being written is read next time. A first read opens on the last turns (skipped: older
+// ones were left out); a long addition comes in pieces, each ending on a line.
+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 });
+    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);
+        return { items, from, next: from + end, skipped: false };
+    }
+    finally {
+        await fh.close();
+    }
+}
+// The whole lines before byte `end`, newest first, with where each starts. A line cut off at `end`, still
+// being written, is not one of them.
+async function* linesBefore(fh, end, chunk) {
+    let pos = end;
+    let rest = Buffer.alloc(0);
+    let whole = false;
+    for (;;) {
+        if (pos > 0) {
+            const n = Math.min(chunk, pos);
+            pos -= n;
+            const piece = Buffer.alloc(n);
+            await fh.read(piece, 0, n, pos);
+            rest = Buffer.concat([piece, rest]);
+        }
+        if (!whole) {
+            const nl = rest.lastIndexOf(0x0a);
+            if (nl < 0) {
+                if (pos > 0)
+                    continue;
+                return;
+            }
+            rest = rest.subarray(0, nl + 1);
+            whole = true;
+        }
+        // rest ends with the newline of the newest line not given yet.
+        let e = rest.length - 1;
+        while (e >= 0) {
+            const p = e > 0 ? rest.lastIndexOf(0x0a, e - 1) : -1;
+            if (p < 0 && pos > 0)
+                break;
+            yield { start: pos + p + 1, line: rest.subarray(p + 1, e) };
+            e = p;
+        }
+        if (e < 0)
+            return;
+        rest = rest.subarray(0, e + 1);
+    }
+}
+// The last turns before byte `before`, which is where the caller's copy starts: from is where they
+// start, next where they end. Reading stops at a budget, to answer quickly however far apart the
+// turns are, but always goes back at least one line. A file shorter than `before` is read from its end.
+export async function readChatBefore(path, before, o = {}) {
+    const turns = o.turns ?? PAGE_TURNS;
+    const maxRead = o.maxRead ?? MAX_READ;
+    const fh = await open(path, 'r');
+    try {
+        const end = Math.min(before, (await fh.stat()).size);
+        const taken = [];
+        let count = 0;
+        let next;
+        let from;
+        for await (const { start, line } of linesBefore(fh, end, o.chunk ?? CHUNK)) {
+            next ??= start + line.length + 1;
+            if (count >= turns || (from !== undefined && next - start > maxRead))
+                break;
+            const items = lineItems(line.toString('utf8'));
+            taken.push(items);
+            count += items.filter((i) => i.k !== 'result').length;
+            from = start;
+        }
+        from ??= next ?? 0;
+        return { items: taken.reverse().flat(), from, next: next ?? from, skipped: from > 0 };
+    }
+    finally {
+        await fh.close();
+    }
+}
+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) {
+    const size = (await stat(path)).size;
+    const { items } = await readChat(path, Math.max(0, size - tail));
+    const last = items.findLast((i) => i.k === 'text' || (i.k === 'note' && 'event' in i && i.event.e === 'failed'));
+    if (!last)
+        return null;
+    // A turn that ended in an error says so, in Claude Code's own words.
+    if (last.k === 'note')
+        return [...`API Error: ${last.detail ?? ''}`.trim()].slice(0, REPLY_CHARS).join('');
+    if (last.k !== 'text')
+        return null;
+    const plain = last.text
+        .replace(/^```.*$/gm, '')
+        .replace(/^\s{0,3}(#{1,6}|>|[-*+]|\d+[.)])\s+/gm, '')
+        .replace(/\[([^\]]*)\]\([^)]*\)/g, '$1')
+        .replace(/(\*\*|__|`)/g, '')
+        .replace(/\s+/g, ' ')
+        .trim();
+    return plain ? [...plain].slice(0, REPLY_CHARS).join('') : null;
+}
+// Where Claude Code keeps the transcript of a session: <root>/<project folder>/<session id>.jsonl.
+export async function findTranscript(root, sessionId) {
+    if (!UUID.test(sessionId))
+        return null;
+    let dirs;
+    try {
+        dirs = await readdir(root);
+    }
+    catch {
+        return null;
+    }
+    for (const d of dirs) {
+        const p = join(root, d, `${sessionId}.jsonl`);
+        try {
+            if ((await stat(p)).isFile())
+                return p;
+        }
+        catch {
+            // not in this folder
+        }
+    }
+    return null;
+}

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

@@ -0,0 +1,210 @@
+import { open, readdir, readFile, stat } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { basename, join } from 'node:path';
+const HEAD_BYTES = 256 * 1024;
+const TAIL_BYTES = 64 * 1024;
+const TITLE_MAX = 60;
+const LAST_PROMPT_MAX = 200;
+// Up to `limit` of the latest sessions people started, and as many of those programs started, newest
+// first: a busy agent runner does not push a person's sessions off the list.
+// Asked for again while a listing runs (several pages and phones open at once), the one running answers.
+const running = new Map();
+export function listRecentClaudeSessions(root, limit = 50) {
+    const key = `${limit}:${root}`;
+    const now = running.get(key);
+    if (now)
+        return now;
+    const next = listRecent(root, limit).finally(() => running.delete(key));
+    running.set(key, next);
+    return next;
+}
+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 };
+    for (const f of files.slice(0, limit * 6)) {
+        if (count.people >= limit && count.programs >= limit)
+            break;
+        const parsed = await parsedOnce(f);
+        if (!parsed || isScratch(parsed.cwd))
+            continue;
+        const kind = parsed.automated ? 'programs' : 'people';
+        if (count[kind] >= limit)
+            continue;
+        count[kind]++;
+        out.push({ sessionId: basename(f.path, '.jsonl'), ...parsed, lastActivity: Math.round(f.mtimeMs) });
+    }
+    return out;
+}
+// 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(), '/')];
+function isScratch(cwd) {
+    return cwd !== null && SCRATCH_ROOTS.some((r) => cwd.startsWith(r));
+}
+export function listProjectDirs(recent, pinned) {
+    const seen = new Set();
+    const out = [];
+    for (const d of [...pinned, ...recent.map((r) => r.cwd)]) {
+        if (d && !seen.has(d)) {
+            seen.add(d);
+            out.push(d);
+        }
+    }
+    return out;
+}
+async function transcriptFiles(root) {
+    let dirs;
+    try {
+        dirs = await readdir(root);
+    }
+    catch {
+        return [];
+    }
+    const files = [];
+    for (const d of dirs) {
+        let names;
+        try {
+            names = await readdir(join(root, d));
+        }
+        catch {
+            continue;
+        }
+        for (const n of names) {
+            if (!n.endsWith('.jsonl'))
+                continue;
+            const p = join(root, d, n);
+            try {
+                const s = await stat(p);
+                if (s.isFile())
+                    files.push({ path: p, mtimeMs: s.mtimeMs, size: s.size });
+            }
+            catch {
+                // vanished between readdir and stat
+            }
+        }
+    }
+    return files;
+}
+// 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;
+async function parsedOnce(f) {
+    const kept = parsedCache.get(f.path);
+    if (kept && kept.size === f.size && kept.mtimeMs === f.mtimeMs)
+        return kept.parsed;
+    const parsed = await parseTranscript(f.path, f.size).catch(() => null);
+    parsedCache.delete(f.path);
+    parsedCache.set(f.path, { size: f.size, mtimeMs: f.mtimeMs, parsed });
+    for (const old of parsedCache.keys()) {
+        if (parsedCache.size <= PARSED_KEPT)
+            break;
+        parsedCache.delete(old);
+    }
+    return parsed;
+}
+async function parseTranscript(path, size) {
+    const records = await readRecords(path, size);
+    if (!records.length)
+        return null;
+    let cwd = null;
+    let customTitle = null;
+    let aiTitle = null;
+    let firstPrompt = null;
+    let lastPrompt = null;
+    let automated = false;
+    for (const r of records) {
+        if (!cwd && typeof r.cwd === 'string' && r.cwd)
+            cwd = r.cwd;
+        if (r.entrypoint === 'sdk-cli')
+            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 (said)
+            lastPrompt = said;
+        if (!firstPrompt && r.type === 'user')
+            firstPrompt = promptText(r.message?.content);
+    }
+    const title = customTitle ?? aiTitle ?? (firstPrompt ? truncate(firstPrompt) : basename(path, '.jsonl').slice(0, 8));
+    return { cwd, title, lastPrompt: lastPrompt && truncate(lastPrompt, LAST_PROMPT_MAX), automated };
+}
+async function readRecords(path, size) {
+    const fh = await open(path, 'r');
+    try {
+        if (size <= HEAD_BYTES + TAIL_BYTES) {
+            return parseLines((await fh.readFile()).toString('utf8'));
+        }
+        const head = Buffer.alloc(HEAD_BYTES);
+        await fh.read(head, 0, HEAD_BYTES, 0);
+        const tail = Buffer.alloc(TAIL_BYTES);
+        await fh.read(tail, 0, TAIL_BYTES, size - TAIL_BYTES);
+        return [...parseLines(head.toString('utf8')), ...parseLines(tail.toString('utf8'))];
+    }
+    finally {
+        await fh.close();
+    }
+}
+// A line cut by the head/tail window is never valid JSON on its own, so the
+// parse below discards it without special handling.
+function parseLines(text) {
+    const out = [];
+    for (const l of text.split('\n')) {
+        if (!l.startsWith('{'))
+            continue;
+        try {
+            const v = JSON.parse(l);
+            if (v && typeof v === 'object')
+                out.push(v);
+        }
+        catch {
+            // partial or foreign line
+        }
+    }
+    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(' ')
+            : '';
+    // 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();
+    return text && !text.startsWith('<') ? text : null;
+}
+function truncate(s, max = TITLE_MAX) {
+    return [...s].slice(0, max).join('');
+}
+// The conversations Claude Code's background sessions hold (~/.claude/jobs: a folder per session, named by
+// the first eight characters of its conversation, its state.json naming the transcript it follows). One
+// held there must not also be resumed here: two Claudes would write the same conversation.
+export async function heldInBackground(jobsRoot) {
+    let names;
+    try {
+        names = await readdir(jobsRoot);
+    }
+    catch {
+        return () => false;
+    }
+    const followed = new Set();
+    const named = new Set();
+    for (const name of names) {
+        let state;
+        try {
+            state = JSON.parse(await readFile(join(jobsRoot, name, 'state.json'), 'utf8'));
+        }
+        catch {
+            continue;
+        }
+        named.add(name);
+        const path = state && typeof state === 'object' ? state.linkScanPath : undefined;
+        if (typeof path === 'string')
+            followed.add(basename(path, '.jsonl'));
+    }
+    return (sessionId) => followed.has(sessionId) || named.has(sessionId.slice(0, 8));
+}