@oqura/wisdom 0.0.0-stage → 0.3.1-beta.0

package/dist/src/client.js

@@ -0,0 +1,116 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { fileURLToPath } from 'node:url';
+import { spawn, spawnSync } from 'node:child_process';
+import { CAPTURE_API } from './daemon.js';
+import { spoolDir } from './paths.js';
+import { handoffSchema } from './schema.js';
+export function connectionAt(dataDir) {
+    const file = path.join(dataDir, 'daemon.json');
+    if (!fs.existsSync(file))
+        throw new Error('Wisdom daemon is not running. Run: wisdom daemon start');
+    return JSON.parse(fs.readFileSync(file, 'utf8'));
+}
+export async function call(connection, route, input, timeoutMs = 30000) {
+    let response;
+    try {
+        response = await fetch(connection.url + route, {
+            method: input === undefined ? 'GET' : 'POST',
+            headers: { Authorization: `Bearer ${connection.token}`, 'Content-Type': 'application/json' },
+            body: input === undefined ? undefined : JSON.stringify(input),
+            signal: AbortSignal.timeout(timeoutMs)
+        });
+    }
+    catch (error) {
+        if (error?.name === 'TimeoutError')
+            throw error;
+        throw new Error(`Wisdom daemon is not answering at ${connection.url}. Run: wisdom daemon start`);
+    }
+    const result = await response.json();
+    if (!response.ok)
+        throw new Error(result.error ?? `Daemon returned HTTP ${response.status}`);
+    return result;
+}
+/** The handoff `wisdom handoff` set on this harness process, if any. A value that does not
+ * parse is ignored: recording never depends on it.
+ */
+export function handoffFromEnv(env = process.env) {
+    try {
+        return env.WISDOM_HANDOFF ? { handoff: handoffSchema.parse(JSON.parse(env.WISDOM_HANDOFF)) } : {};
+    }
+    catch {
+        return {};
+    }
+}
+/** How every hook reports. Live when the daemon answers; otherwise the event is kept in
+ * the spool and the daemon is started, so nothing waits on Wisdom and nothing is lost.
+ * A spooled event that was in fact recorded is recognized by its observation ID.
+ */
+export async function deliver(dataDir, event, timeoutMs = 10000) {
+    try {
+        await call(connectionAt(dataDir), '/observe', event, timeoutMs);
+        return {};
+    }
+    catch (error) {
+        spool(dataDir, event);
+        await ensureDaemon(dataDir).catch(() => { });
+        return { spooled: error instanceof Error ? error.message : String(error) };
+    }
+}
+/** One file per event, named so that a session's events sort in the order they were kept. */
+export function spool(dataDir, event) {
+    const session = /^[A-Za-z0-9_-]+$/.test(event.observation.sessionId) ? event.observation.sessionId : '_unnamed';
+    const folder = path.join(spoolDir(dataDir), event.harness, session);
+    fs.mkdirSync(folder, { recursive: true });
+    const file = path.join(folder, `${String(Date.now()).padStart(15, '0')}-${process.hrtime.bigint()}-${randomUUID()}`);
+    fs.writeFileSync(file + '.tmp', JSON.stringify({ ...event, late: { spooledAt: new Date().toISOString() } }));
+    fs.renameSync(file + '.tmp', file + '.json');
+}
+/** Start the daemon so it outlives whatever started it. On Windows a child of Node inherits
+ * every inheritable handle, including a hook's output pipe: Codex then waits for that pipe
+ * until its hook timeout, and kills the child. Measured with real Codex hooks on 0.164:
+ * `spawn` and `cmd /c start` hang and die; `Start-Process` returns at once and survives.
+ */
+function startDetached(args, logFile) {
+    if (process.platform === 'win32') {
+        const line = [process.execPath, ...args].map(arg => `"${arg}"`).join(' ') + ` >> "${logFile}" 2>&1`;
+        const script = `Start-Process -WindowStyle Hidden -FilePath $env:ComSpec -ArgumentList '/d /s /c "${line.replaceAll("'", "''")}"'`;
+        const started = spawnSync('powershell.exe', ['-NoProfile', '-NonInteractive', '-EncodedCommand', Buffer.from(script, 'utf16le').toString('base64')], { windowsHide: true, stdio: ['ignore', 'pipe', 'pipe'], encoding: 'utf8' });
+        if (started.status !== 0)
+            throw new Error(`Could not start Wisdom's daemon (${started.stderr || started.error}). A sandboxed agent may not be allowed to; run wisdom daemon start outside the sandbox.`);
+        return;
+    }
+    const log = fs.openSync(logFile, 'a');
+    spawn(process.execPath, args, { detached: true, stdio: ['ignore', log, log] }).unref();
+    fs.closeSync(log);
+}
+export async function ensureDaemon(dataDir, port, dashboard = true) {
+    const connect = async () => {
+        try {
+            const connection = connectionAt(dataDir);
+            return { connection, health: await call(connection, '/health') };
+        }
+        catch {
+            return undefined;
+        }
+    };
+    const existing = await connect();
+    if (existing) {
+        if (existing.health.captureApi !== CAPTURE_API)
+            throw new Error(`The running Wisdom daemon (PID ${existing.connection.pid}) is from an older build. `
+                + 'Stop it with `wisdom daemon stop` (any active recording becomes interrupted), then retry.');
+        return existing.connection;
+    }
+    fs.mkdirSync(dataDir, { recursive: true });
+    startDetached([fileURLToPath(new URL('./cli.js', import.meta.url)), 'daemon', 'run', '--data', dataDir,
+        ...(port === undefined ? [] : ['--port', String(port)]), ...(dashboard ? [] : ['--no-dashboard'])], path.join(dataDir, 'daemon.log'));
+    for (let attempt = 0; attempt < 100; attempt++) {
+        const started = await connect();
+        if (started)
+            return started.connection;
+        await new Promise(resolve => setTimeout(resolve, 100));
+    }
+    throw new Error(`Daemon did not start. Read ${path.join(dataDir, 'daemon.log')}`);
+}
+//# sourceMappingURL=client.js.map

package/dist/src/clone.js

@@ -0,0 +1,72 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { call } from './client.js';
+import { adapter, userHome } from './harnesses/index.js';
+import { hookState } from './harnesses/launch.js';
+import { moveFolder } from './harnesses/types.js';
+import { hash } from './ledger.js';
+import { cloneNote, harnessHome } from './paths.js';
+/** Recorded files whose content on disk is not what the session last recorded. */
+export function differingFiles(cwd, changes) {
+    return changes.filter(({ path: file, afterHash }) => {
+        const target = path.join(cwd, file);
+        if (afterHash === null)
+            return fs.existsSync(target);
+        try {
+            return hash(fs.readFileSync(target)) !== afterHash;
+        }
+        catch {
+            return true;
+        }
+    }).map(change => change.path);
+}
+/** A session's transcript as a new session's: every line rewritten by the harness's adapter
+ * to name the new session and folder. A line that is not JSON is kept as it is.
+ */
+export function cloneTranscript(harness, text, clone) {
+    const move = moveFolder(clone.fromFolder, clone.toFolder);
+    return text.split('\n').map(line => {
+        if (!line.trim())
+            return line;
+        try {
+            return JSON.stringify(adapter(harness).cloneLine(JSON.parse(line), { from: clone.from, sessionId: clone.sessionId, move }));
+        }
+        catch {
+            return line;
+        }
+    }).join('\n');
+}
+/** Copy a session, this project's own or a shared one, into a new session of the same harness
+ * in this project. A clone is always a new session: it takes a fresh ID and refuses one that is
+ * already in use, so it can never overwrite or disturb another session. The note is written
+ * before the transcript, so the daemon never sees the copy without knowing what it is.
+ */
+export async function planClone(connection, dataDir, ref, cwd, now = new Date()) {
+    const source = await call(connection, '/view', { view: 'transcript', capture: ref });
+    const { manifest } = source;
+    if (!source.file || !source.bytes)
+        throw new Error(`${manifest.captureId} has no copy of its harness transcript, so it cannot be cloned. Read it instead, or hand off from it.`);
+    const harness = adapter(manifest.harness);
+    // A connected project runs the harness in the person's own home, so the copy goes there.
+    const place = hookState(dataDir, manifest.harness, 'project') === 'none' ? 'home' : 'project';
+    const home = place === 'project' ? userHome(manifest.harness) : harnessHome(dataDir, manifest.harness);
+    const sessionId = randomUUID();
+    const file = harness.sessionFile(home, sessionId, cwd, now);
+    const note = cloneNote(dataDir, sessionId);
+    const taken = fs.existsSync(file) || fs.existsSync(note) || harness.sessionFiles(home).some(existing => path.basename(existing).includes(sessionId))
+        || await call(connection, '/resolve', { session: sessionId }).then(() => true, () => false);
+    if (taken)
+        throw new Error(`Session ID ${sessionId} is already in use, so nothing was cloned. Run the command again.`);
+    const text = fs.readFileSync(source.file).subarray(0, source.bytes).toString('utf8');
+    const copy = cloneTranscript(manifest.harness, text, { from: manifest.sessionId, sessionId, fromFolder: manifest.workspaceRoot, toFolder: cwd });
+    fs.mkdirSync(path.dirname(note), { recursive: true });
+    const written = { from: manifest.captureId, fromHarness: manifest.harness, version: source.readVersion, turns: source.turns,
+        bytes: Buffer.byteLength(copy), createdAt: now.toISOString() };
+    fs.writeFileSync(note, JSON.stringify(written, null, 2) + '\n', { flag: 'wx' });
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, copy, { flag: 'wx' });
+    const [command, ...args] = harness.resume(sessionId);
+    return { command: command, place, args, cwd, sessionId, file, source, differing: differingFiles(cwd, source.changes) };
+}
+//# sourceMappingURL=clone.js.map

package/dist/src/connect.js

@@ -0,0 +1,87 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { execFileSync } from 'node:child_process';
+import { writeJson } from './ledger.js';
+import { connectedFile, readConnected } from './paths.js';
+import { userHome } from './harnesses/index.js';
+import { hookState, installSkill, removeSkill, settingsFile, settingsFiles } from './harnesses/launch.js';
+import { connectClaudeCode, disconnectClaudeCode } from './harnesses/claude-code/launch.js';
+import { connectCodex, disconnectCodex } from './harnesses/codex/launch.js';
+import { connectPi, disconnectPi } from './harnesses/pi/launch.js';
+const connectors = {
+    'claude-code': { connect: connectClaudeCode, disconnect: disconnectClaudeCode },
+    codex: { connect: connectCodex, disconnect: disconnectCodex },
+    pi: { connect: connectPi, disconnect: disconnectPi },
+};
+const BEGIN = '# wisdom connect: local settings naming this machine (wisdom disconnect removes this block)';
+const END = '# end wisdom connect';
+/** Record these harnesses with the person's own login: Wisdom's hook or extension in the
+ * project's own settings, and the reading skill beside them. Nothing reaches git: the files
+ * go in `.git/info/exclude`, and a settings file git already tracks is left alone.
+ */
+export function connect(dataDir, harnesses, now = new Date()) {
+    const project = path.dirname(path.resolve(dataDir));
+    const tracked = harnesses.map(harness => settingsFile(dataDir, harness, 'project')).filter(file => trackedByGit(project, file));
+    const connected = harnesses.filter(harness => !tracked.includes(settingsFile(dataDir, harness, 'project')));
+    const files = connected.map(harness => connectors[harness].connect(dataDir));
+    for (const folder of new Set(connected.map(harness => settingsFiles.project[harness].skills))) {
+        installSkill(path.join(project, folder));
+        files.push(path.join(project, folder, 'skills', 'wisdom-ledger'));
+    }
+    const before = readConnected(dataDir);
+    const after = { ...before };
+    for (const harness of connected)
+        after[harness] = { since: before[harness]?.since ?? now.toISOString(), home: userHome(harness) };
+    writeJson(connectedFile(dataDir), after);
+    const excluded = setExcluded(project, files.map(file => '/' + path.relative(project, file).replaceAll('\\', '/') + (fs.statSync(file).isDirectory() ? '/' : '')));
+    return { connected, tracked, files, excluded };
+}
+/** Take Wisdom out of the project's settings and skill folders, exactly what connect added.
+ * Recordings are kept.
+ */
+export function disconnect(dataDir) {
+    const project = path.dirname(path.resolve(dataDir));
+    const was = Object.keys(readConnected(dataDir));
+    for (const harness of Object.keys(connectors)) {
+        // A file that does not name Wisdom is not touched, not even rewritten.
+        if (hookState(dataDir, harness, 'project') !== 'none' && !trackedByGit(project, settingsFile(dataDir, harness, 'project')))
+            connectors[harness].disconnect(dataDir);
+    }
+    for (const folder of new Set(Object.values(settingsFiles.project).map(files => files.skills)))
+        removeSkill(path.join(project, folder));
+    fs.rmSync(connectedFile(dataDir), { force: true });
+    setExcluded(project, []);
+    return was;
+}
+/** Whether git tracks a file. Without git, or outside a repository, nothing is tracked. */
+function trackedByGit(project, file) {
+    try {
+        execFileSync('git', ['ls-files', '--error-unmatch', '--', path.relative(project, file).replaceAll('\\', '/')], { cwd: project, windowsHide: true, stdio: 'ignore' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Replace Wisdom's block in the repository's own `info/exclude` (git's per-clone ignore file,
+ * never committed) with these patterns, or remove it. Without a repository there is nothing to do.
+ */
+function setExcluded(project, patterns) {
+    let file;
+    try {
+        file = path.resolve(project, execFileSync('git', ['rev-parse', '--git-path', 'info/exclude'], { cwd: project, windowsHide: true, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim());
+    }
+    catch {
+        return false;
+    }
+    const text = fs.existsSync(file) ? fs.readFileSync(file, 'utf8') : '';
+    const kept = text.replace(new RegExp(`${escape(BEGIN)}[\\s\\S]*?${escape(END)}\\r?\\n?`), '');
+    const block = patterns.length ? `${kept && !kept.endsWith('\n') ? '\n' : ''}${BEGIN}\n${patterns.join('\n')}\n${END}\n` : '';
+    if (kept + block === text)
+        return true;
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, kept + block);
+    return true;
+}
+const escape = (text) => text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+//# sourceMappingURL=connect.js.map

package/dist/src/content.js

@@ -0,0 +1,27 @@
+/** Shared surface rules. Detailed views project text; clean views can also retain
+ * images and other non-text blocks without treating thinking as surface text.
+ */
+export function messageContent(value, surface = false) {
+    if (!Array.isArray(value))
+        return value ?? null;
+    const blocks = surface ? value.filter(b => !['thinking', 'toolCall', 'reasoning'].includes(b?.type)) : value;
+    if (blocks.every(b => b?.type === 'text' && typeof b.text === 'string'))
+        return blocks.map(b => b.text).join('\n');
+    return blocks;
+}
+export function surfaceText(value) {
+    const message = value?.message ?? value;
+    if (typeof message?.text === 'string')
+        return message.text;
+    const content = messageContent(message?.content, true);
+    return typeof content === 'string' ? content : Array.isArray(content)
+        ? content.filter(block => block?.type === 'text').map(block => block.text).join('\n') : '';
+}
+// The single definition of conversation surface: a new role cannot be a message in one view only.
+export const surfaceRoles = ['user', 'assistant'];
+export function isSurfaceRecord(record) {
+    const surfaceRole = surfaceRoles.includes(record.role ?? '');
+    return record.type === 'input' || record.type === 'message' && (record.role === undefined || surfaceRole)
+        || record.type === 'source_record' && surfaceRole;
+}
+//# sourceMappingURL=content.js.map

package/dist/src/conversation.js

@@ -0,0 +1,254 @@
+import { EvidenceReader, evidenceVersion } from './evidence.js';
+import { nativeMessage } from './harnesses/index.js';
+import { messageContent } from './content.js';
+import { estimateCost } from './prices.js';
+/** A tool result without its transport envelope. Native message envelopes carry provider
+ * metadata; hook result bodies keep their meaningful extra fields (details, structuredContent).
+ */
+export function cleanOutput(body) {
+    if (!body || typeof body !== 'object' || Array.isArray(body))
+        return body ?? null;
+    if (body.message || body.role === 'toolResult')
+        return messageContent((body.message ?? body).content);
+    const { content: blocks, ...extra } = body;
+    const text = messageContent(blocks);
+    const structured = extra.structuredContent;
+    // Pi's shell result repeats stdout inside a timing/exit-status envelope. Flatten only this
+    // recognized successful, untruncated duplicate; anything else keeps its fields.
+    if (structured && structured.output === text && structured.truncated === false && structured.exit_code === 0
+        && Object.keys(structured).every(k => ['output', 'truncated', 'exit_code', 'wall_time_seconds'].includes(k))) {
+        delete extra.structuredContent;
+    }
+    for (const key of Object.keys(extra)) {
+        if (extra[key] === null || typeof extra[key] === 'object' && !Object.keys(extra[key]).length)
+            delete extra[key];
+    }
+    if (!Object.keys(extra).length && blocks !== undefined)
+        return text;
+    return blocks === undefined ? extra : { content: text, ...extra };
+}
+/** Which of two results to show for a call. One that says how the call ended beats one that
+ * does not; otherwise a hook result is preferred over one established from the transcript.
+ */
+export function betterResult(prior, next) {
+    if (!prior)
+        return true;
+    if (typeof prior.isError === 'boolean' !== (typeof next.isError === 'boolean'))
+        return typeof next.isError === 'boolean';
+    return !!prior.resultBasis || !next.resultBasis;
+}
+const turnTypes = ['input', 'source_record', 'message', 'tool_started', 'tool_finished', 'file_change', 'subagent_started', 'subagent_stopped', 'agent_settled'];
+/** One request as a conversation turn: the prompt, then thinking, replies, tool calls
+ * (input, output, file changes) and subagents in recorded order. Native transcript
+ * lines are read through the harness adapter, so the shape is the same for every
+ * harness. Only recorded links place an item; nothing is inferred.
+ */
+export function conversation(captures, request) {
+    const version = evidenceVersion(captures, request.readVersion);
+    const ledger = captures.get(request.captureId);
+    const harness = ledger.manifest.harness;
+    const db = captures.database;
+    const prompt = db.records('capture_id=? AND id=? AND type=? AND revision<=?', [request.captureId, request.requestId, 'input', version])[0];
+    if (!prompt)
+        throw new Error('Request not found at this readVersion');
+    const reader = new EvidenceReader(captures);
+    const issues = [];
+    const clip = (value, recordId) => {
+        if (value === undefined || value === null || value === '')
+            return undefined;
+        const text = typeof value === 'string' ? value : JSON.stringify(value, null, 2);
+        const limit = request.maxChars;
+        return limit === undefined || text.length <= limit ? { text } : { text: text.slice(0, limit), truncated: true, totalChars: text.length, recordId };
+    };
+    const json = (record) => {
+        try {
+            const raw = reader.read(record, 'data');
+            return raw === undefined ? undefined : JSON.parse(raw);
+        }
+        catch (error) {
+            issues.push({ id: record.id, reason: String(error) });
+            return undefined;
+        }
+    };
+    const types = turnTypes.map(() => '?').join(',');
+    let records = db.records(`capture_id=? AND revision<=? AND request_id=? AND type IN (${types})`, [request.captureId, version, prompt.id, ...turnTypes]);
+    // Subagents started during this turn bring their own records, wherever they are linked.
+    const agents = new Set();
+    for (const record of records) {
+        if (record.childAgentId)
+            agents.add(record.childAgentId);
+        if (record.agentId && !record.internalAgent)
+            agents.add(record.agentId);
+    }
+    if (agents.size) {
+        const ids = [...agents];
+        const known = new Set(records.map(r => r.id));
+        records = records.concat(db.records(`capture_id=? AND revision<=? AND type IN (${types}) AND json_extract(body,'$.agentId') IN (${ids.map(() => '?').join(',')})`, [request.captureId, version, ...turnTypes, ...ids]).filter(r => !known.has(r.id)));
+    }
+    // File changes link by call ID; a subagent's changes may sit under its own request.
+    const callIds = [...new Set(records.filter(r => r.type === 'tool_started' && r.toolCallId).map(r => r.toolCallId))];
+    if (callIds.length) {
+        const known = new Set(records.map(r => r.id));
+        records = records.concat(db.records(`capture_id=? AND revision<=? AND type='file_change' AND tool_call_id IN (${callIds.map(() => '?').join(',')})`, [request.captureId, version, ...callIds]).filter(r => !known.has(r.id)));
+    }
+    records = records.filter(r => !r.internalAgent && r.id !== prompt.id);
+    const at = (r) => r.sourceTimestamp ?? r.observedAt;
+    records.sort((a, b) => at(a).localeCompare(at(b)) || a.seq - b.seq);
+    const finishes = new Map();
+    for (const r of records)
+        if (r.type === 'tool_finished' && r.toolCallId) {
+            const prior = finishes.get(r.toolCallId);
+            if (betterResult(prior, r))
+                finishes.set(r.toolCallId, r);
+        }
+    const nativeResults = new Map();
+    const nativeOutcomes = new Map();
+    const hookTools = new Set(records.filter(r => r.type === 'tool_started' && r.toolCallId).map(r => r.toolCallId));
+    const buckets = new Map(); // '' is the main agent
+    const bucket = (agentId) => buckets.get(agentId ?? '') ?? buckets.set(agentId ?? '', []).get(agentId ?? '');
+    const tools = new Map();
+    const reports = new Map();
+    let settled;
+    const output = (finish) => {
+        if (!finish)
+            return undefined;
+        if (finish.resultBasis)
+            return clip(nativeResults.get(finish.toolCallId), finish.id);
+        const body = json(finish);
+        return clip(cleanOutput(body?.response ?? body?.error ?? body), finish.id);
+    };
+    const status = (finish) => !finish ? 'pending' : finish.isError === true ? 'error' : finish.isError === false ? 'ok' : 'recorded';
+    for (const record of records) {
+        if (record.type === 'source_record' && record.role === 'toolResult' && record.toolCallId) {
+            const message = nativeMessage(harness, reader.read(record, 'data') ?? 'null', record.toolCallId);
+            nativeResults.set(record.toolCallId, cleanOutput(message?.content));
+            if (typeof record.isError === 'boolean')
+                nativeOutcomes.set(record.toolCallId, record.isError);
+        }
+    }
+    for (const record of records) {
+        if (record.type === 'tool_started' && record.toolCallId) {
+            const finish = finishes.get(record.toolCallId);
+            const data = json(record);
+            const item = { kind: 'tool', id: record.id, at: at(record), toolCallId: record.toolCallId, name: record.toolName ?? 'tool',
+                agentId: record.agentId, input: clip(data?.input, record.id), output: output(finish), status: status(finish),
+                resultBasis: finish?.resultBasis, durationMs: finish ? json(finish)?.durationMs : undefined, changes: [] };
+            tools.set(record.toolCallId, item);
+            bucket(record.agentId).push(item);
+        }
+        else if (record.type === 'file_change') {
+            const change = { kind: 'change', id: record.id, at: at(record), path: record.path, operation: record.operation,
+                attribution: record.attribution, worktree: record.worktree, branch: record.branch, patchUnavailable: record.patchUnavailable };
+            try {
+                const patch = reader.read(record, 'patch');
+                if (patch)
+                    change.patch = clip(patch, record.id);
+            }
+            catch (error) {
+                issues.push({ id: record.id, reason: String(error) });
+            }
+            const owner = record.toolCallId ? tools.get(record.toolCallId) : undefined;
+            if (owner)
+                owner.changes.push(change);
+            else
+                bucket(record.agentId).push(change);
+        }
+        else if ((record.type === 'source_record' || record.type === 'message') && record.role === 'assistant') {
+            const raw = reader.read(record, 'data');
+            if (raw === undefined)
+                continue;
+            let message;
+            try {
+                message = record.type === 'source_record' ? nativeMessage(harness, raw, record.toolCallId) : JSON.parse(raw);
+            }
+            catch (error) {
+                issues.push({ id: record.id, reason: String(error) });
+                continue;
+            }
+            const blocks = typeof message?.content === 'string' ? [{ type: 'text', text: message.content }] : Array.isArray(message?.content) ? message.content : [];
+            blocks.forEach((block, index) => {
+                const id = `${record.id}:${index}`;
+                if (block?.type === 'text' && block.text?.trim())
+                    bucket(record.agentId).push({ kind: 'text', id, at: at(record), text: clip(block.text, record.id), source: 'transcript' });
+                else if (block?.type === 'thinking')
+                    bucket(record.agentId).push({ kind: 'thinking', id, at: at(record),
+                        text: clip(block.thinking ?? '', record.id) ?? { text: '' }, redacted: block.redacted, durationMs: block.durationMs });
+                else if (block?.type === 'toolCall' && block.id && !hookTools.has(block.id)) {
+                    // A call only the transcript knows about (no hook fired for it).
+                    const item = { kind: 'tool', id, at: at(record), toolCallId: block.id, name: block.name ?? 'tool', agentId: record.agentId,
+                        input: clip(block.arguments, record.id), output: clip(nativeResults.get(block.id), record.id),
+                        status: (nativeOutcomes.has(block.id) ? nativeOutcomes.get(block.id) ? 'error' : 'ok' : nativeResults.has(block.id) ? 'recorded' : 'pending'), changes: [], native: true };
+                    tools.set(block.id, item);
+                    bucket(record.agentId).push(item);
+                }
+            });
+        }
+        else if (record.type === 'subagent_stopped' && record.agentId) {
+            const data = json(record);
+            reports.set(record.agentId, { ...reports.get(record.agentId), body: clip(data?.lastAssistantMessage, record.id), agentType: data?.agentType });
+        }
+        else if (record.type === 'subagent_started' && record.agentId) {
+            const data = json(record);
+            reports.set(record.agentId, { ...reports.get(record.agentId), agentType: data?.agentType });
+        }
+        else if (record.type === 'input' && record.agentId) {
+            // A subagent's own prompt is its task.
+            reports.set(record.agentId, { ...reports.get(record.agentId), task: clip(json(record)?.text, record.id) });
+        }
+        else if (record.type === 'agent_settled' && !record.agentId) {
+            settled = clip(json(record)?.lastAssistantMessage, record.id) ?? settled;
+        }
+    }
+    // The final reply as the harness reported it, when no transcript text exists (no native file).
+    const main = bucket();
+    if (settled && !main.some(item => item.kind === 'text'))
+        main.push({ kind: 'text', id: `${prompt.id}:settled`, at: main.at(-1)?.at ?? at(prompt), text: settled, source: 'hook' });
+    // Nest each subagent under the call that started it; without a recorded link it stands alone.
+    for (const [agentId, items] of buckets) {
+        if (!agentId)
+            continue;
+        const report = reports.get(agentId);
+        const subagent = { agentId, agentType: report?.agentType, task: report?.task, items, report: report?.body };
+        const spawn = [...tools.values()].find(tool => finishes.get(tool.toolCallId)?.childAgentId === agentId);
+        if (spawn)
+            spawn.subagent = subagent;
+        else
+            main.push({ kind: 'subagent', id: `agent:${agentId}`, at: items[0]?.at ?? at(prompt), subagent });
+    }
+    main.sort((a, b) => a.at.localeCompare(b.at));
+    // Tokens of this turn: once per model response, resumed history excluded.
+    const tokens = { calls: 0, input: 0, cacheRead: 0, cacheWrite: 0, output: 0, reasoning: 0, total: 0, costUsd: null, costEstimated: undefined };
+    const seen = new Set();
+    const usageAgents = [...agents];
+    const usage = db.records(`capture_id=? AND revision<=? AND type='usage' AND (request_id=?${usageAgents.length ? ` OR json_extract(body,'$.agentId') IN (${usageAgents.map(() => '?').join(',')})` : ''})`, [request.captureId, version, prompt.id, ...usageAgents], 'ORDER BY seq');
+    for (const record of usage) {
+        if (record.usageScope !== 'call' || record.beforeCapture || !record.usage)
+            continue;
+        const key = `${record.agentId ?? ''}:${record.usageKey}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        const u = record.usage;
+        tokens.calls++;
+        tokens.input += u.input;
+        tokens.cacheRead += u.cacheRead;
+        tokens.cacheWrite += u.cacheWrite;
+        tokens.output += u.output;
+        tokens.reasoning += u.reasoning ?? 0;
+        tokens.total += u.input + u.cacheRead + u.cacheWrite + u.output;
+        // A harness that reports no cost (Codex) gets an estimate from its tokens, marked as one.
+        const estimate = typeof u.costUsd === 'number' ? undefined : estimateCost(record.model, u);
+        if (typeof u.costUsd === 'number')
+            tokens.costUsd = (tokens.costUsd ?? 0) + u.costUsd;
+        else if (estimate !== undefined) {
+            tokens.costUsd = (tokens.costUsd ?? 0) + estimate;
+            tokens.costEstimated = true;
+        }
+    }
+    const promptData = json(prompt);
+    return { readVersion: version, captureId: request.captureId, harness,
+        request: { id: prompt.id, at: at(prompt), text: clip(promptData?.text ?? '', prompt.id) ?? { text: '' }, images: promptData?.images?.length || undefined },
+        items: main, tokens, issues,
+        notes: ['Recorded evidence in recorded order. Thinking marked redacted happened, but its text was not recorded (omitted by the harness or encrypted by the provider).'] };
+}
+//# sourceMappingURL=conversation.js.map