@agentdeck/bridge 0.1.0 → 0.2.0

package/dist/apme/collector.js

@@ -0,0 +1,659 @@
+/**
+ * APME Collector — the ingestion boundary.
+ *
+ * Responsibilities:
+ *   - openRun(session): create a `runs` row when a bridge session starts
+ *   - ingestHook(evt): write a `steps` row for every hook POST
+ *   - updateUsage(snapshot): keep token/cost columns in sync
+ *   - closeRun(session, exitCode): finalize the row, capture git SHA, enqueue eval
+ *
+ * The collector is lazy — it's created once at daemon/bridge startup and gated on
+ * `store.enabled`. All methods are no-ops if the store failed to initialize
+ * (e.g. better-sqlite3 missing), so the rest of the bridge never needs to care.
+ */
+import { randomUUID, createHash } from 'crypto';
+import { execSync } from 'child_process';
+import { join } from 'path';
+import { mkdirSync, writeFileSync } from 'fs';
+import { homedir } from 'os';
+import { debug } from '../logger.js';
+import { resolveProjectName } from '../utils/project-name.js';
+import { classifyRunSmart } from './classifier.js';
+export class ApmeCollector {
+    store;
+    hwSampler;
+    sessionToRun = new Map(); // sessionId → runId
+    sessionToTurn = new Map(); // sessionId → current turn
+    sessionToLastTurnId = new Map(); // survives closeTurn()
+    sessionToTask = new Map(); // sessionId → current task
+    runTaskCount = new Map(); // runId → next task_index
+    /** Optional listener fired after `closeTask` persists the row. The runner
+     *  wires this to enqueue a task-level judge call. */
+    onTaskClosed = null;
+    constructor(store, hwSampler) {
+        this.store = store;
+        this.hwSampler = hwSampler;
+    }
+    /** Start a new run and return its id. Safe to call if store disabled (returns ''). */
+    openRun(input) {
+        if (!this.store.enabled)
+            return '';
+        const runId = randomUUID();
+        const gitBefore = readGitHead(input.projectPath);
+        const row = {
+            id: runId,
+            sessionId: input.sessionId,
+            agentType: input.agentType,
+            modelId: input.modelId ?? null,
+            projectName: input.projectName ?? (input.projectPath ? resolveProjectName({ cwd: input.projectPath }) : null),
+            projectPath: input.projectPath ?? null,
+            taskPrompt: input.taskPrompt ?? null,
+            startedAt: Date.now(),
+            gitBefore,
+        };
+        try {
+            this.store.insertRun(row);
+            this.sessionToRun.set(input.sessionId, runId);
+            debug('APME', `openRun ${runId} session=${input.sessionId} agent=${input.agentType} model=${input.modelId ?? '-'}`);
+        }
+        catch (err) {
+            debug('APME', `openRun failed: ${String(err)}`);
+        }
+        return runId;
+    }
+    /** Record a hook event as a step + manage turn lifecycle. */
+    ingestHook(sessionId, event, data) {
+        if (!this.store.enabled)
+            return;
+        const runId = this.sessionToRun.get(sessionId);
+        if (!runId)
+            return;
+        const toolName = typeof data.tool_name === 'string' ? data.tool_name : null;
+        // ── Turn management ──
+        if (event === 'UserPromptSubmit') {
+            // Claude Code sends { message: { content: "..." } }, legacy sends { prompt: "..." }
+            const rawPrompt = typeof data.prompt === 'string' ? data.prompt
+                : (typeof data.message === 'object'
+                    ? data.message?.content
+                    : undefined);
+            const prompt = typeof rawPrompt === 'string' ? rawPrompt.slice(0, 8_000) : null;
+            // Close previous turn if open — read index BEFORE delete
+            const prevIndex = this.sessionToTurn.get(sessionId)?.index ?? -1;
+            this.closeTurn(sessionId);
+            // Open new turn
+            const turnIndex = prevIndex + 1;
+            const run = this.store.getRun(runId);
+            const projectPath = run?.projectPath ?? undefined;
+            const turnId = randomUUID();
+            const turn = {
+                id: turnId, runId, index: turnIndex,
+                startedAt: Date.now(), toolCalls: 0,
+                filesModified: 0, filesCreated: 0,
+                gitBefore: readGitHead(projectPath),
+            };
+            this.sessionToTurn.set(sessionId, turn);
+            // Ensure an active task exists so this turn can attach to it. Tasks group
+            // consecutive turns between boundary signals (TodoWrite all-completed,
+            // /clear, session_end). First turn in a run opens task 0.
+            const task = this.openTaskIfNone(sessionId, runId);
+            if (task) {
+                if (task.firstTurnIndex === null)
+                    task.firstTurnIndex = turnIndex;
+                task.lastTurnIndex = turnIndex;
+            }
+            try {
+                this.store.insertTurn({
+                    id: turnId, runId, taskId: task?.id ?? null, turnIndex,
+                    prompt: prompt ?? undefined,
+                    startedAt: turn.startedAt, gitBefore: turn.gitBefore ?? undefined,
+                });
+            }
+            catch (err) {
+                debug('APME', `insertTurn failed: ${String(err)}`);
+            }
+            // Also set run's task_prompt from first prompt
+            try {
+                if (run && !run.taskPrompt && prompt) {
+                    this.store.updateRun(runId, { taskPrompt: prompt });
+                }
+            }
+            catch { /* ignore */ }
+        }
+        // Track tool calls on the active turn
+        const activeTurn = this.sessionToTurn.get(sessionId);
+        if (activeTurn && (event === 'PreToolUse' || event === 'tool_start')) {
+            activeTurn.toolCalls++;
+            if (toolName === 'Edit')
+                activeTurn.filesModified++;
+            if (toolName === 'Write')
+                activeTurn.filesCreated++;
+        }
+        // ── Task boundary: TodoWrite all-completed ──
+        // Claude Code's TodoWrite PostToolUse payload contains tool_input.todos.
+        // When every todo status is "completed", treat it as the agent declaring
+        // the task finished. Close the current task; the next UserPromptSubmit
+        // opens a fresh one.
+        if (event === 'PostToolUse' && toolName === 'TodoWrite') {
+            const todos = extractTodos(data);
+            if (todos && todos.length > 0 && todos.every((t) => t.status === 'completed')) {
+                this.closeTask(sessionId, 'todo_complete');
+            }
+        }
+        // Record step
+        try {
+            this.store.insertStep({
+                runId, ts: Date.now(), kind: event,
+                toolName, payload: safeStringify(data),
+            });
+        }
+        catch (err) {
+            debug('APME', `ingestHook failed: ${String(err)}`);
+        }
+    }
+    /** Close the current turn for a session (called on new prompt or session end). */
+    closeTurn(sessionId) {
+        const turn = this.sessionToTurn.get(sessionId);
+        if (!turn)
+            return;
+        this.sessionToLastTurnId.set(sessionId, turn.id);
+        this.sessionToTurn.delete(sessionId);
+        const run = this.store.getRun(turn.runId);
+        const projectPath = run?.projectPath ?? undefined;
+        const gitAfter = readGitHead(projectPath);
+        try {
+            this.store.updateTurn(turn.id, {
+                endedAt: Date.now(),
+                toolCalls: turn.toolCalls,
+                filesModified: turn.filesModified,
+                filesCreated: turn.filesCreated,
+                gitAfter,
+            });
+            debug('APME', `closeTurn ${turn.id.slice(0, 8)} index=${turn.index} tools=${turn.toolCalls}`);
+        }
+        catch (err) {
+            debug('APME', `closeTurn failed: ${String(err)}`);
+        }
+    }
+    /** Get the current active turn ID for a session (if any). */
+    getActiveTurnId(sessionId) {
+        return this.sessionToTurn.get(sessionId)?.id ?? null;
+    }
+    /** Get the current active task ID for a session (if any). Exposed for tests. */
+    getActiveTaskId(sessionId) {
+        return this.sessionToTask.get(sessionId)?.id ?? null;
+    }
+    /** Open a new task if none is active for this session. Returns the active
+     *  task (new or existing), or null if no run is open. Idempotent: repeat
+     *  calls while a task is already active are no-ops. */
+    openTaskIfNone(sessionId, runId) {
+        const existing = this.sessionToTask.get(sessionId);
+        if (existing)
+            return existing;
+        const nextIndex = this.runTaskCount.get(runId) ?? 0;
+        this.runTaskCount.set(runId, nextIndex + 1);
+        const task = {
+            id: randomUUID(),
+            runId,
+            index: nextIndex,
+            startedAt: Date.now(),
+            firstTurnIndex: null,
+            lastTurnIndex: null,
+        };
+        this.sessionToTask.set(sessionId, task);
+        try {
+            this.store.insertTask({
+                id: task.id,
+                runId,
+                taskIndex: task.index,
+                boundarySignal: 'open',
+                startedAt: task.startedAt,
+            });
+        }
+        catch (err) {
+            debug('APME', `insertTask failed: ${String(err)}`);
+        }
+        return task;
+    }
+    /** Close the current task for a session, persisting boundary metadata.
+     *  No-op if no task is active. Fires `onTaskClosed` so the runner can
+     *  enqueue a task-level judge call. Tasks that never saw a turn
+     *  (firstTurnIndex === null) are deleted rather than left as noise. */
+    closeTask(sessionId, boundarySignal) {
+        const task = this.sessionToTask.get(sessionId);
+        if (!task)
+            return;
+        this.sessionToTask.delete(sessionId);
+        // Empty task: no turns ever attached. Drop the row so the dashboard
+        // doesn't show phantom entries from back-to-back boundary signals.
+        if (task.firstTurnIndex === null) {
+            try {
+                // Direct delete — no DAO for it; tasks FK is ON DELETE CASCADE.
+                // We reach through the store via a raw statement to avoid adding
+                // a dedicated method for this edge case.
+                this.store.db
+                    ?.prepare('DELETE FROM tasks WHERE id = ?').run(task.id);
+            }
+            catch { /* ignore */ }
+            debug('APME', `closeTask ${task.id.slice(0, 8)} — empty, dropped`);
+            return;
+        }
+        // Derive task category from the run (best-effort). Turn-level categories
+        // may diverge, but for now tasks inherit from the run.
+        const run = this.store.getRun(task.runId);
+        const taskCategory = run?.taskCategory ?? null;
+        try {
+            this.store.updateTask(task.id, {
+                endedAt: Date.now(),
+                lastTurnIndex: task.lastTurnIndex ?? task.firstTurnIndex,
+                boundarySignal,
+                taskCategory,
+            });
+        }
+        catch (err) {
+            debug('APME', `updateTask failed: ${String(err)}`);
+        }
+        debug('APME', `closeTask ${task.id.slice(0, 8)} signal=${boundarySignal} turns=${task.firstTurnIndex}..${task.lastTurnIndex}`);
+        // Notify listeners (runner enqueueTask is wired via apme/index.ts).
+        if (this.onTaskClosed) {
+            try {
+                this.onTaskClosed({
+                    taskId: task.id,
+                    runId: task.runId,
+                    boundarySignal,
+                    taskCategory,
+                });
+            }
+            catch (err) {
+                debug('APME', `onTaskClosed listener threw: ${String(err)}`);
+            }
+        }
+    }
+    /** Get the current run ID for a session (if any). */
+    getRunId(sessionId) {
+        return this.sessionToRun.get(sessionId) ?? null;
+    }
+    /** Store Claude's response text on the current turn.
+     *  Falls back to the last closed turn if closeTurn() already ran (race with session exit).
+     *  Tags turns.efficiency_json.response_kind so the runner can skip tool-only / empty
+     *  turns — judging silence produces noise scores. */
+    setTurnResponse(sessionId, response) {
+        if (!this.store.enabled)
+            return;
+        const turn = this.sessionToTurn.get(sessionId);
+        const turnId = turn?.id ?? this.sessionToLastTurnId.get(sessionId);
+        debug('APME', `setTurnResponse session=${sessionId.slice(0, 8)} turnId=${turnId?.slice(0, 8) ?? 'null'} respLen=${response.length}`);
+        if (!turnId)
+            return;
+        const trimmedLen = response.trim().length;
+        // Active-turn toolCalls is authoritative; after closeTurn() the counter is
+        // already flushed to the DB row, so we fetch from there instead.
+        const toolCalls = turn?.toolCalls
+            ?? (this.store.getTurn(turnId)?.tool_calls ?? 0);
+        const kind = trimmedLen >= 1
+            ? 'text'
+            : (toolCalls > 0 ? 'tool_only' : 'empty');
+        const efficiencyJson = mergeEfficiencyJson(this.store.getTurn(turnId), { response_kind: kind });
+        try {
+            this.store.updateTurn(turnId, {
+                response: response.slice(0, 10_000),
+                efficiencyJson,
+            });
+        }
+        catch (err) {
+            debug('APME', `setTurnResponse failed: ${String(err)}`);
+        }
+    }
+    /** Apply response to the last closed turn if it has no response yet.
+     *  Used as fallback when Stop hook doesn't fire (PTY output capture). */
+    setLastClosedTurnResponse(sessionId, response) {
+        if (!this.store.enabled)
+            return;
+        const turnId = this.sessionToLastTurnId.get(sessionId);
+        if (!turnId)
+            return;
+        const existing = this.store.getTurn(turnId);
+        if (existing?.response)
+            return;
+        const trimmedLen = response.trim().length;
+        const toolCalls = existing?.tool_calls ?? 0;
+        const kind = trimmedLen >= 1
+            ? 'text'
+            : (toolCalls > 0 ? 'tool_only' : 'empty');
+        const efficiencyJson = mergeEfficiencyJson(existing, { response_kind: kind });
+        try {
+            this.store.updateTurn(turnId, {
+                response: response.slice(0, 10_000),
+                efficiencyJson,
+            });
+        }
+        catch { /* ignore */ }
+    }
+    /** Single-entrypoint ingestion using the shared TelemetrySpan envelope.
+     *
+     *  Adapters in `bridge/src/apme/adapters/*` translate per-source events
+     *  (Claude hooks / PTY parser / OpenClaw timeline / Codex) into spans;
+     *  this method dispatches each span to the appropriate legacy collector
+     *  method so existing race-handling and step-row insertion logic stays
+     *  intact. New ingestion paths should prefer this entrypoint over
+     *  `ingestHook` / `setTurnResponse` directly. */
+    ingestSpan(sessionId, span) {
+        if (!this.store.enabled)
+            return;
+        const a = span.attributes;
+        switch (span.kind) {
+            case 'turn_start': {
+                const prompt = a['agentdeck.prompt_text'] ?? '';
+                // Reuse the canonical UserPromptSubmit path so step row, prev-turn close,
+                // task auto-open, and run.task_prompt seeding all behave identically.
+                this.ingestHook(sessionId, 'UserPromptSubmit', { message: { content: prompt } });
+                return;
+            }
+            case 'turn_response': {
+                const text = a['agentdeck.response_text'] ?? '';
+                const fallback = a['agentdeck.fallback_to_last_closed'] === true;
+                if (fallback)
+                    this.setLastClosedTurnResponse(sessionId, text);
+                else
+                    this.setTurnResponse(sessionId, text);
+                return;
+            }
+            case 'turn_end':
+                // No-op: turns auto-close on the next `turn_start` or session end.
+                return;
+            case 'tool_call': {
+                const toolName = (a['gen_ai.tool.name'] ?? a['agentdeck.tool_name']);
+                const raw = a['agentdeck.raw_payload'] ?? {};
+                this.ingestHook(sessionId, 'PreToolUse', { tool_name: toolName, ...raw });
+                return;
+            }
+            case 'tool_result': {
+                const toolName = (a['gen_ai.tool.name'] ?? a['agentdeck.tool_name']);
+                const raw = a['agentdeck.raw_payload'] ?? {};
+                // PostToolUse + TodoWrite all-completed → existing ingestHook path
+                // detects todo_complete boundary automatically, so adapters don't
+                // need to emit a separate task_boundary span for that case.
+                this.ingestHook(sessionId, 'PostToolUse', { tool_name: toolName, ...raw });
+                return;
+            }
+            case 'task_boundary': {
+                const signal = a['agentdeck.boundary_signal'];
+                if (signal === 'clear') {
+                    this.splitRun(sessionId, a['agentdeck.cwd']);
+                    return;
+                }
+                // Other boundary signals (todo_complete, session_end) are handled
+                // automatically: tool_result detects todo_complete, closeRun closes
+                // the current task with session_end. Adapters that emit those
+                // spans explicitly are no-ops here by design — preserving the
+                // single-source-of-truth for those transitions.
+                return;
+            }
+            case 'session_meta': {
+                const model = a['gen_ai.request.model'];
+                if (model)
+                    this.updateModel(sessionId, model);
+                const inputTokens = a['agentdeck.usage.input_tokens'];
+                const outputTokens = a['agentdeck.usage.output_tokens'];
+                const costUsd = a['agentdeck.usage.cost_usd'];
+                if (inputTokens !== undefined || outputTokens !== undefined || costUsd !== undefined) {
+                    // Synthesize a UsageSnapshot-compatible shape. Missing fields stay null.
+                    this.updateUsage(sessionId, {
+                        inputTokens: inputTokens ?? 0,
+                        outputTokens: outputTokens ?? 0,
+                        estimatedCostUsd: costUsd ?? null,
+                    });
+                }
+                return;
+            }
+            case 'raw_step': {
+                const event = a['agentdeck.raw_event'] ?? 'raw';
+                const payload = a['agentdeck.raw_payload'] ?? {};
+                this.ingestHook(sessionId, event, payload);
+                return;
+            }
+        }
+    }
+    /** Ingest a generic timeline-style event (non-hook). */
+    ingestStep(sessionId, kind, payload, toolName) {
+        if (!this.store.enabled)
+            return;
+        const runId = this.sessionToRun.get(sessionId);
+        if (!runId)
+            return;
+        try {
+            this.store.insertStep({
+                runId, ts: Date.now(), kind,
+                toolName: toolName ?? null,
+                payload: safeStringify(payload),
+            });
+        }
+        catch { /* ignore */ }
+    }
+    /** Update token / cost columns from the bridge's UsageTracker snapshot. */
+    updateUsage(sessionId, snapshot) {
+        if (!this.store.enabled)
+            return;
+        const runId = this.sessionToRun.get(sessionId);
+        if (!runId)
+            return;
+        try {
+            this.store.updateRun(runId, {
+                inputTokens: snapshot.inputTokens,
+                outputTokens: snapshot.outputTokens,
+                costUsd: snapshot.estimatedCostUsd ?? snapshot.costSpent ?? null,
+            });
+        }
+        catch { /* ignore */ }
+    }
+    /** Split the current run — closes the active run and opens a fresh one.
+     *  Triggered on `/clear` or other context-reset events so each logical
+     *  conversation gets its own evaluation unit. */
+    splitRun(sessionId, projectPath) {
+        if (!this.store.enabled)
+            return null;
+        const runId = this.sessionToRun.get(sessionId);
+        if (!runId)
+            return null;
+        const run = this.store.getRun(runId);
+        if (!run)
+            return null;
+        // The active task (if any) belongs to the run being closed; mark it as
+        // boundary=clear before closeRun tears everything down.
+        this.closeTask(sessionId, 'clear');
+        // Close current run (no exitCode — session is still alive)
+        this.closeRun(sessionId, undefined, projectPath);
+        // Open a new run with the same session parameters
+        return this.openRun({
+            sessionId,
+            agentType: run.agentType,
+            modelId: run.modelId ?? undefined,
+            projectName: run.projectName ?? undefined,
+            projectPath: run.projectPath ?? undefined,
+        });
+    }
+    /** Update model id when the bridge resolves which model is in use. */
+    updateModel(sessionId, modelId) {
+        if (!this.store.enabled || !modelId)
+            return;
+        const runId = this.sessionToRun.get(sessionId);
+        if (!runId)
+            return;
+        try {
+            this.store.updateRun(runId, { modelId });
+        }
+        catch { /* ignore */ }
+    }
+    /** Finalize a run. Returns the runId so callers can enqueue evaluation.
+     *  Empty runs (no prompts, no steps, no turns) are deleted — they're just
+     *  connection noise and clutter the dashboard. */
+    closeRun(sessionId, exitCode, projectPath) {
+        if (!this.store.enabled)
+            return null;
+        const runId = this.sessionToRun.get(sessionId);
+        if (!runId)
+            return null;
+        // Close the last open turn + task before finalizing the run.
+        this.closeTurn(sessionId);
+        // splitRun already called closeTask('clear') before us, so this is usually
+        // a no-op in the split path. Direct closeRun (session exit) still needs it.
+        this.closeTask(sessionId, 'session_end');
+        this.sessionToRun.delete(sessionId);
+        this.sessionToLastTurnId.delete(sessionId);
+        this.runTaskCount.delete(runId);
+        // Mark empty runs so the dashboard can filter them out.
+        // Don't delete — FK constraints and concurrent access make deletion risky.
+        const run = this.store.getRun(runId);
+        const steps = this.store.listSteps(runId);
+        const meaningfulSteps = steps.filter(s => s.kind !== 'SessionEnd' && s.kind !== 'session_end' && s.kind !== 'session_start' && s.kind !== 'SessionStart');
+        const isEmpty = !run?.taskPrompt && meaningfulSteps.length === 0;
+        const gitAfter = readGitHead(projectPath);
+        try {
+            this.store.updateRun(runId, {
+                endedAt: Date.now(),
+                exitCode: exitCode ?? null,
+                gitAfter,
+                // Tag empty runs so dashboard can filter them
+                ...(isEmpty ? { taskCategory: '_empty' } : {}),
+            });
+            if (isEmpty) {
+                debug('APME', `closeRun ${runId} — empty (no prompt, no steps)`);
+                return runId;
+            }
+            debug('APME', `closeRun ${runId} exit=${exitCode ?? '-'} gitAfter=${gitAfter ?? '-'}`);
+        }
+        catch (err) {
+            debug('APME', `closeRun failed: ${String(err)}`);
+        }
+        // Capture hardware profile asynchronously — don't block shutdown.
+        if (this.hwSampler) {
+            this.hwSampler.snapshot().then((snap) => {
+                try {
+                    this.store.updateRun(runId, { hwProfile: JSON.stringify(snap) });
+                }
+                catch { /* ignore */ }
+            }).catch(() => { });
+        }
+        // Classify the run — rule-based first, LLM fallback if unknown.
+        // Fire-and-forget since classifyRunSmart is async (LLM call).
+        void classifyRunSmart(this.store, runId).then(({ signals, category, source }) => {
+            this.store.updateRun(runId, {
+                taskSignals: JSON.stringify(signals),
+                taskCategory: category,
+                taskCategorySource: source,
+            });
+            debug('APME', `classified ${runId} as ${category} (${source})`);
+        }).catch((err) => {
+            debug('APME', `classify failed: ${String(err)}`);
+        });
+        // Save git diff as artifact (best-effort, capped at 1MB).
+        this.saveDiffArtifact(runId, projectPath);
+        return runId;
+    }
+    /** Save the git diff produced by this run as an artifact file. */
+    saveDiffArtifact(runId, projectPath) {
+        if (!projectPath)
+            return;
+        try {
+            const run = this.store.getRun(runId);
+            if (!run)
+                return;
+            const args = run.gitBefore && run.gitAfter && run.gitBefore !== run.gitAfter
+                ? `diff ${run.gitBefore}..${run.gitAfter}`
+                : 'diff HEAD';
+            const diff = execSync(`git ${args}`, {
+                cwd: projectPath, encoding: 'utf-8', timeout: 5000,
+                maxBuffer: 1024 * 1024, stdio: ['ignore', 'pipe', 'ignore'],
+            });
+            if (!diff || diff.length < 10)
+                return;
+            const hash = createHash('sha256').update(diff).digest('hex').slice(0, 16);
+            const artifactDir = getArtifactDir(runId);
+            mkdirSync(artifactDir, { recursive: true });
+            const filePath = join(artifactDir, `${hash}.diff`);
+            writeFileSync(filePath, diff, 'utf-8');
+            this.store.insertArtifact({
+                runId, kind: 'diff', path: filePath,
+                sha256: createHash('sha256').update(diff).digest('hex'),
+                bytes: Buffer.byteLength(diff, 'utf-8'),
+            });
+        }
+        catch { /* ignore — artifact storage is best-effort */ }
+    }
+    /** Translate a `SessionEntry` + optional extras into an OpenRunInput. */
+    static fromSessionEntry(entry, extras = {}) {
+        return {
+            sessionId: entry.id,
+            agentType: (entry.agentType ?? 'claude-code'),
+            modelId: extras.modelId,
+            projectName: entry.projectName,
+            projectPath: extras.projectPath,
+        };
+    }
+}
+/** Extract the todos array from a TodoWrite PostToolUse payload. Returns null
+ *  if the shape doesn't match (payload malformed, older CC versions). Accepts
+ *  `tool_input.todos` (hook standard) and `todos` (legacy flat shape). */
+function extractTodos(data) {
+    const fromToolInput = data.tool_input?.todos;
+    const fromFlat = data.todos;
+    const raw = fromToolInput ?? fromFlat;
+    if (!Array.isArray(raw))
+        return null;
+    const items = [];
+    for (const entry of raw) {
+        if (!entry || typeof entry !== 'object')
+            continue;
+        const e = entry;
+        const status = typeof e.status === 'string' ? e.status : '';
+        if (!status)
+            continue;
+        items.push({
+            status,
+            content: typeof e.content === 'string' ? e.content : undefined,
+            activeForm: typeof e.activeForm === 'string' ? e.activeForm : undefined,
+        });
+    }
+    return items;
+}
+function readGitHead(cwd) {
+    if (!cwd)
+        return null;
+    try {
+        return execSync('git rev-parse HEAD', {
+            cwd, encoding: 'utf-8', stdio: ['ignore', 'pipe', 'ignore'], timeout: 2000,
+        }).trim() || null;
+    }
+    catch {
+        return null;
+    }
+}
+function getArtifactDir(runId) {
+    const dataDir = process.env.AGENTDECK_DATA_DIR || join(homedir(), '.agentdeck');
+    return join(dataDir, 'apme', 'artifacts', runId);
+}
+function safeStringify(v) {
+    try {
+        return JSON.stringify(v);
+    }
+    catch {
+        return '"<unserializable>"';
+    }
+}
+/** Merge `patch` into an existing turns.efficiency_json string without losing
+ *  sibling keys. Returns a JSON string suitable for the column. Unparseable
+ *  existing values are replaced outright. */
+function mergeEfficiencyJson(turn, patch) {
+    let base = {};
+    const raw = turn?.efficiency_json;
+    if (typeof raw === 'string' && raw.length > 0) {
+        try {
+            const parsed = JSON.parse(raw);
+            if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+                base = parsed;
+            }
+        }
+        catch { /* replace */ }
+    }
+    return JSON.stringify({ ...base, ...patch });
+}
+//# sourceMappingURL=collector.js.map