@faithfulalabi/agent-lens 0.1.0

package/dist/src/db/write.js

@@ -0,0 +1,279 @@
+import { runPipeline } from '../project/pipeline.js';
+import { linkSubagents, } from '../project/subagents.js';
+import { resolvePersistedOutput } from '../transcript/spill.js';
+import { PROJECTOR_VERSION } from '../transcript/version.js';
+import { estimateCost } from '../shared/pricing.js';
+const UPSERT_INDEX_SQL = `INSERT INTO sessions
+    (id, source_path, archive_path, file_mtime_ms, file_size,
+     project_path, started_at, last_activity_at)
+  VALUES
+    (:id, :source_path, :archive_path, :file_mtime_ms, :file_size,
+     :project_path, :started_at, :last_activity_at)
+  ON CONFLICT(id) DO UPDATE SET
+    source_path      = excluded.source_path,
+    archive_path     = excluded.archive_path,
+    file_mtime_ms    = excluded.file_mtime_ms,
+    file_size        = excluded.file_size,
+    project_path     = excluded.project_path,
+    started_at       = excluded.started_at,
+    last_activity_at = excluded.last_activity_at`;
+export function upsertSessionIndex(db, row) {
+    db.prepare(UPSERT_INDEX_SQL).run({ ...row });
+}
+const UPSERT_SIDECAR_SQL = `INSERT INTO sessions
+    (id, source_path, archive_path, file_mtime_ms, file_size,
+     project_path, started_at, last_activity_at,
+     parent_session_id, spawned_by_event_id, agent_type, agent_description, spawn_depth)
+  VALUES
+    (:id, :source_path, :archive_path, :file_mtime_ms, :file_size,
+     :project_path, :started_at, :last_activity_at,
+     :parent_session_id, :spawned_by_event_id, :agent_type, :agent_description, :spawn_depth)
+  ON CONFLICT(id) DO UPDATE SET
+    source_path         = excluded.source_path,
+    archive_path        = excluded.archive_path,
+    file_mtime_ms       = excluded.file_mtime_ms,
+    file_size           = excluded.file_size,
+    project_path        = excluded.project_path,
+    started_at          = excluded.started_at,
+    last_activity_at    = excluded.last_activity_at,
+    parent_session_id   = excluded.parent_session_id,
+    spawned_by_event_id = excluded.spawned_by_event_id,
+    agent_type          = excluded.agent_type,
+    agent_description   = excluded.agent_description,
+    spawn_depth         = excluded.spawn_depth`;
+export function upsertSidecarIndex(db, row) {
+    db.prepare(UPSERT_SIDECAR_SQL).run({
+        ...row,
+        agent_type: row.agent_type ?? null,
+        agent_description: row.agent_description ?? null,
+        spawn_depth: row.spawn_depth ?? null,
+    });
+}
+export function deleteSessionProjection(db, id) {
+    db.prepare(`INSERT INTO events_fts(events_fts, rowid, text, input)
+       SELECT 'delete', rowid, text, input FROM events WHERE session_id = ?`).run(id);
+    db.prepare('DELETE FROM events WHERE session_id = ?').run(id);
+    db.prepare('DELETE FROM turns  WHERE session_id = ?').run(id);
+}
+const INSERT_TURN_SQL = `INSERT INTO turns
+    (id, session_id, seq, kind, parent_event_id, title, started_at, ended_at,
+     duration_ms, duration_source, tokens_in, tokens_out, tokens_cache_read,
+     tokens_cache_write, tool_call_count, error_count, first_seq, last_seq)
+  VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)`;
+const INSERT_EVENT_SQL = `INSERT INTO events
+    (id, session_id, turn_id, seq, kind, ts, request_id, block_index, name, status,
+     duration_ms, duration_source, input, input_bytes, input_storage, text, text_bytes,
+     output_storage, spill_path, spill_bytes, src_offset, src_len, result_offset,
+     result_len, result_block, model, tokens_in, tokens_out, tokens_cache_read,
+     tokens_cache_write, est_cost, child_session_id, agent_type, agent_status, raw_type,
+     raw_subtype, attrs)
+  VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)`;
+const POPULATE_FTS_SQL = `INSERT INTO events_fts(rowid, text, input)
+  SELECT rowid, text, input FROM events WHERE session_id = ?`;
+const WRITE_HEADER_SQL = `UPDATE sessions SET
+    project_path     = COALESCE(:project_path, project_path),
+    git_branch       = :git_branch,
+    model            = :model,
+    harness_version  = :harness_version,
+    title            = :title,
+    preview          = :preview,
+    started_at       = :started_at,
+    last_activity_at = :last_activity_at
+  WHERE id = :id`;
+const STAMP_SQL = `UPDATE sessions SET
+    drift_json         = :drift_json,
+    projected_mtime_ms = :mtime_ms,
+    projected_size     = :size,
+    projector_version  = :version,
+    projected_at       = :projected_at,
+    projection_state   = :state,
+    projection_error   = NULL
+  WHERE id = :id`;
+const SAVEPOINT = 'agent_lens_projection';
+export function projectSession(db, id, env, fold) {
+    const row = db.prepare('SELECT archive_path, source_path FROM sessions WHERE id = ?').get(id);
+    if (row === undefined)
+        throw new Error(`no sessions row to project: ${id}`);
+    db.exec(`SAVEPOINT ${SAVEPOINT}`);
+    try {
+        const state = writeProjection(db, id, row.archive_path, row.source_path, env, fold);
+        db.exec(`RELEASE ${SAVEPOINT}`);
+        return state;
+    }
+    catch (error) {
+        db.exec(`ROLLBACK TO ${SAVEPOINT}`);
+        db.exec(`RELEASE ${SAVEPOINT}`);
+        recordFailure(db, id, error);
+        throw error;
+    }
+}
+function writeProjection(db, id, archivePath, sourcePath, env, fold) {
+    deleteSessionProjection(db, id);
+    const read = env.readLines(archivePath);
+    const projection = runPipeline(read.lines, { session_id: id, drift: read.drift });
+    const toolUseIds = new Set(projection.events
+        .filter((event) => event.kind === 'tool_call' && event.name === 'Agent')
+        .map((event) => event.id));
+    const sidecarRows = linkSubagents(projection.events, env.sidecars(archivePath, sourcePath, toolUseIds), projection.launches, read.drift);
+    const spills = resolveSpills(read.lines, env.spillEnv(archivePath));
+    const drift = withUnresolvedSpills(read.drift.serialize(), spills.unresolved);
+    const header = projection.header;
+    if (header === undefined) {
+        stamp(db, id, fold, 'empty', drift);
+        return 'empty';
+    }
+    db.prepare(WRITE_HEADER_SQL).run({
+        project_path: header.project_path ?? null,
+        git_branch: header.git_branch ?? null,
+        model: header.model ?? null,
+        harness_version: header.harness_version ?? null,
+        title: header.title ?? null,
+        preview: header.preview ?? null,
+        started_at: header.started_at,
+        last_activity_at: header.last_activity_at,
+        id,
+    });
+    for (const sidecar of sidecarRows)
+        upsertSidecarIndex(db, sidecar);
+    insertTurns(db, projection.turns);
+    insertEvents(db, projection.events, spills.byOffset);
+    db.prepare(ROLLUP_TURN_COST_SQL).run({ id });
+    db.prepare(POPULATE_FTS_SQL).run(id);
+    recomputeSessionRollups(db, id);
+    stamp(db, id, fold, 'ready', drift);
+    return 'ready';
+}
+function stamp(db, id, fold, state, drift) {
+    db.prepare(STAMP_SQL).run({
+        drift_json: drift,
+        mtime_ms: fold.mtime_ms,
+        size: fold.size,
+        version: PROJECTOR_VERSION,
+        projected_at: new Date().toISOString(),
+        state,
+        id,
+    });
+}
+function recordFailure(db, id, error) {
+    try {
+        db.prepare(`UPDATE sessions SET projection_state = 'failed', projection_error = ? WHERE id = ?`).run(String(error), id);
+    }
+    catch {
+    }
+}
+function insertTurns(db, turns) {
+    const insert = db.prepare(INSERT_TURN_SQL);
+    for (const turn of turns) {
+        insert.run(turn.id, turn.session_id, turn.seq, turn.kind, turn.parent_event_id ?? null, turn.title, turn.started_at, turn.ended_at, turn.duration_ms ?? null, turn.duration_source, turn.tokens_in, turn.tokens_out, turn.tokens_cache_read, turn.tokens_cache_write, turn.tool_call_count, turn.error_count, turn.first_seq, turn.last_seq);
+    }
+}
+function insertEvents(db, events, spills) {
+    const insert = db.prepare(INSERT_EVENT_SQL);
+    for (const event of events) {
+        const output = spillColumns(event, spills);
+        const est_cost = estimateCost(event.model, {
+            tokens_in: event.tokens_in,
+            tokens_out: event.tokens_out,
+            cache_read: event.tokens_cache_read,
+            cache_write: event.tokens_cache_write,
+        });
+        insert.run(event.id, event.session_id, event.turn_id, event.seq, event.kind, event.ts, event.request_id ?? null, event.block_index, event.name ?? null, event.status ?? null, event.duration_ms ?? null, event.duration_source ?? null, event.input ?? null, event.input_bytes ?? null, event.input_storage ?? null, event.text ?? null, event.text_bytes ?? null, output.output_storage, output.spill_path, output.spill_bytes, event.src_offset, event.src_len, event.result_offset ?? null, event.result_len ?? null, event.result_block ?? null, event.model ?? null, event.tokens_in ?? null, event.tokens_out ?? null, event.tokens_cache_read ?? null, event.tokens_cache_write ?? null, est_cost, event.child_session_id ?? null, event.agent_type ?? null, event.agent_status ?? null, event.raw_type, event.raw_subtype ?? null, event.attrs);
+    }
+}
+function spillColumns(event, spills) {
+    if (event.output_storage !== 'spill' || event.result_offset === undefined) {
+        return { output_storage: event.output_storage ?? null, spill_path: null, spill_bytes: null };
+    }
+    const state = spills.get(event.result_offset);
+    if (state?.kind === 'resolved') {
+        return {
+            output_storage: 'spill',
+            spill_path: state.path,
+            spill_bytes: state.declaredSize ?? null,
+        };
+    }
+    return { output_storage: 'missing', spill_path: null, spill_bytes: null };
+}
+function resolveSpills(lines, env) {
+    const byOffset = new Map();
+    let unresolved = 0;
+    for (const line of lines) {
+        const state = resolvePersistedOutput(line.raw, env);
+        if (state.kind === 'none')
+            continue;
+        byOffset.set(line.byte_offset, state);
+        if (state.kind === 'missing')
+            unresolved += 1;
+    }
+    return { byOffset, unresolved };
+}
+function withUnresolvedSpills(drift, unresolved) {
+    if (unresolved === 0)
+        return drift;
+    const counted = JSON.parse(drift);
+    counted['unresolved_spills'] = unresolved;
+    return JSON.stringify(counted);
+}
+const ROLLUP_TURN_COST_SQL = `UPDATE turns SET est_cost = (
+    CASE WHEN EXISTS (
+      SELECT 1 FROM events e WHERE e.turn_id = turns.id
+        AND e.est_cost IS NULL
+        AND (COALESCE(e.tokens_in, 0) + COALESCE(e.tokens_out, 0)
+             + COALESCE(e.tokens_cache_read, 0) + COALESCE(e.tokens_cache_write, 0)) > 0
+    ) THEN NULL
+    ELSE (SELECT sum(e2.est_cost) FROM events e2 WHERE e2.turn_id = turns.id)
+    END
+  ) WHERE session_id = :id`;
+const ROLLUP_SQL = `UPDATE sessions SET
+    turn_count         = COALESCE((SELECT count(*)                FROM turns WHERE session_id = :id AND kind = 'human'), 0),
+    tool_call_count    = COALESCE((SELECT sum(tool_call_count)    FROM turns WHERE session_id = :id), 0),
+    error_count        = COALESCE((SELECT sum(error_count)        FROM turns WHERE session_id = :id), 0),
+    tokens_in          = COALESCE((SELECT sum(tokens_in)          FROM turns WHERE session_id = :id), 0),
+    tokens_out         = COALESCE((SELECT sum(tokens_out)         FROM turns WHERE session_id = :id), 0),
+    tokens_cache_read  = COALESCE((SELECT sum(tokens_cache_read)  FROM turns WHERE session_id = :id), 0),
+    tokens_cache_write = COALESCE((SELECT sum(tokens_cache_write) FROM turns WHERE session_id = :id), 0),
+    est_cost           = CASE WHEN EXISTS (
+                           SELECT 1 FROM turns t WHERE t.session_id = :id
+                             AND t.est_cost IS NULL
+                             AND (t.tokens_in + t.tokens_out
+                                  + t.tokens_cache_read + t.tokens_cache_write) > 0
+                         ) THEN NULL
+                         ELSE (SELECT sum(t2.est_cost) FROM turns t2 WHERE t2.session_id = :id)
+                         END
+  WHERE id = :id`;
+export function recomputeSessionRollups(db, id) {
+    db.prepare(ROLLUP_SQL).run({ id });
+}
+const SUBAGENT_ROLLUP_SQL = `UPDATE sessions SET
+    agent_count            = COALESCE((SELECT sum(1 + c.agent_count)                                FROM sessions c WHERE c.parent_session_id = :id), 0),
+    sub_tool_call_count    = COALESCE((SELECT sum(c.tool_call_count    + c.sub_tool_call_count)     FROM sessions c WHERE c.parent_session_id = :id), 0),
+    sub_error_count        = COALESCE((SELECT sum(c.error_count        + c.sub_error_count)         FROM sessions c WHERE c.parent_session_id = :id), 0),
+    sub_tokens_in          = COALESCE((SELECT sum(c.tokens_in          + c.sub_tokens_in)           FROM sessions c WHERE c.parent_session_id = :id), 0),
+    sub_tokens_out         = COALESCE((SELECT sum(c.tokens_out         + c.sub_tokens_out)          FROM sessions c WHERE c.parent_session_id = :id), 0),
+    sub_tokens_cache_read  = COALESCE((SELECT sum(c.tokens_cache_read  + c.sub_tokens_cache_read)   FROM sessions c WHERE c.parent_session_id = :id), 0),
+    sub_tokens_cache_write = COALESCE((SELECT sum(c.tokens_cache_write + c.sub_tokens_cache_write)  FROM sessions c WHERE c.parent_session_id = :id), 0),
+    sub_est_cost           = CASE WHEN EXISTS (
+                               SELECT 1 FROM sessions c WHERE c.parent_session_id = :id AND (
+                                 (c.est_cost IS NULL AND (c.tokens_in + c.tokens_out
+                                    + c.tokens_cache_read + c.tokens_cache_write) > 0)
+                                 OR (c.sub_est_cost IS NULL AND (c.sub_tokens_in + c.sub_tokens_out
+                                    + c.sub_tokens_cache_read + c.sub_tokens_cache_write) > 0))
+                             ) THEN NULL
+                             ELSE (SELECT sum(COALESCE(c.est_cost, 0) + COALESCE(c.sub_est_cost, 0))
+                                     FROM sessions c
+                                    WHERE c.parent_session_id = :id
+                                      AND (c.est_cost IS NOT NULL OR c.sub_est_cost IS NOT NULL))
+                             END
+  WHERE id = :id`;
+export function recomputeSubagentRollups(db, id) {
+    db.prepare(SUBAGENT_ROLLUP_SQL).run({ id });
+}
+export function markRollupComplete(db, id) {
+    db.prepare(`UPDATE sessions SET rollup_state = 'complete' WHERE id = ?`).run(id);
+}
+export function setParentSession(db, id, parent_session_id) {
+    db.prepare('UPDATE sessions SET parent_session_id = ? WHERE id = ?').run(parent_session_id, id);
+}
+export function writeMeta(db, key, value) {
+    db.prepare('INSERT OR REPLACE INTO meta (key, value) VALUES (?, ?)').run(key, value);
+}

package/dist/src/project/pipeline.js

@@ -0,0 +1,307 @@
+import { asyncAgentLaunch, taskNotification } from '../transcript/agents.js';
+import { contentBlocks } from '../transcript/blocks.js';
+import { isHumanPrompt, MACHINERY_TAGS } from '../transcript/human.js';
+import { foldControlLines, foldSessionEnvelope, promptGroupId, toolDenialKind, turnDurationMs, } from '../transcript/line.js';
+import { foldRequestGroup, groupByRequestId, modelOfRequestGroup, requestIdOf, } from '../transcript/usage.js';
+import { joinToolCalls, NO_INPUT, toolInput, } from './tools.js';
+const MAX_TITLE_CHARS = 200;
+const NO_BLOCKS = Object.freeze([]);
+const MS_PER_DAY = 86_400_000;
+const MS_PER_HOUR = 3_600_000;
+const MS_PER_MINUTE = 60_000;
+const MS_PER_SECOND = 1_000;
+const DAYS_PER_ERA = 146_097;
+const DAYS_TO_EPOCH = 719_468;
+export function epochMs(ts) {
+    const year = Number(ts.slice(0, 4));
+    const month = Number(ts.slice(5, 7));
+    const day = Number(ts.slice(8, 10));
+    const shifted = year - (month <= 2 ? 1 : 0);
+    const era = ((shifted >= 0 ? shifted : shifted - 399) / 400) | 0;
+    const yearOfEra = shifted - era * 400;
+    const dayOfYear = (((153 * (month + (month > 2 ? -3 : 9)) + 2) / 5) | 0) + day - 1;
+    const dayOfEra = yearOfEra * 365 + ((yearOfEra / 4) | 0) - ((yearOfEra / 100) | 0) + dayOfYear;
+    const days = era * DAYS_PER_ERA + dayOfEra - DAYS_TO_EPOCH;
+    return (days * MS_PER_DAY +
+        Number(ts.slice(11, 13)) * MS_PER_HOUR +
+        Number(ts.slice(14, 16)) * MS_PER_MINUTE +
+        Number(ts.slice(17, 19)) * MS_PER_SECOND +
+        Number(ts.slice(20, 23)));
+}
+function prose(blocks) {
+    return blocks
+        .flatMap((block) => (block.kind === 'text' ? [block.text] : []))
+        .join('\n')
+        .trim();
+}
+function resultText(children) {
+    return children.flatMap((child) => (child.kind === 'text' ? [child.text] : [])).join('\n');
+}
+function blockText(block) {
+    switch (block?.kind) {
+        case 'text':
+        case 'thinking':
+        case 'thinking_elided':
+            return block.text;
+        case 'image':
+            return block.placeholder;
+        default:
+            return undefined;
+    }
+}
+function eventKind(line, block, human) {
+    switch (block?.kind) {
+        case 'text':
+            return human ? 'prompt' : 'text';
+        case 'thinking':
+        case 'thinking_elided':
+            return 'thinking';
+        case 'tool_use':
+            return 'tool_call';
+        case 'image':
+            return 'text';
+    }
+    if (line.kind === 'system') {
+        if (line.subtype === 'compact_boundary')
+            return 'compaction';
+        if (line.subtype === 'api_error')
+            return 'error';
+    }
+    return 'unknown';
+}
+function rawTypeOf(line) {
+    return line.kind === 'unknown' ? line.raw_type : line.kind;
+}
+function rawSubtypeOf(line) {
+    if (line.kind === 'unknown')
+        return line.raw_subtype;
+    return line.kind === 'system' ? line.subtype : undefined;
+}
+function turnKind(lead, human, text, compacted) {
+    if (human)
+        return 'human';
+    const tag = MACHINERY_TAGS.find((candidate) => text.startsWith(candidate));
+    if (tag === '<task-notification>')
+        return 'task_notification';
+    if (tag === '<command-name>' || tag === '<command-message>')
+        return 'slash_command';
+    if (compacted)
+        return 'compaction';
+    return lead.kind === 'system' ? 'system' : 'unknown';
+}
+export function runPipeline(lines, ctx) {
+    const segmentOf = [];
+    const blocksAt = [];
+    const humanAt = [];
+    const assistantAt = [];
+    const leadOf = new Map();
+    const compactedSegments = new Set();
+    const reportedDuration = new Map();
+    const errorsOf = new Map();
+    const titleOf = new Map();
+    const toolResults = new Map();
+    const notifications = [];
+    const calledBy = new Map();
+    let previewText;
+    let segment = 0;
+    let currentGroup;
+    for (const [index, line] of lines.entries()) {
+        const group = promptGroupId(line);
+        if (group !== undefined && group !== currentGroup) {
+            currentGroup = group;
+            segment += 1;
+        }
+        segmentOf.push(segment);
+        const blocks = line.uuid === undefined ? NO_BLOCKS : contentBlocks(line);
+        blocksAt.push(blocks);
+        humanAt.push(isHumanPrompt(line).human);
+        if (line.kind === 'assistant')
+            assistantAt.push(index);
+        if (line.uuid !== undefined && !leadOf.has(segment))
+            leadOf.set(segment, index);
+        if (line.kind === 'system' && line.subtype === 'compact_boundary') {
+            compactedSegments.add(segment);
+        }
+        const reported = turnDurationMs(line);
+        if (reported !== undefined && !reportedDuration.has(segment)) {
+            reportedDuration.set(segment, reported);
+        }
+        const failures = blocks.filter((block) => block.kind === 'tool_result' && block.is_error).length;
+        if (failures > 0)
+            errorsOf.set(segment, (errorsOf.get(segment) ?? 0) + failures);
+        for (const [blockIndex, block] of blocks.entries()) {
+            if (block.kind !== 'tool_result' || toolResults.has(block.tool_call_id))
+                continue;
+            const output = resultText(block.children);
+            toolResults.set(block.tool_call_id, {
+                text: output,
+                is_error: block.is_error,
+                denial: toolDenialKind(line),
+                launch: asyncAgentLaunch(line, output),
+                ts: line.timestamp ?? '',
+                result_offset: line.byte_offset,
+                result_len: line.byte_length,
+                result_block: blockIndex,
+            });
+        }
+        const text = prose(blocks);
+        const notification = taskNotification(text);
+        if (notification !== undefined) {
+            notifications.push(notification);
+            const called = notification.toolCallId;
+            if (called !== undefined && !calledBy.has(segment))
+                calledBy.set(segment, called);
+        }
+        if (text === '')
+            continue;
+        if (!titleOf.has(segment))
+            titleOf.set(segment, text);
+        if (humanAt[index] === true && previewText === undefined)
+            previewText = text;
+    }
+    const usageAt = new Map();
+    const modelAt = new Map();
+    let member = 0;
+    for (const group of groupByRequestId(assistantAt.map((index) => lines[index].raw))) {
+        usageAt.set(assistantAt[member], foldRequestGroup(group));
+        modelAt.set(assistantAt[member], modelOfRequestGroup(group));
+        member += group.length;
+    }
+    const events = [];
+    const ownerOfEvent = [];
+    for (const [index, line] of lines.entries()) {
+        const uuid = line.uuid;
+        if (uuid === undefined)
+            continue;
+        const blocks = blocksAt[index];
+        const human = humanAt[index];
+        const usage = usageAt.get(index);
+        let stamped = false;
+        const emit = (block, blockIndex) => {
+            if (block?.kind === 'unknown_block')
+                ctx.drift.noteUnknownBlock(block.raw_type);
+            const kind = eventKind(line, block, human);
+            const id = block?.kind === 'tool_use' && block.id !== '' ? block.id : `${uuid}:${blockIndex}`;
+            const tokens = stamped ? undefined : usage;
+            const model = stamped ? undefined : modelAt.get(index);
+            stamped = true;
+            events.push({
+                id,
+                session_id: ctx.session_id,
+                turn_id: '',
+                seq: events.length,
+                kind,
+                ts: line.timestamp ?? '',
+                request_id: requestIdOf(line.raw),
+                block_index: blockIndex,
+                name: block?.kind === 'tool_use' ? block.name : undefined,
+                status: kind === 'tool_call' ? 'running' : undefined,
+                duration_ms: undefined,
+                duration_source: undefined,
+                child_session_id: undefined,
+                agent_type: undefined,
+                ...(block?.kind === 'tool_use' ? toolInput(block.input) : NO_INPUT),
+                text: kind === 'tool_call' ? undefined : blockText(block),
+                text_bytes: undefined,
+                output_storage: kind === 'tool_call' ? 'absent' : undefined,
+                spill_path: undefined,
+                agent_status: undefined,
+                src_offset: line.byte_offset,
+                src_len: line.byte_length,
+                result_offset: undefined,
+                result_len: undefined,
+                result_block: undefined,
+                model,
+                tokens_in: tokens?.input_tokens,
+                tokens_out: tokens?.output_tokens,
+                tokens_cache_read: tokens?.cache_read_input_tokens,
+                tokens_cache_write: tokens?.cache_creation_input_tokens,
+                raw_type: rawTypeOf(line),
+                raw_subtype: rawSubtypeOf(line),
+                attrs: '{}',
+            });
+            ownerOfEvent.push(segmentOf[index]);
+        };
+        if (blocks.length === 0) {
+            emit(undefined, 0);
+            continue;
+        }
+        for (const [blockIndex, block] of blocks.entries()) {
+            if (block.kind !== 'tool_result')
+                emit(block, blockIndex);
+        }
+    }
+    const eventsOf = new Map();
+    for (const [index, event] of events.entries()) {
+        const owner = ownerOfEvent[index];
+        const own = eventsOf.get(owner);
+        if (own === undefined)
+            eventsOf.set(owner, [event]);
+        else
+            own.push(event);
+    }
+    const nameOfEvent = new Map();
+    for (const event of events) {
+        if (event.name !== undefined)
+            nameOfEvent.set(event.id, event.name);
+    }
+    const turns = [];
+    for (const [owner, own] of eventsOf) {
+        const seq = turns.length;
+        for (const event of own)
+            event.turn_id = `${ctx.session_id}:${seq}`;
+        const stamps = own.map((event) => event.ts).filter((ts) => ts !== '');
+        const started_at = stamps.reduce((a, b) => (a < b ? a : b), stamps[0] ?? '');
+        const ended_at = stamps.reduce((a, b) => (a > b ? a : b), stamps[0] ?? '');
+        const reported = reportedDuration.get(owner);
+        const lead = leadOf.get(owner);
+        const kind = turnKind(lines[lead], humanAt[lead], prose(blocksAt[lead]), compactedSegments.has(owner));
+        const called = kind === 'task_notification' ? calledBy.get(owner) : undefined;
+        turns.push({
+            id: `${ctx.session_id}:${seq}`,
+            session_id: ctx.session_id,
+            seq,
+            kind,
+            parent_event_id: called !== undefined && nameOfEvent.get(called) === 'Agent' ? called : undefined,
+            title: (titleOf.get(owner) ?? '').slice(0, MAX_TITLE_CHARS),
+            started_at,
+            ended_at,
+            duration_ms: reported ?? (stamps.length === 0 ? undefined : epochMs(ended_at) - epochMs(started_at)),
+            duration_source: reported === undefined ? 'derived' : 'turn_duration',
+            tokens_in: sum(own, (event) => event.tokens_in),
+            tokens_out: sum(own, (event) => event.tokens_out),
+            tokens_cache_read: sum(own, (event) => event.tokens_cache_read),
+            tokens_cache_write: sum(own, (event) => event.tokens_cache_write),
+            tool_call_count: own.filter((event) => event.kind === 'tool_call').length,
+            error_count: errorsOf.get(owner) ?? 0,
+            first_seq: own[0].seq,
+            last_seq: own[own.length - 1].seq,
+        });
+    }
+    joinToolCalls(events, toolResults, notifications, ctx.drift);
+    const launches = new Map();
+    for (const [callId, result] of toolResults) {
+        const agentId = result.launch?.agentId;
+        if (agentId !== undefined)
+            launches.set(callId, agentId);
+    }
+    const envelope = foldSessionEnvelope(lines);
+    const { started_at, last_activity_at } = envelope;
+    const header = events.length === 0 || started_at === undefined || last_activity_at === undefined
+        ? undefined
+        : {
+            session_id: ctx.session_id,
+            project_path: envelope.project_path,
+            git_branch: envelope.git_branch,
+            harness_version: envelope.harness_version,
+            model: envelope.model,
+            title: foldControlLines(lines).ai_title,
+            preview: previewText?.slice(0, MAX_TITLE_CHARS),
+            started_at,
+            last_activity_at,
+        };
+    return { header, turns, events, drift: ctx.drift.serialize(), launches };
+}
+function sum(events, of) {
+    return events.reduce((total, event) => total + (of(event) ?? 0), 0);
+}

package/dist/src/project/subagents.js

@@ -0,0 +1,41 @@
+import { epochMs } from './pipeline.js';
+export function linkSubagents(events, sidecars, launches, drift) {
+    const byToolUseId = new Map();
+    for (const sidecar of sidecars) {
+        const key = sidecar.meta.toolUseId;
+        if (key !== undefined)
+            byToolUseId.set(key, sidecar);
+    }
+    const rows = [];
+    for (const event of events) {
+        if (event.kind !== 'tool_call')
+            continue;
+        const sidecar = byToolUseId.get(event.id);
+        if (sidecar === undefined)
+            continue;
+        const launched = launches.get(event.id);
+        if (launched !== undefined && launched !== sidecar.agent_id)
+            drift.noteSidecarMismatch();
+        event.child_session_id = sidecar.agent_id;
+        event.agent_type = sidecar.meta.agentType;
+        event.duration_ms =
+            epochMs(sidecar.envelope.last_activity_at) - epochMs(sidecar.envelope.started_at);
+        event.duration_source = 'sidecar_span';
+        rows.push({
+            id: sidecar.agent_id,
+            source_path: sidecar.source_path,
+            archive_path: sidecar.archive_path,
+            file_mtime_ms: sidecar.mtime_ms,
+            file_size: sidecar.size,
+            project_path: sidecar.envelope.project_path,
+            started_at: sidecar.envelope.started_at,
+            last_activity_at: sidecar.envelope.last_activity_at,
+            parent_session_id: event.session_id,
+            spawned_by_event_id: event.id,
+            agent_type: sidecar.meta.agentType,
+            agent_description: sidecar.meta.description,
+            spawn_depth: sidecar.meta.spawnDepth,
+        });
+    }
+    return rows;
+}