handmux 0.29.2 → 0.31.0

package/dist/src/agents/codebuddyConversation.js

@@ -0,0 +1,414 @@
+// The CodeBuddy Conversation adapter: the binding between a CodeBuddy session's JSONL log and the shared
+// conversation model. Everything generic is reused — the append-aware reader (transcriptReader), the item
+// model and its safety clipping (conversationProjectionSafety), the pump/Core in agent-runtime/conversation
+// — so this module answers only what is CodeBuddy's: where its logs live, how they parse, and what a
+// delivery or an interrupt means for its pane.
+//
+// The shape mirrors Claude's adapter on purpose: same page/cursor semantics, same live-poll reconciliation
+// (a CodeBuddy session writes its JSONL itself, so there is no push channel to subscribe to), same receipt
+// vocabulary for a send. Two deliberate differences:
+//   - No diff is read from a structured patch: CodeBuddy logs no patch. Its Edit result DOES carry the
+//     provider's own `renderer: {type:'diff'}` plus the call's old/new strings, so a diff item is derived
+//     from those — a file RENDERED as a diff by the provider, never a guess about what changed.
+//   - No history reordering: CodeBuddy appends in display order (Claude needs an adjacency fix for its
+//     compaction scaffold), so the session id alone is the view epoch.
+import { createHash } from 'node:crypto';
+import { promises as fsp } from 'node:fs';
+import path from 'node:path';
+import { createCodeBuddyTranscriptParser } from './codebuddyTranscriptParse.js';
+import { transcriptReader } from '../transcriptReader.js';
+import { codebuddyProjectsDir } from './codebuddy.js';
+import { isSessionUuid } from './scanUtils.js';
+import { clipConversationText as clipped, safeProviderDiffPath, sanitizeToolInputWithMetadata, sanitizeToolResultText, } from './conversationProjectionSafety.js';
+function isRun(target) {
+    return 'runId' in target;
+}
+function inside(root, candidate) {
+    const relative = path.relative(root, candidate);
+    return relative === '' || (!relative.startsWith(`..${path.sep}`) && relative !== '..'
+        && !path.isAbsolute(relative));
+}
+async function safeRoot(root) {
+    try {
+        const resolved = await fsp.realpath(root);
+        return (await fsp.stat(resolved)).isDirectory() ? resolved : null;
+    }
+    catch {
+        return null;
+    }
+}
+async function safeBoundFile(root, sessionId, candidate) {
+    if (!path.isAbsolute(candidate) || path.basename(candidate) !== `${sessionId}.jsonl`)
+        return null;
+    const resolvedRoot = await safeRoot(root);
+    if (!resolvedRoot)
+        return null;
+    try {
+        const parent = await fsp.realpath(path.dirname(candidate));
+        if (!inside(resolvedRoot, parent))
+            return null;
+        try {
+            const resolvedFile = await fsp.realpath(candidate);
+            const stat = await fsp.stat(resolvedFile);
+            return stat.isFile() && inside(resolvedRoot, resolvedFile) ? resolvedFile : null;
+        }
+        catch {
+            // The session can be bound just before CodeBuddy creates its JSONL: the verified parent and the exact
+            // UUID filename still make this a safe empty history, and a later read picks the file up.
+            return path.join(parent, path.basename(candidate));
+        }
+    }
+    catch {
+        return null;
+    }
+}
+// CodeBuddy stores one session per encoded-cwd project directory, exactly like Claude. Discovery scans for
+// the exact UUID filename and rejects ambiguity rather than guessing by cwd or mtime.
+export async function findCodeBuddySessionFile(root, sessionId) {
+    if (!isSessionUuid(sessionId))
+        return null;
+    const resolvedRoot = await safeRoot(root);
+    if (!resolvedRoot)
+        return null;
+    let projects;
+    try {
+        projects = await fsp.readdir(resolvedRoot, { withFileTypes: true });
+    }
+    catch {
+        return null;
+    }
+    const matches = [];
+    for (const project of projects) {
+        if (!project.isDirectory() || project.isSymbolicLink())
+            continue;
+        const candidate = path.join(resolvedRoot, project.name, `${sessionId}.jsonl`);
+        try {
+            const resolved = await fsp.realpath(candidate);
+            if (inside(resolvedRoot, resolved) && (await fsp.stat(resolved)).isFile())
+                matches.push(resolved);
+        }
+        catch { /* not this project */ }
+        if (matches.length > 1)
+            return null;
+    }
+    return matches[0] ?? null;
+}
+function sourceViewId(sessionId) {
+    return `codebuddy-session:${sessionId}`;
+}
+function sourceTime(value) {
+    if (typeof value !== 'string')
+        return undefined;
+    const parsed = Date.parse(value);
+    return Number.isFinite(parsed) ? parsed : undefined;
+}
+function itemBase(message, sessionId, id) {
+    const createdAt = sourceTime(message.ts);
+    return {
+        id,
+        sessionId,
+        status: 'complete',
+        ...(createdAt === undefined ? {} : { sourceCreatedAt: createdAt }),
+    };
+}
+function textItem(message, sessionId, id, role, value) {
+    const output = clipped(value);
+    return {
+        ...itemBase(message, sessionId, id),
+        kind: 'message',
+        role,
+        content: [{ type: 'text', text: output.text }],
+        ...(output.truncated ? {
+            status: 'truncated',
+            truncation: { reason: 'size_limit', originalBytes: output.originalBytes },
+        } : {}),
+    };
+}
+// The call's own old/new strings, in the same +/- line shape Claude's structured patch produces, so the
+// shared diff chip renders it without a provider-specific branch.
+function derivedPatch(oldText, newText) {
+    const lines = [];
+    for (const line of oldText.split('\n'))
+        if (line)
+            lines.push(`-${line}`);
+    for (const line of newText.split('\n'))
+        if (line)
+            lines.push(`+${line}`);
+    return lines.join('\n');
+}
+function editedStrings(input) {
+    if (input === null || typeof input !== 'object' || Array.isArray(input))
+        return null;
+    const fields = input;
+    const oldText = typeof fields.old_string === 'string' ? fields.old_string : null;
+    const newText = typeof fields.new_string === 'string' ? fields.new_string : null;
+    // Only a replacement carries both halves; a Write/create has content only, and inventing the "before"
+    // side of a new file would be a guess, so it stays a plain tool call.
+    if (oldText === null || newText === null)
+        return null;
+    return { oldText, newText };
+}
+function toolItems(message, sessionId, id, tool) {
+    const callId = `${id}:call`;
+    const name = clipped(tool.name || 'tool', 512).text || 'tool';
+    const inputProjection = sanitizeToolInputWithMetadata(tool.input);
+    const input = inputProjection.value;
+    const items = [{
+            ...itemBase(message, sessionId, callId),
+            kind: 'tool_call',
+            callId,
+            name,
+            ...(input === undefined ? {} : { input }),
+            ...(inputProjection.truncated ? {
+                status: 'truncated',
+                truncation: { reason: 'size_limit', originalBytes: inputProjection.originalBytes },
+            } : {}),
+        }];
+    if (tool.result !== null && tool.result.length > 0) {
+        const output = sanitizeToolResultText(tool.result);
+        items.push({
+            ...itemBase(message, sessionId, `${id}:result`),
+            kind: 'tool_result',
+            callId,
+            content: [{ type: 'text', text: output.text }],
+            ...(tool.isError ? { isError: true } : {}),
+            ...(output.truncated ? {
+                status: 'truncated',
+                truncation: { reason: 'size_limit', originalBytes: output.originalBytes },
+            } : {}),
+        });
+    }
+    const edited = editedStrings(tool.input);
+    if (edited && !tool.isError) {
+        const rawPath = tool.input.file_path;
+        const providerPath = safeProviderDiffPath(rawPath);
+        const patch = sanitizeToolResultText(derivedPatch(edited.oldText, edited.newText));
+        const removed = edited.oldText.split('\n').filter((line) => line).length;
+        const added = edited.newText.split('\n').filter((line) => line).length;
+        items.push({
+            ...itemBase(message, sessionId, `${id}:diff`),
+            kind: 'diff',
+            ...(providerPath === undefined ? {} : { path: providerPath }),
+            ...(patch.text ? { patch: patch.text } : {}),
+            summary: `+${added} -${removed}`,
+            ...(patch.truncated ? {
+                status: 'truncated',
+                truncation: { reason: 'size_limit', originalBytes: patch.originalBytes },
+            } : {}),
+        });
+    }
+    return items;
+}
+function projectMessage(message, sessionId, ordinal) {
+    const id = `codebuddy:${message.i}:${ordinal}:${message.type}`;
+    // The parser keeps a public reasoning projection, but the shared model has no place to show it (Claude's
+    // adapter drops thinking for the same reason), so it never becomes an item.
+    if (message.type === 'thinking')
+        return [];
+    if (message.type === 'text' && message.role && typeof message.text === 'string' && message.text) {
+        return [textItem(message, sessionId, id, message.role, message.text)];
+    }
+    if (message.type === 'tool' && message.tool)
+        return toolItems(message, sessionId, id, message.tool);
+    if (message.type === 'compact') {
+        const summary = typeof message.summary === 'string' && message.summary
+            ? clipped(message.summary) : null;
+        const truncated = message.summaryTruncated === true || summary?.truncated === true;
+        const originalBytes = typeof message.summaryOriginalBytes === 'number'
+            ? message.summaryOriginalBytes : summary?.originalBytes;
+        return [{
+                ...itemBase(message, sessionId, id), kind: 'compaction',
+                ...(summary ? { summary: summary.text } : {}),
+                ...(truncated ? {
+                    status: 'truncated',
+                    truncation: { reason: 'size_limit', originalBytes: originalBytes ?? 0 },
+                } : {}),
+            }];
+    }
+    if (message.type === 'slash') {
+        const command = `${message.name ?? '/command'}${message.args ? ` ${message.args}` : ''}`;
+        // /compact begins as the user's own message: keeping that role lets the Core replace the optimistic
+        // local bubble with the canonical occurrence, exactly as Claude's adapter does.
+        if (message.name?.toLowerCase() === '/compact') {
+            return [textItem(message, sessionId, id, 'user', command)];
+        }
+        return [{
+                ...itemBase(message, sessionId, id), kind: 'notice', level: 'info',
+                code: 'slash_command', message: clipped(command, 4096).text,
+            }];
+    }
+    return [];
+}
+export function createCodeBuddyConversationAdapter({ projectsRoot = codebuddyProjectsDir(), sessions = null, reader = transcriptReader, findSessionFile = findCodeBuddySessionFile, control, livePollMs = 750, } = {}) {
+    if (!path.isAbsolute(projectsRoot)) {
+        throw new TypeError('CodeBuddy Conversation adapter requires an absolute projects root');
+    }
+    if (!Number.isFinite(livePollMs) || livePollMs <= 0) {
+        throw new TypeError('CodeBuddy Conversation adapter requires a positive live poll interval');
+    }
+    const boundFiles = new Map();
+    async function fileForSession(sessionId) {
+        const bound = boundFiles.get(sessionId);
+        if (bound)
+            return bound;
+        return findSessionFile(projectsRoot, sessionId);
+    }
+    async function discoverFile(target) {
+        if (!isSessionUuid(target.sessionId))
+            return null;
+        if (!isRun(target))
+            return fileForSession(target.sessionId);
+        const binding = sessions?.paneSession(target.paneId);
+        if (!binding || (binding.agent !== undefined && binding.agent !== null && binding.agent !== 'codebuddy')) {
+            return null;
+        }
+        const bindingId = binding.sessionId
+            ?? (binding.transcriptPath ? path.basename(binding.transcriptPath, '.jsonl') : null);
+        if (bindingId !== target.sessionId)
+            return null;
+        if (!binding.transcriptPath)
+            return fileForSession(target.sessionId);
+        const file = await safeBoundFile(projectsRoot, target.sessionId, binding.transcriptPath);
+        if (file)
+            boundFiles.set(target.sessionId, file);
+        return file;
+    }
+    function project(messages, sessionId) {
+        return messages.flatMap((message, ordinal) => projectMessage(message, sessionId, ordinal));
+    }
+    async function readPage(session, request) {
+        const file = await fileForSession(session.sessionId);
+        const parsed = file ? await reader.read(file, createCodeBuddyTranscriptParser) : [];
+        const all = project(parsed, session.sessionId);
+        let end = all.length;
+        if (request.beforeSourceCursor !== undefined) {
+            if (!/^\d+$/.test(request.beforeSourceCursor))
+                throw new Error('Invalid CodeBuddy source cursor');
+            const cursor = Number(request.beforeSourceCursor);
+            if (!Number.isSafeInteger(cursor))
+                throw new Error('Invalid CodeBuddy source cursor');
+            end = Math.min(cursor, all.length);
+        }
+        const start = Math.max(0, end - request.limit);
+        return {
+            sessionId: session.sessionId,
+            sourceViewId: sourceViewId(session.sessionId),
+            sourceHistoryToken: createHash('sha256').update(JSON.stringify(all)).digest('hex'),
+            items: all.slice(start, end),
+            ...(start > 0 ? { previousSourceCursor: String(start) } : {}),
+            hasMore: start > 0,
+        };
+    }
+    return {
+        apiVersion: 1,
+        async discoverNative(target) {
+            if (target.agentId !== 'codebuddy' || !target.sessionId)
+                return null;
+            const file = await discoverFile(target);
+            if (!file)
+                return null;
+            boundFiles.set(target.sessionId, file);
+            return {
+                session: { agentId: 'codebuddy', sessionId: target.sessionId },
+                ...(isRun(target) ? { run: target } : {}),
+                sourceViewId: sourceViewId(target.sessionId),
+                capabilities: isRun(target) && control ? {
+                    history: true, live: 'settled', sendable: true, send: ['prompt'], interrupt: true,
+                    // Verified live on 2.156.0: a prompt typed while a tool is running is accepted by the editor and
+                    // the TUI reports "Messages to be submitted after next tool call", then submits it into the same
+                    // turn. So an ordinary send does not have to wait for idle.
+                    promptWhileActive: true,
+                } : { history: true, live: 'poll' },
+            };
+        },
+        readNativePage: readPage,
+        ...(control ? {
+            async observeNative(run, sink) {
+                const sessionId = run.ref.sessionId;
+                if (!sessionId)
+                    throw new Error('CodeBuddy Conversation run has no session');
+                const session = { agentId: 'codebuddy', sessionId };
+                const baseline = await readPage(session, { limit: 1 });
+                let sourceSequence = 0;
+                let historyToken = baseline.sourceHistoryToken;
+                let closed = false;
+                let timer;
+                let tail = Promise.resolve();
+                const close = () => {
+                    closed = true;
+                    if (timer)
+                        clearTimeout(timer);
+                    timer = undefined;
+                };
+                const schedule = () => {
+                    if (closed || run.signal.aborted)
+                        return;
+                    timer = setTimeout(() => {
+                        tail = tail.then(async () => {
+                            if (closed || run.signal.aborted)
+                                return;
+                            const next = await readPage(session, { limit: 1 });
+                            if (next.sourceViewId !== baseline.sourceViewId) {
+                                close();
+                                await sink({
+                                    type: 'stream.gap', sourceSequence: ++sourceSequence,
+                                    afterSourceSequence: sourceSequence - 1,
+                                });
+                                return;
+                            }
+                            if (next.sourceHistoryToken !== historyToken) {
+                                historyToken = next.sourceHistoryToken;
+                                await sink({
+                                    type: 'history.committed',
+                                    sourceSequence: ++sourceSequence,
+                                    sourceViewId: next.sourceViewId,
+                                    sourceHistoryToken: next.sourceHistoryToken,
+                                });
+                            }
+                        }).catch(async () => {
+                            if (closed || run.signal.aborted)
+                                return;
+                            await Promise.resolve(sink({
+                                type: 'stream.gap', sourceSequence: ++sourceSequence,
+                                afterSourceSequence: Math.max(0, sourceSequence - 1),
+                            })).catch(close);
+                        }).finally(schedule);
+                    }, livePollMs);
+                    timer.unref?.();
+                };
+                const onAbort = () => close();
+                run.signal.addEventListener('abort', onAbort, { once: true });
+                schedule();
+                return {
+                    checkpoint: { sourceViewId: baseline.sourceViewId, sourceSequence },
+                    close() {
+                        run.signal.removeEventListener('abort', onAbort);
+                        close();
+                    },
+                };
+            },
+            async dispatchPrompt(run, request, guard) {
+                try {
+                    const result = await (guard
+                        ? control.sendPrompt(run.ref.paneId, request.text, guard)
+                        : control.sendPrompt(run.ref.paneId, request.text));
+                    if (result && typeof result === 'object'
+                        && result.nativeMutation === false) {
+                        if (result.reason === 'terminal_draft_conflict') {
+                            return { outcome: 'rejected', nativeMutation: false, reason: 'terminal_draft_conflict' };
+                        }
+                        return { outcome: 'busy', nativeMutation: false };
+                    }
+                    return { outcome: 'accepted' };
+                }
+                catch {
+                    return { outcome: 'unknown', nativeMutation: 'unknown', reason: 'delivery_unconfirmed' };
+                }
+            },
+            async dispatchInterrupt(run) {
+                await control.interrupt(run.ref.paneId);
+                return { status: 'accepted' };
+            },
+        } : {}),
+    };
+}

package/dist/src/agents/codebuddyInteraction.js

@@ -0,0 +1,4 @@
+import { createHookInteractionAdapter } from './hookInteraction.js';
+export function createCodeBuddyInteractionAdapter(control, pollMs = 750, reportHealth = () => { }) {
+    return createHookInteractionAdapter(control, { id: 'codebuddy', label: 'CodeBuddy' }, pollMs, reportHealth);
+}

package/dist/src/agents/codebuddyNativeTail.js

@@ -0,0 +1,206 @@
+// The CodeBuddy out-of-band reconciliation. CodeBuddy fires NO Hook when the user answers a
+// PermissionRequest, so an answered pane keeps its 需要你 gate lit until whatever Hook comes next — for a
+// tool outside the PostToolUse matcher, until the turn ends. Claude closes the same gap from its own session
+// registry (`status: idle|busy|waiting`, which flips back to busy the moment the user answers). CodeBuddy
+// keeps no such status anywhere readable: its registry file carries only a heartbeat, its per-session local
+// HTTP endpoint exposes no session state, and its live event channel is a Centrifugo WebSocket. The one
+// artifact that does move is the session transcript, where the granted tool lands its result record.
+//
+// The verdict is deliberately one-sided: a result record strictly newer than the gate proves the pane's tool
+// ran after the user answered, so the gate is over. Everything else — no transcript, an unparsable file, a
+// result older than the gate, a row that is not a gate, or a tail that happens to hold no result at all —
+// says nothing, leaving the Hook's own state exactly as it was.
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { codebuddyProjectsDir, codebuddySessionsDir } from './codebuddy.js';
+const record = (value) => (value !== null && typeof value === 'object' && !Array.isArray(value) ? value : null);
+// A transcript is append-only and a result is written when it happens, so the newest one is always in the
+// last chunk. A chunk with no result at all (a very large tool output ahead of it) closes nothing.
+const MAX_TAIL_BYTES = 262_144;
+const MAX_CACHED_TRANSCRIPTS = 64;
+// The rows that can latch a gate. Only they are worth reading a transcript for, which keeps this reader at
+// zero cost on a pane that is simply working.
+function isGateRow(src, payload) {
+    return src === 'permreq'
+        || (src === 'notify' && payload.notification_type === 'permission_prompt');
+}
+// The transcript for a gate row. Three AUTHORITATIVE names, in order — never a guess: a path the Hook
+// carried, the session id the Hook carried, then the pid's own registry row. The registry one matters
+// because a Notification payload carries neither a session id nor a transcript path (measured) and it is
+// the row a gate is often latched from; the session-id one matters because a registry row can be stale
+// (observed: a resumed session keeps the pid file's older id), which would otherwise leave the gate unclosed
+// on a pane whose Hook did name its session.
+function transcriptFor(payload, pid, home, locate) {
+    const explicit = payload.transcript_path;
+    if (typeof explicit === 'string' && path.isAbsolute(explicit)
+        && path.basename(explicit).endsWith('.jsonl'))
+        return explicit;
+    const projects = codebuddyProjectsDir(home);
+    const payloadSession = payload.session_id;
+    if (typeof payloadSession === 'string' && payloadSession) {
+        const found = locate(projects, payloadSession);
+        if (found)
+            return found;
+    }
+    if (!Number.isSafeInteger(pid) || Number(pid) <= 0)
+        return null;
+    let registry = null;
+    try {
+        registry = record(JSON.parse(fs.readFileSync(path.join(codebuddySessionsDir(home), `${Number(pid)}.json`), 'utf8')));
+    }
+    catch {
+        return null;
+    }
+    const sessionId = registry?.sessionId;
+    const cwd = registry?.cwd;
+    if (typeof sessionId !== 'string' || !sessionId)
+        return null;
+    // CodeBuddy names a project directory after the cwd with the separating slashes replaced by dashes
+    // (verified: /home/user/x → Users-admin-x, /private/tmp/cb-sim → private-tmp-cb-sim). It is only a
+    // shortcut past the scan — the session UUID is what actually names the file, so a miss costs nothing.
+    if (typeof cwd === 'string' && cwd) {
+        const direct = path.join(projects, cwd.replace(/^\//, '').replace(/\//g, '-'), `${sessionId}.jsonl`);
+        try {
+            if (fs.statSync(direct).isFile())
+                return direct;
+        }
+        catch { /* scan below */ }
+    }
+    return locate(projects, sessionId);
+}
+// The newest tool result timestamp in the transcript's tail, or null when the tail holds none.
+function newestResultAt(file) {
+    let descriptor = null;
+    try {
+        const stat = fs.statSync(file);
+        if (!stat.isFile() || stat.size === 0)
+            return null;
+        const length = Math.min(stat.size, MAX_TAIL_BYTES);
+        descriptor = fs.openSync(file, 'r');
+        const buffer = Buffer.alloc(length);
+        fs.readSync(descriptor, buffer, 0, length, stat.size - length);
+        const lines = buffer.toString('utf8').split('\n');
+        // A read that started mid-file begins with a fragment of a line: it cannot parse, but drop it anyway so
+        // a truncated record can never be mistaken for one.
+        if (stat.size > length)
+            lines.shift();
+        let newest = null;
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            let row = null;
+            try {
+                row = record(JSON.parse(trimmed));
+            }
+            catch {
+                continue;
+            } // a half-written last line
+            if (!row || row.type !== 'function_call_result')
+                continue;
+            const timestamp = row.timestamp;
+            if (typeof timestamp !== 'number' || !Number.isFinite(timestamp))
+                continue;
+            if (newest === null || timestamp > newest)
+                newest = timestamp;
+        }
+        return newest;
+    }
+    catch {
+        return null;
+    }
+    finally {
+        if (descriptor !== null) {
+            try {
+                fs.closeSync(descriptor);
+            }
+            catch { /* already closed */ }
+        }
+    }
+}
+export class CodeBuddyNativeTailReader {
+    #home;
+    // Keyed by transcript file and bounded: an unchanged file costs one `stat`, and the gate rows that get
+    // here are few. `retain` is deliberately a no-op — the cache is not keyed by session, and the rows that
+    // need it (a gate latched from a Notification) carry no session id to retain it by.
+    #tails = new Map();
+    // Memoized `<sessionId>.jsonl` lookups: a session's path never moves, and the walk only ever runs for a
+    // session a gate actually named.
+    #paths = new Map();
+    constructor({ home = os.homedir() } = {}) {
+        this.#home = home;
+    }
+    read(payload, after, now, process, src) {
+        const body = record(payload) ?? {};
+        if (!isGateRow(String(src ?? ''), body))
+            return {};
+        const file = transcriptFor(body, process?.pid, this.#home, (projects, sessionId) => this.#locate(projects, sessionId));
+        if (!file)
+            return {};
+        const at = this.#resultAt(file);
+        // Strictly after the gate, and never in the future: a result from before the request cannot close it,
+        // and a clock that ran away must not either.
+        if (at === null || at <= after || at > now)
+            return {};
+        const sessionId = typeof body.session_id === 'string' ? body.session_id : '';
+        return {
+            status: 'busy',
+            statusEventId: `codebuddy-native:${sessionId}:${process?.pid ?? 0}:${at}`,
+        };
+    }
+    retain() { }
+    clear() {
+        this.#tails.clear();
+        this.#paths.clear();
+    }
+    #locate(projects, sessionId) {
+        const key = `${projects}\0${sessionId}`;
+        const cached = this.#paths.get(key);
+        if (cached !== undefined)
+            return cached;
+        let found = null;
+        try {
+            for (const entry of fs.readdirSync(projects)) {
+                const candidate = path.join(projects, entry, `${sessionId}.jsonl`);
+                try {
+                    if (fs.statSync(candidate).isFile()) {
+                        found = candidate;
+                        break;
+                    }
+                }
+                catch { /* next entry */ }
+            }
+        }
+        catch { /* no projects directory */ }
+        this.#paths.delete(key);
+        this.#paths.set(key, found);
+        if (this.#paths.size > MAX_CACHED_TRANSCRIPTS) {
+            this.#paths.delete(this.#paths.keys().next().value);
+        }
+        return found;
+    }
+    #resultAt(file) {
+        let fingerprint;
+        try {
+            const stat = fs.statSync(file);
+            if (!stat.isFile())
+                return null;
+            fingerprint = [stat.dev, stat.ino, stat.size, stat.mtimeMs].join(':');
+        }
+        catch {
+            this.#tails.delete(file);
+            return null;
+        }
+        const cached = this.#tails.get(file);
+        if (cached?.fingerprint === fingerprint)
+            return cached.at;
+        const at = newestResultAt(file);
+        this.#tails.delete(file);
+        this.#tails.set(file, { fingerprint, at });
+        if (this.#tails.size > MAX_CACHED_TRANSCRIPTS) {
+            this.#tails.delete(this.#tails.keys().next().value);
+        }
+        return at;
+    }
+}