sidekick-shared 0.27.6 → 0.28.0

package/dist/esm/aggregation/EventAggregator.js

@@ -0,0 +1,2034 @@
+/**
+ * Shared event aggregation engine.
+ *
+ * Pure computation class (no I/O, no framework dependencies) that processes
+ * SessionEvent and FollowEvent objects to accumulate session metrics.
+ * Both the VS Code SessionMonitor and CLI DashboardState delegate to this.
+ *
+ * @module aggregation/EventAggregator
+ */
+import { TRUNCATION_PATTERNS } from '../parsers/jsonl';
+import { PlanExtractor } from '../parsers/planExtractor';
+import { toFollowEvents } from '../watchers/eventBridge';
+import { formatToolSummary } from '../formatters/toolSummary';
+import { isHardNoise, isHardNoiseFollowEvent, getSoftNoiseReason, classifyMessage, classifyFollowEvent, } from '../formatters/noiseClassifier';
+import { classifyCostProvenance } from './costProvenance';
+import { FrequencyTracker } from './FrequencyTracker';
+import { HeatmapTracker } from './HeatmapTracker';
+import { PatternExtractor } from './PatternExtractor';
+import { categorizeError } from '../extractors/errorTaxonomy';
+import { estimateTextTokens } from '../tokenEstimation';
+import { calculateNormalizedUsageCost, extractNormalizedUsage, normalizeProviderUsage, } from '../usageNormalization';
+// ── Defaults ──
+const DEFAULT_TIMELINE_CAP = 200;
+const DEFAULT_LATENCY_CAP = 100;
+const DEFAULT_CONTEXT_TIMELINE_CAP = 2_000;
+const DEFAULT_BURN_WINDOW_MS = 5 * 60_000;
+const DEFAULT_BURN_SAMPLE_MS = 10_000;
+const COMPACTION_DROP_THRESHOLD = 0.8; // >20% drop
+/** Schema version for serialized snapshots. v6: token totals count each Claude response and Codex call once. */
+export const SNAPSHOT_SCHEMA_VERSION = 6;
+// ── Goal gate detection regex ──
+const GOAL_GATE_REGEX = /\b(CRITICAL|MUST|blocker|required|must.?complete|goal.?gate|essential|do.?not.?skip|blocking)\b/i;
+// ── Todo dependency parsing ──
+/**
+ * Parses dependency references from a todo item's content text.
+ *
+ * Looks for patterns like "(blocked by Task A and Task B)" and maps
+ * referenced task names back to todo-{i} IDs by substring matching.
+ */
+export function parseTodoDependencies(content, allTodos) {
+    const depPattern = /(?:blocked by|depends on|waiting on|requires)\s+(.+?)(?:\)|$)/i;
+    const match = content.match(depPattern);
+    if (!match)
+        return [];
+    const refs = match[1]
+        .split(/\s+and\s+|,\s*|&\s*/)
+        .map((r) => r.trim())
+        .filter(Boolean);
+    const result = [];
+    for (const ref of refs) {
+        const refLower = ref.toLowerCase();
+        for (let j = 0; j < allTodos.length; j++) {
+            const otherContent = String(allTodos[j].content || allTodos[j].subject || '').toLowerCase();
+            if (otherContent.includes(refLower) || refLower.includes(otherContent.split(':')[0].trim())) {
+                result.push(`todo-${j}`);
+                break;
+            }
+        }
+    }
+    return result;
+}
+// ── EventAggregator ──
+export class EventAggregator {
+    // Options
+    timelineCap;
+    latencyCap;
+    burnWindowMs;
+    burnSampleMs;
+    computeContextSize;
+    providerId;
+    // Token totals
+    inputTokens = 0;
+    outputTokens = 0;
+    cacheWriteTokens = 0;
+    cacheReadTokens = 0;
+    reasoningTokens = 0;
+    totalTokens = 0;
+    /** Running cost in USD (reported + estimated). */
+    costUsd = 0;
+    reportedCostUsd = 0;
+    estimatedCostUsd = 0;
+    reportedCalls = 0;
+    estimatedCalls = 0;
+    unpricedCalls = 0;
+    // Per-model usage
+    modelUsage = new Map();
+    // Context size tracking
+    currentContextSize = 0;
+    previousContextSize = 0;
+    /**
+     * Index of a heuristic compaction event still awaiting its real
+     * post-compaction size from the next usage event. Prevents the usage-drop
+     * detector from double-counting an explicit compaction marker.
+     */
+    pendingHeuristicCompactionIndex = null;
+    // Compaction
+    compactionEvents = [];
+    // Truncation
+    truncationEvents = [];
+    // Tool analytics
+    toolAnalytics = new Map();
+    pendingToolCalls = new Map();
+    errorByToolCategory = new Map();
+    errorBuckets = new Map();
+    retryAttempts = 0;
+    finishReasons = new Map();
+    // Burn rate
+    burnSamples = [];
+    lastBurnSampleTime = 0;
+    tokensSinceLastSample = 0;
+    // Task state
+    tasks = new Map();
+    pendingTaskCreates = new Map();
+    activeTaskId = null;
+    // Subagent lifecycle
+    subagents = [];
+    pendingSubagents = new Map(); // toolUseId -> index
+    // Plan state
+    planExtractor;
+    planState = null;
+    planEnteredAt;
+    // Context attribution
+    contextAttribution = {
+        systemPrompt: 0,
+        userMessages: 0,
+        assistantResponses: 0,
+        toolInputs: 0,
+        toolOutputs: 0,
+        thinking: 0,
+        other: 0,
+    };
+    // Permission mode
+    currentPermissionMode = null;
+    permissionModeHistory = [];
+    // Context timeline
+    contextTimeline = [];
+    contextTimelineCap;
+    contextTurnIndex = 0;
+    // Timeline
+    timeline = [];
+    // Latency tracking
+    pendingUserRequest = null;
+    latencyRecords = [];
+    // Counters
+    messageCount = 0;
+    eventCount = 0;
+    sessionStartTime = null;
+    lastEventTime = null;
+    currentModel = null;
+    _providerId = null;
+    // Gonzo/Lazyjournal analytics
+    toolFrequency = new FrequencyTracker();
+    wordFrequency = new FrequencyTracker();
+    patternExtractor = new PatternExtractor();
+    heatmapTracker = new HeatmapTracker();
+    constructor(options) {
+        this.timelineCap = options?.timelineCap ?? DEFAULT_TIMELINE_CAP;
+        this.latencyCap = options?.latencyCap ?? DEFAULT_LATENCY_CAP;
+        this.burnWindowMs = options?.burnWindowMs ?? DEFAULT_BURN_WINDOW_MS;
+        this.burnSampleMs = options?.burnSampleMs ?? DEFAULT_BURN_SAMPLE_MS;
+        this.contextTimelineCap = options?.contextTimelineCap ?? DEFAULT_CONTEXT_TIMELINE_CAP;
+        this.computeContextSize = options?.computeContextSize ?? null;
+        this.providerId = options?.providerId ?? null;
+        this._providerId = this.providerId;
+        this.planExtractor = new PlanExtractor(options?.readPlanFile);
+    }
+    // ═══════════════════════════════════════════════════════════════════════
+    // processEvent — main entry for SessionEvent
+    // ═══════════════════════════════════════════════════════════════════════
+    processEvent(event) {
+        // 1. Increment counters, capture timestamps
+        this.eventCount++;
+        if (!this.sessionStartTime) {
+            this.sessionStartTime = event.timestamp;
+        }
+        this.lastEventTime = event.timestamp;
+        this.recordProviderMetadata(event);
+        // Bookkeeping rows can be useful without a message payload.
+        if (!event.message) {
+            if (event.type === 'summary') {
+                this.recordExplicitCompaction(event.timestamp, event.compaction);
+            }
+            this.trackPermissionMode(event);
+            this.addTimelineFromSessionEvent(event);
+            this.feedAnalytics(event.timestamp, event.type === 'summary' ? (event.summary ?? '') : '', this.extractToolNameFromEvent(event));
+            return;
+        }
+        // 2. Track model
+        if (event.message.model) {
+            this.currentModel = event.message.model;
+        }
+        // 3. Skip system/audit events and synthetic token-count events for messageCount
+        const msgId = event.message.id ?? '';
+        if ((event.type === 'user' || event.type === 'assistant') &&
+            !msgId.startsWith('token-count-')) {
+            this.messageCount++;
+        }
+        // 4. Latency tracking
+        if (event.type !== 'system') {
+            this.processLatency(event);
+        }
+        // 5. Token accumulation
+        const normalizedUsage = extractNormalizedUsage(event);
+        if (normalizedUsage) {
+            const usageCost = this.accumulateUsage(normalizedUsage, event.timestamp, event.message.model, event.message.usageKind);
+            this.attributePlanUsage(normalizedUsage.totalTokens, usageCost);
+        }
+        if (event.type !== 'system') {
+            // 6. Tool extraction from content blocks
+            this.extractToolsFromContent(event);
+            // 7. Task state
+            this.extractTaskStateFromEvent(event);
+            // 8. Subagent tracking
+            this.extractSubagentFromEvent(event);
+            // 9. Plan extraction — convert SessionEvent to a FollowEvent shape for PlanExtractor
+            this.extractPlanFromSessionEvent(event);
+        }
+        // 10. Context attribution
+        this.attributeContextFromEvent(event);
+        // 11. Permission mode tracking
+        this.trackPermissionMode(event);
+        if (event.type === 'summary') {
+            this.recordExplicitCompaction(event.timestamp, event.compaction);
+        }
+        // 12. Timeline
+        this.addTimelineFromSessionEvent(event);
+        // 13. Gonzo/Lazyjournal analytics
+        const summary = this.extractTextContent(event) ?? '';
+        const toolName = this.extractToolNameFromEvent(event);
+        this.feedAnalytics(event.timestamp, summary, toolName);
+    }
+    // ═══════════════════════════════════════════════════════════════════════
+    // processFollowEvent — adapter for CLI FollowEvent format
+    // ═══════════════════════════════════════════════════════════════════════
+    processFollowEvent(event) {
+        // 1. Increment counters, capture timestamps
+        this.eventCount++;
+        if (!this.sessionStartTime) {
+            this.sessionStartTime = event.timestamp;
+        }
+        this.lastEventTime = event.timestamp;
+        // Provider
+        if (!this._providerId && event.providerId) {
+            this._providerId = event.providerId;
+        }
+        // 2. Model tracking
+        if (event.model) {
+            this.currentModel = event.model;
+        }
+        // 3. Token accumulation from FollowEvent fields
+        if (event.tokens) {
+            const normalized = normalizeProviderUsage({
+                semantics: 'sidekick',
+                provider: event.providerId,
+                source: 'follow-event',
+                model: event.model,
+                inputTokens: event.tokens.input,
+                outputTokens: event.tokens.output,
+                cacheReadTokens: event.cacheTokens?.read,
+                cacheWriteTokens: event.cacheTokens?.write,
+                reasoningIncludedInOutput: false,
+                reportedCostUsd: event.cost,
+            });
+            const cost = this.accumulateUsage(normalized, event.timestamp, event.model, event.usageKind);
+            this.attributePlanUsage(normalized.totalTokens, cost);
+        }
+        else if (typeof event.cost === 'number' && Number.isFinite(event.cost) && event.cost >= 0) {
+            // Compatibility for cost-only follow events (provider-reported by definition).
+            this.costUsd += event.cost;
+            this.reportedCostUsd += event.cost;
+            this.reportedCalls += 1;
+        }
+        // 4. Tool tracking from FollowEvent
+        if (event.type === 'tool_use' && event.toolName) {
+            this.recordFollowToolUse(event);
+            this.attributePlanToolCall(event.toolName);
+        }
+        else if (event.type === 'tool_result') {
+            this.recordFollowToolResult(event);
+        }
+        // 5. Task state extraction
+        this.extractTaskStateFromFollowEvent(event);
+        // 6. Subagent tracking
+        this.extractSubagentFromFollowEvent(event);
+        // 7. Plan extraction
+        this.processPlanFollowEvent(event);
+        // 8. Context attribution
+        this.attributeContextFromFollowEvent(event);
+        // 9. Truncation detection from tool results
+        if (event.type === 'tool_result') {
+            this.detectTruncationFromFollowEvent(event);
+        }
+        // 10. Explicit compaction event (summary type)
+        if (event.type === 'summary') {
+            this.recordExplicitCompaction(event.timestamp, event.compaction);
+        }
+        // 11. Timeline
+        this.addTimelineFromFollowEvent(event);
+        // 12. Gonzo/Lazyjournal analytics
+        this.feedAnalytics(event.timestamp, event.summary, event.toolName);
+        // Message count (skip system events)
+        if (event.type === 'user' || event.type === 'assistant') {
+            this.messageCount++;
+        }
+    }
+    // ═══════════════════════════════════════════════════════════════════════
+    // Public getters
+    // ═══════════════════════════════════════════════════════════════════════
+    getAggregatedTokens() {
+        return {
+            inputTokens: this.inputTokens,
+            outputTokens: this.outputTokens,
+            cacheWriteTokens: this.cacheWriteTokens,
+            cacheReadTokens: this.cacheReadTokens,
+            reasoningTokens: this.reasoningTokens,
+            totalTokens: this.totalTokens,
+            costUsd: this.costUsd,
+            reportedCostUsd: this.reportedCostUsd,
+            estimatedCostUsd: this.estimatedCostUsd,
+            unpricedCalls: this.unpricedCalls,
+            costProvenance: classifyCostProvenance({
+                reportedCalls: this.reportedCalls,
+                estimatedCalls: this.estimatedCalls,
+                unpricedCalls: this.unpricedCalls,
+            }),
+            reportedCost: this.costUsd,
+        };
+    }
+    getModelStats() {
+        return Array.from(this.modelUsage.entries())
+            .map(([model, acc]) => ({ model, ...acc }))
+            .sort((a, b) => b.calls - a.calls);
+    }
+    getToolStats() {
+        return Array.from(this.toolAnalytics.values()).sort((a, b) => b.successCount +
+            b.failureCount +
+            b.pendingCount -
+            (a.successCount + a.failureCount + a.pendingCount));
+    }
+    getErrorRollup() {
+        return {
+            totalFailures: Array.from(this.errorByToolCategory.values()).reduce((sum, entry) => sum + entry.count, 0),
+            byToolCategory: Array.from(this.errorByToolCategory.values()).sort((a, b) => b.count - a.count),
+            byHourModel: Array.from(this.errorBuckets.values()).sort((a, b) => a.hour.localeCompare(b.hour)),
+            retryAttempts: this.retryAttempts,
+            finishReasons: Array.from(this.finishReasons, ([reason, count]) => ({ reason, count })).sort((a, b) => b.count - a.count),
+        };
+    }
+    getCompactionEvents() {
+        return [...this.compactionEvents];
+    }
+    getTruncationEvents() {
+        return [...this.truncationEvents];
+    }
+    getBurnRate() {
+        const points = this.burnSamples.map((s) => s.tokens);
+        const tokensPerMinute = points.length > 0 ? points[points.length - 1] : 0;
+        return {
+            tokensPerMinute,
+            points: [...points],
+            sampleCount: this.burnSamples.length,
+        };
+    }
+    getTaskState() {
+        return {
+            tasks: new Map(this.tasks),
+            activeTaskId: this.activeTaskId,
+        };
+    }
+    getSubagents() {
+        return [...this.subagents];
+    }
+    getPlan() {
+        return this.planState
+            ? { ...this.planState, steps: this.planState.steps.map((step) => ({ ...step })) }
+            : null;
+    }
+    getContextAttribution() {
+        return { ...this.contextAttribution };
+    }
+    getTimeline() {
+        return [...this.timeline];
+    }
+    getLatencyStats() {
+        if (this.latencyRecords.length === 0)
+            return null;
+        const records = this.latencyRecords;
+        const totalFirstToken = records.reduce((sum, r) => sum + r.firstTokenLatencyMs, 0);
+        const totalResponse = records.reduce((sum, r) => sum + r.totalResponseTimeMs, 0);
+        const maxFirstToken = Math.max(...records.map((r) => r.firstTokenLatencyMs));
+        const last = records[records.length - 1];
+        return {
+            recentLatencies: [...records],
+            avgFirstTokenLatencyMs: Math.round(totalFirstToken / records.length),
+            maxFirstTokenLatencyMs: maxFirstToken,
+            avgTotalResponseTimeMs: Math.round(totalResponse / records.length),
+            lastFirstTokenLatencyMs: last ? last.firstTokenLatencyMs : null,
+            completedCycles: records.length,
+        };
+    }
+    getMetrics() {
+        return {
+            sessionStartTime: this.sessionStartTime,
+            lastEventTime: this.lastEventTime,
+            messageCount: this.messageCount,
+            eventCount: this.eventCount,
+            currentModel: this.currentModel,
+            providerId: this._providerId,
+            tokens: this.getAggregatedTokens(),
+            modelStats: this.getModelStats(),
+            currentContextSize: this.currentContextSize,
+            contextAttribution: this.getContextAttribution(),
+            compactionCount: this.compactionEvents.length,
+            compactionEvents: this.getCompactionEvents(),
+            truncationCount: this.truncationEvents.length,
+            truncationEvents: this.getTruncationEvents(),
+            toolStats: this.getToolStats(),
+            errorRollup: this.getErrorRollup(),
+            burnRate: this.getBurnRate(),
+            taskState: this.getTaskState(),
+            subagents: this.getSubagents(),
+            plan: this.getPlan(),
+            permissionMode: this.currentPermissionMode,
+            permissionModeHistory: [...this.permissionModeHistory],
+            contextTimeline: [...this.contextTimeline],
+            timeline: this.getTimeline(),
+            latencyStats: this.getLatencyStats(),
+            toolFrequency: this.toolFrequency.getTopN(20).map((e) => ({ name: e.key, count: e.count })),
+            wordFrequency: this.wordFrequency.getTopN(20).map((e) => ({ name: e.key, count: e.count })),
+            patterns: this.patternExtractor.getPatterns().slice(0, 20),
+            heatmapBuckets: this.heatmapTracker.getBuckets(),
+        };
+    }
+    // ═══════════════════════════════════════════════════════════════════════
+    // reset — clear all state
+    // ═══════════════════════════════════════════════════════════════════════
+    reset() {
+        this.inputTokens = 0;
+        this.outputTokens = 0;
+        this.cacheWriteTokens = 0;
+        this.cacheReadTokens = 0;
+        this.reasoningTokens = 0;
+        this.totalTokens = 0;
+        this.costUsd = 0;
+        this.reportedCostUsd = 0;
+        this.estimatedCostUsd = 0;
+        this.reportedCalls = 0;
+        this.estimatedCalls = 0;
+        this.unpricedCalls = 0;
+        this.modelUsage.clear();
+        this.currentContextSize = 0;
+        this.previousContextSize = 0;
+        this.compactionEvents = [];
+        this.truncationEvents = [];
+        this.toolAnalytics.clear();
+        this.pendingToolCalls.clear();
+        this.errorByToolCategory.clear();
+        this.errorBuckets.clear();
+        this.retryAttempts = 0;
+        this.finishReasons.clear();
+        this.burnSamples = [];
+        this.lastBurnSampleTime = 0;
+        this.tokensSinceLastSample = 0;
+        this.tasks.clear();
+        this.pendingTaskCreates.clear();
+        this.activeTaskId = null;
+        this.subagents = [];
+        this.pendingSubagents.clear();
+        this.planExtractor.reset();
+        this.planState = null;
+        this.planEnteredAt = undefined;
+        this.currentPermissionMode = null;
+        this.permissionModeHistory = [];
+        this.contextTimeline = [];
+        this.contextTurnIndex = 0;
+        this.contextAttribution = {
+            systemPrompt: 0,
+            userMessages: 0,
+            assistantResponses: 0,
+            toolInputs: 0,
+            toolOutputs: 0,
+            thinking: 0,
+            other: 0,
+        };
+        this.timeline = [];
+        this.pendingUserRequest = null;
+        this.latencyRecords = [];
+        this.toolFrequency.reset();
+        this.wordFrequency.reset();
+        this.patternExtractor.reset();
+        this.heatmapTracker.reset();
+        this.messageCount = 0;
+        this.eventCount = 0;
+        this.sessionStartTime = null;
+        this.lastEventTime = null;
+        this.currentModel = null;
+        this._providerId = this.providerId;
+    }
+    // ═══════════════════════════════════════════════════════════════════════
+    // Seed methods — for initializing state from provider snapshots
+    // ═══════════════════════════════════════════════════════════════════════
+    /** Seeds the current context size (e.g., from a provider usage snapshot on attach). */
+    seedContextSize(size) {
+        this.currentContextSize = size;
+        this.previousContextSize = size;
+    }
+    /** Seeds context attribution (e.g., from a provider's DB-backed attribution). */
+    seedContextAttribution(attribution) {
+        this.contextAttribution = { ...attribution };
+    }
+    // ═══════════════════════════════════════════════════════════════════════
+    // Snapshot serialization — for fast session resume
+    // ═══════════════════════════════════════════════════════════════════════
+    /** Serializes all mutable state to a JSON-safe object for snapshot persistence. */
+    serialize() {
+        return {
+            version: SNAPSHOT_SCHEMA_VERSION,
+            tokens: {
+                input: this.inputTokens,
+                output: this.outputTokens,
+                cacheWrite: this.cacheWriteTokens,
+                cacheRead: this.cacheReadTokens,
+                reasoning: this.reasoningTokens,
+                total: this.totalTokens,
+                reportedCost: this.costUsd,
+                costUsd: this.costUsd,
+                reportedCostUsd: this.reportedCostUsd,
+                estimatedCostUsd: this.estimatedCostUsd,
+                reportedCalls: this.reportedCalls,
+                estimatedCalls: this.estimatedCalls,
+                unpricedCalls: this.unpricedCalls,
+            },
+            modelUsage: Array.from(this.modelUsage.entries()),
+            contextSize: this.currentContextSize,
+            previousContextSize: this.previousContextSize,
+            compactionEvents: this.compactionEvents,
+            truncationEvents: this.truncationEvents,
+            toolAnalytics: Array.from(this.toolAnalytics.entries()),
+            errorByToolCategory: Array.from(this.errorByToolCategory.entries()),
+            errorBuckets: Array.from(this.errorBuckets.entries()),
+            retryAttempts: this.retryAttempts,
+            finishReasons: Array.from(this.finishReasons.entries()),
+            contextAttribution: { ...this.contextAttribution },
+            burnSamples: [...this.burnSamples],
+            lastBurnSampleTime: this.lastBurnSampleTime,
+            tokensSinceLastSample: this.tokensSinceLastSample,
+            latencyRecords: [...this.latencyRecords],
+            tasks: Array.from(this.tasks.entries()),
+            activeTaskId: this.activeTaskId,
+            subagents: [...this.subagents],
+            permissionMode: this.currentPermissionMode,
+            permissionModeHistory: [...this.permissionModeHistory],
+            contextTimeline: [...this.contextTimeline],
+            contextTurnIndex: this.contextTurnIndex,
+            timeline: [...this.timeline],
+            messageCount: this.messageCount,
+            eventCount: this.eventCount,
+            sessionStartTime: this.sessionStartTime,
+            lastEventTime: this.lastEventTime,
+            currentModel: this.currentModel,
+            toolFrequency: this.toolFrequency.serialize(),
+            wordFrequency: this.wordFrequency.serialize(),
+            patternState: this.patternExtractor.serialize(),
+            heatmapState: this.heatmapTracker.serialize(),
+        };
+    }
+    /** Restores mutable state from a serialized snapshot. Clears transient state (pending calls). */
+    restore(state) {
+        if (state.version !== SNAPSHOT_SCHEMA_VERSION) {
+            return false;
+        }
+        this.inputTokens = state.tokens.input;
+        this.outputTokens = state.tokens.output;
+        this.cacheWriteTokens = state.tokens.cacheWrite;
+        this.cacheReadTokens = state.tokens.cacheRead;
+        this.reasoningTokens = state.tokens.reasoning;
+        this.totalTokens = state.tokens.total;
+        this.costUsd = state.tokens.costUsd;
+        this.reportedCostUsd = state.tokens.reportedCostUsd;
+        this.estimatedCostUsd = state.tokens.estimatedCostUsd;
+        this.reportedCalls = state.tokens.reportedCalls;
+        this.estimatedCalls = state.tokens.estimatedCalls;
+        this.unpricedCalls = state.tokens.unpricedCalls;
+        this.modelUsage = new Map(state.modelUsage);
+        this.currentContextSize = state.contextSize;
+        this.previousContextSize = state.previousContextSize;
+        this.compactionEvents = [...state.compactionEvents];
+        this.truncationEvents = [...state.truncationEvents];
+        this.toolAnalytics = new Map(state.toolAnalytics);
+        this.errorByToolCategory = new Map(state.errorByToolCategory);
+        this.errorBuckets = new Map(state.errorBuckets);
+        this.retryAttempts = state.retryAttempts;
+        this.finishReasons = new Map(state.finishReasons);
+        this.contextAttribution = { ...state.contextAttribution };
+        this.burnSamples = [...state.burnSamples];
+        this.lastBurnSampleTime = state.lastBurnSampleTime;
+        this.tokensSinceLastSample = state.tokensSinceLastSample;
+        this.latencyRecords = [...state.latencyRecords];
+        this.tasks = new Map(state.tasks);
+        this.activeTaskId = state.activeTaskId;
+        this.subagents = [...state.subagents];
+        this.currentPermissionMode = state.permissionMode ?? null;
+        this.permissionModeHistory = state.permissionModeHistory
+            ? [...state.permissionModeHistory]
+            : [];
+        this.contextTimeline = state.contextTimeline
+            ? state.contextTimeline.slice(-this.contextTimelineCap)
+            : [];
+        this.contextTurnIndex = state.contextTurnIndex ?? 0;
+        this.timeline = [...state.timeline];
+        this.messageCount = state.messageCount;
+        this.eventCount = state.eventCount;
+        this.sessionStartTime = state.sessionStartTime;
+        this.lastEventTime = state.lastEventTime;
+        this.currentModel = state.currentModel;
+        // Gonzo/Lazyjournal analytics restore
+        if (state.toolFrequency)
+            this.toolFrequency.restore(state.toolFrequency);
+        if (state.wordFrequency)
+            this.wordFrequency.restore(state.wordFrequency);
+        if (state.patternState)
+            this.patternExtractor.restore(state.patternState);
+        if (state.heatmapState)
+            this.heatmapTracker.restore(state.heatmapState);
+        // Clear transient state — pending calls won't survive a snapshot boundary
+        this.pendingToolCalls.clear();
+        this.pendingTaskCreates.clear();
+        this.pendingSubagents.clear();
+        this.pendingUserRequest = null;
+        this.planExtractor.reset();
+        return true;
+    }
+    // ═══════════════════════════════════════════════════════════════════════
+    // Private: Token & Context
+    // ═══════════════════════════════════════════════════════════════════════
+    /**
+     * Add one usage record to the running totals. A `'correction'` tops up a call
+     * already counted (a later split line of the same response grew), so it adds
+     * tokens and cost but no call, context sample, or compaction check.
+     */
+    accumulateUsage(usage, timestamp, model, kind = 'call') {
+        const isCall = kind !== 'correction';
+        const inputTok = usage.uncachedInputTokens;
+        const outputTok = usage.outputTokens;
+        const cacheWrite = usage.cacheWriteTokens;
+        const cacheRead = usage.cacheReadTokens;
+        const reasoningTok = usage.reasoningTokens;
+        const modelKey = model ?? this.currentModel;
+        const pricedUsage = calculateNormalizedUsageCost({ usage, modelId: modelKey ?? undefined });
+        const priced = pricedUsage.source !== 'unpriced';
+        const cost = pricedUsage.costUsd ?? 0;
+        this.inputTokens += inputTok;
+        this.outputTokens += outputTok;
+        this.cacheWriteTokens += cacheWrite;
+        this.cacheReadTokens += cacheRead;
+        this.reasoningTokens += reasoningTok;
+        this.totalTokens += usage.totalTokens;
+        this.costUsd += cost;
+        const callIncrement = isCall ? 1 : 0;
+        if (pricedUsage.source === 'provider-reported') {
+            this.reportedCostUsd += cost;
+            this.reportedCalls += callIncrement;
+        }
+        else if (pricedUsage.source === 'unpriced') {
+            this.unpricedCalls += callIncrement;
+        }
+        else {
+            this.estimatedCostUsd += cost;
+            this.estimatedCalls += callIncrement;
+        }
+        // Burn rate sample accumulation
+        this.tokensSinceLastSample += usage.totalTokens;
+        if (!isCall) {
+            this.accumulateModelUsage(usage, model, cost, priced, false);
+            this.updateBurnRate(timestamp);
+            return cost;
+        }
+        // Context size computation
+        let contextSize;
+        if (this.computeContextSize) {
+            contextSize = this.computeContextSize({
+                inputTokens: inputTok,
+                outputTokens: outputTok,
+                cacheWriteTokens: cacheWrite,
+                cacheReadTokens: cacheRead,
+                reasoningTokens: reasoningTok,
+            });
+        }
+        else {
+            contextSize = inputTok + cacheWrite + cacheRead;
+        }
+        // Compaction detection
+        if (this.resolvePendingHeuristicCompaction(contextSize)) {
+            // The drop belongs to the explicit compaction marker just recorded.
+        }
+        else if (this.previousContextSize > 0 &&
+            contextSize < this.previousContextSize * COMPACTION_DROP_THRESHOLD) {
+            this.compactionEvents.push({
+                timestamp: new Date(timestamp),
+                contextBefore: this.previousContextSize,
+                contextAfter: contextSize,
+                tokensReclaimed: this.previousContextSize - contextSize,
+                source: 'heuristic',
+            });
+        }
+        this.previousContextSize = contextSize;
+        this.currentContextSize = contextSize;
+        // Context timeline tracking
+        this.contextTimeline.push({
+            timestamp,
+            inputTokens: contextSize,
+            turnIndex: this.contextTurnIndex++,
+        });
+        if (this.contextTimeline.length > this.contextTimelineCap) {
+            this.contextTimeline.splice(0, this.contextTimeline.length - this.contextTimelineCap);
+        }
+        this.accumulateModelUsage(usage, model, cost, priced, true);
+        // Burn rate sampling
+        this.updateBurnRate(timestamp);
+        return cost;
+    }
+    /**
+     * Per-model usage. Accumulate reasoning tokens and an inverted-sticky
+     * `priced` flag so one unpriced event taints the aggregate (UI renders "—").
+     */
+    accumulateModelUsage(usage, model, cost, priced, countCall) {
+        const inputTok = usage.uncachedInputTokens;
+        const outputTok = usage.outputTokens;
+        const cacheWrite = usage.cacheWriteTokens;
+        const cacheRead = usage.cacheReadTokens;
+        const reasoningTok = usage.reasoningTokens;
+        const perModelKey = model ?? this.currentModel ?? 'unknown';
+        const acc = this.modelUsage.get(perModelKey) ?? {
+            calls: 0,
+            tokens: 0,
+            inputTokens: 0,
+            outputTokens: 0,
+            cacheWriteTokens: 0,
+            cacheReadTokens: 0,
+            reasoningTokens: 0,
+            cost: 0,
+            priced: true,
+        };
+        if (countCall)
+            acc.calls++;
+        acc.tokens += usage.totalTokens;
+        acc.inputTokens += inputTok;
+        acc.outputTokens += outputTok;
+        acc.cacheWriteTokens += cacheWrite;
+        acc.cacheReadTokens += cacheRead;
+        acc.reasoningTokens = (acc.reasoningTokens ?? 0) + reasoningTok;
+        acc.cost += cost;
+        if (!priced)
+            acc.priced = false;
+        this.modelUsage.set(perModelKey, acc);
+    }
+    // ═══════════════════════════════════════════════════════════════════════
+    // Private: Burn Rate
+    // ═══════════════════════════════════════════════════════════════════════
+    updateBurnRate(timestamp) {
+        const now = new Date(timestamp).getTime();
+        if (isNaN(now))
+            return;
+        if (this.lastBurnSampleTime === 0) {
+            this.lastBurnSampleTime = now;
+            return;
+        }
+        const elapsed = now - this.lastBurnSampleTime;
+        if (elapsed >= this.burnSampleMs) {
+            const tokPerMin = elapsed > 0 ? Math.round((this.tokensSinceLastSample / elapsed) * 60_000) : 0;
+            this.burnSamples.push({ time: now, tokens: tokPerMin });
+            this.tokensSinceLastSample = 0;
+            this.lastBurnSampleTime = now;
+            // Trim to window
+            const cutoff = now - this.burnWindowMs;
+            this.burnSamples = this.burnSamples.filter((s) => s.time >= cutoff);
+        }
+    }
+    // ═══════════════════════════════════════════════════════════════════════
+    // Private: Latency Tracking (SessionEvent only)
+    // ═══════════════════════════════════════════════════════════════════════
+    processLatency(event) {
+        const now = new Date(event.timestamp);
+        if (event.type === 'user' && this.hasTextContent(event)) {
+            // User event with text content -> start tracking
+            this.pendingUserRequest = {
+                timestamp: now,
+                firstResponseReceived: false,
+            };
+        }
+        else if (event.type === 'assistant' && this.pendingUserRequest) {
+            if (!this.pendingUserRequest.firstResponseReceived && this.hasTextContent(event)) {
+                // First assistant response with text
+                this.pendingUserRequest.firstResponseReceived = true;
+                this.pendingUserRequest.firstResponseTimestamp = now;
+                this.pendingUserRequest.firstTokenLatencyMs =
+                    now.getTime() - this.pendingUserRequest.timestamp.getTime();
+            }
+            if (event.message.usage && this.pendingUserRequest.firstResponseReceived) {
+                // Assistant with usage -> complete the cycle
+                const totalResponseTimeMs = now.getTime() - this.pendingUserRequest.timestamp.getTime();
+                const firstTokenLatencyMs = this.pendingUserRequest.firstTokenLatencyMs ?? totalResponseTimeMs;
+                this.latencyRecords.push({
+                    firstTokenLatencyMs,
+                    totalResponseTimeMs,
+                    requestTimestamp: this.pendingUserRequest.timestamp,
+                });
+                // Cap latency records
+                if (this.latencyRecords.length > this.latencyCap) {
+                    this.latencyRecords.shift();
+                }
+                this.pendingUserRequest = null;
+            }
+        }
+    }
+    // ═══════════════════════════════════════════════════════════════════════
+    // Private: Tool Extraction from SessionEvent content blocks
+    // ═══════════════════════════════════════════════════════════════════════
+    extractToolsFromContent(event) {
+        const content = event.message?.content;
+        if (!Array.isArray(content))
+            return;
+        for (const block of content) {
+            if (block.type === 'tool_use') {
+                // Assistant content: tool_use block
+                const toolUseId = block.id;
+                const name = block.name;
+                if (!toolUseId || !name)
+                    continue;
+                // Record in toolAnalytics
+                const analytics = this.toolAnalytics.get(name) ?? {
+                    name,
+                    successCount: 0,
+                    failureCount: 0,
+                    totalDuration: 0,
+                    completedCount: 0,
+                    pendingCount: 0,
+                };
+                analytics.pendingCount++;
+                this.toolAnalytics.set(name, analytics);
+                // Track pending
+                this.pendingToolCalls.set(toolUseId, {
+                    toolUseId,
+                    name,
+                    startTime: new Date(event.timestamp),
+                });
+                this.attributePlanToolCall(name);
+            }
+            else if (block.type === 'tool_result') {
+                // User content: tool_result block
+                const toolUseId = block.tool_use_id;
+                const isError = block.is_error === true;
+                if (!toolUseId)
+                    continue;
+                const pending = this.pendingToolCalls.get(toolUseId);
+                if (pending) {
+                    if (isError) {
+                        this.recordError(pending.name, categorizeError(block.content), event.timestamp, this.currentModel ?? 'unknown');
+                    }
+                    this.pendingToolCalls.delete(toolUseId);
+                    const analytics = this.toolAnalytics.get(pending.name);
+                    if (analytics) {
+                        analytics.pendingCount = Math.max(0, analytics.pendingCount - 1);
+                        analytics.completedCount++;
+                        if (isError) {
+                            analytics.failureCount++;
+                        }
+                        else {
+                            analytics.successCount++;
+                        }
+                        // Duration
+                        const duration = new Date(event.timestamp).getTime() - pending.startTime.getTime();
+                        if (duration >= 0) {
+                            analytics.totalDuration += duration;
+                        }
+                    }
+                }
+                // Truncation detection
+                this.detectTruncationInContent(block, event.timestamp);
+            }
+        }
+    }
+    detectTruncationInContent(block, timestamp) {
+        const content = block.content;
+        let text;
+        if (typeof content === 'string')
+            text = content;
+        else if (content)
+            text = JSON.stringify(content);
+        else
+            text = '';
+        if (!text)
+            return;
+        for (const pattern of TRUNCATION_PATTERNS) {
+            if (pattern.regex.test(text)) {
+                // Try to find the tool name from pending calls
+                const toolUseId = block.tool_use_id;
+                const pending = toolUseId ? this.pendingToolCalls.get(toolUseId) : undefined;
+                this.truncationEvents.push({
+                    timestamp: new Date(timestamp),
+                    toolName: pending?.name ?? 'unknown',
+                    marker: pattern.name,
+                });
+                break;
+            }
+        }
+    }
+    // ═══════════════════════════════════════════════════════════════════════
+    // Private: Tool tracking from FollowEvent
+    // ═══════════════════════════════════════════════════════════════════════
+    recordFollowToolUse(event) {
+        const name = event.toolName;
+        // Update analytics
+        const analytics = this.toolAnalytics.get(name) ?? {
+            name,
+            successCount: 0,
+            failureCount: 0,
+            totalDuration: 0,
+            completedCount: 0,
+            pendingCount: 0,
+        };
+        analytics.pendingCount++;
+        this.toolAnalytics.set(name, analytics);
+        // Track pending by tool_use_id from raw
+        const raw = event.raw;
+        const toolUseId = raw?.id;
+        if (toolUseId) {
+            this.pendingToolCalls.set(toolUseId, {
+                toolUseId,
+                name,
+                startTime: new Date(event.timestamp),
+            });
+        }
+    }
+    recordFollowToolResult(event) {
+        const raw = event.raw;
+        if (!raw)
+            return;
+        const toolUseId = raw.tool_use_id;
+        if (!toolUseId)
+            return;
+        const pending = this.pendingToolCalls.get(toolUseId);
+        if (!pending)
+            return;
+        this.pendingToolCalls.delete(toolUseId);
+        const analytics = this.toolAnalytics.get(pending.name);
+        if (analytics) {
+            analytics.pendingCount = Math.max(0, analytics.pendingCount - 1);
+            analytics.completedCount++;
+            const isError = raw.is_error === true;
+            if (isError) {
+                analytics.failureCount++;
+                this.recordError(pending.name, categorizeError(raw.content ?? event.summary), event.timestamp, event.model ?? this.currentModel ?? 'unknown');
+            }
+            else {
+                analytics.successCount++;
+            }
+            const duration = new Date(event.timestamp).getTime() - pending.startTime.getTime();
+            if (duration >= 0) {
+                analytics.totalDuration += duration;
+            }
+        }
+    }
+    recordProviderMetadata(event) {
+        const metadata = event.providerMetadata;
+        if (!metadata)
+            return;
+        this.retryAttempts += metadata.retryAttempts?.length ?? 0;
+        for (const reason of metadata.finishReasons ?? []) {
+            this.finishReasons.set(reason, (this.finishReasons.get(reason) ?? 0) + 1);
+        }
+        if (metadata.providerError) {
+            this.recordError('ProviderAPI', categorizeError(metadata.providerError, metadata.providerError.type), event.timestamp, event.message?.model ?? this.currentModel ?? 'unknown');
+        }
+    }
+    recordError(tool, category, timestamp, model) {
+        const categoryKey = `${tool}\u0000${category}`;
+        const current = this.errorByToolCategory.get(categoryKey);
+        if (current)
+            current.count++;
+        else
+            this.errorByToolCategory.set(categoryKey, { tool, category, count: 1 });
+        const parsed = new Date(timestamp);
+        const hour = Number.isNaN(parsed.getTime())
+            ? timestamp.slice(0, 13)
+            : parsed.toISOString().slice(0, 13);
+        const bucketKey = `${hour}\u0000${model}\u0000${tool}\u0000${category}`;
+        const bucket = this.errorBuckets.get(bucketKey);
+        if (bucket)
+            bucket.count++;
+        else
+            this.errorBuckets.set(bucketKey, { hour, model, tool, category, count: 1 });
+    }
+    detectTruncationFromFollowEvent(event) {
+        const raw = event.raw;
+        if (!raw)
+            return;
+        const content = raw.content;
+        let text;
+        if (typeof content === 'string')
+            text = content;
+        else if (content)
+            text = JSON.stringify(content);
+        else
+            text = '';
+        if (!text)
+            return;
+        for (const pattern of TRUNCATION_PATTERNS) {
+            if (pattern.regex.test(text)) {
+                const toolUseId = raw.tool_use_id;
+                // Try to find the tool name — it may have been resolved already, so check summary
+                let toolName = 'unknown';
+                if (toolUseId) {
+                    const pending = this.pendingToolCalls.get(toolUseId);
+                    if (pending)
+                        toolName = pending.name;
+                }
+                if (toolName === 'unknown' && event.toolName) {
+                    toolName = event.toolName;
+                }
+                this.truncationEvents.push({
+                    timestamp: new Date(event.timestamp),
+                    toolName,
+                    marker: pattern.name,
+                });
+                break;
+            }
+        }
+    }
+    recordExplicitCompaction(timestamp, reported) {
+        const hasReported = reported !== undefined &&
+            Number.isFinite(reported.tokensBefore) &&
+            Number.isFinite(reported.tokensAfter) &&
+            reported.tokensBefore >= reported.tokensAfter &&
+            reported.tokensAfter >= 0;
+        // Without reported counts, assume the full context was reclaimed until
+        // the next usage event supplies the real post-compaction size.
+        const contextBefore = hasReported ? reported.tokensBefore : this.previousContextSize;
+        const contextAfter = hasReported ? reported.tokensAfter : 0;
+        this.compactionEvents.push({
+            timestamp: new Date(timestamp),
+            contextBefore,
+            contextAfter,
+            tokensReclaimed: Math.max(0, contextBefore - contextAfter),
+            source: hasReported ? 'reported' : 'heuristic',
+        });
+        if (hasReported) {
+            this.previousContextSize = contextAfter;
+            this.currentContextSize = contextAfter;
+        }
+        else {
+            this.pendingHeuristicCompactionIndex = this.compactionEvents.length - 1;
+        }
+    }
+    /**
+     * Fills a pending heuristic compaction with the first observed
+     * post-compaction context size. Returns true when the observed drop was
+     * consumed by that pending event, so the caller must not record it again.
+     */
+    resolvePendingHeuristicCompaction(contextSize) {
+        if (this.pendingHeuristicCompactionIndex === null)
+            return false;
+        const compaction = this.compactionEvents[this.pendingHeuristicCompactionIndex];
+        this.pendingHeuristicCompactionIndex = null;
+        if (!compaction)
+            return false;
+        if (contextSize < compaction.contextBefore) {
+            compaction.contextAfter = contextSize;
+            compaction.tokensReclaimed = compaction.contextBefore - contextSize;
+        }
+        return true;
+    }
+    // ═══════════════════════════════════════════════════════════════════════
+    // Private: Task State from SessionEvent
+    // ═══════════════════════════════════════════════════════════════════════
+    extractTaskStateFromEvent(event) {
+        const content = event.message?.content;
+        if (!Array.isArray(content))
+            return;
+        for (const block of content) {
+            if (block.type === 'tool_use') {
+                const name = block.name;
+                const input = block.input;
+                const toolUseId = block.id;
+                if (!input)
+                    continue;
+                if (name === 'TaskCreate' && toolUseId) {
+                    this.pendingTaskCreates.set(toolUseId, {
+                        subject: input.subject || 'Untitled',
+                        description: input.description,
+                        activeForm: input.activeForm,
+                        subagentType: input.subagentType,
+                        isGoalGate: input.isGoalGate,
+                        timestamp: new Date(event.timestamp),
+                    });
+                }
+                else if (name === 'TaskUpdate') {
+                    this.applyTaskUpdate(input);
+                    this.syncPlanStepFromTaskUpdate(input, new Date(event.timestamp));
+                }
+                else if (name === 'TodoWrite') {
+                    this.handleTodoWrite(input, new Date(event.timestamp));
+                }
+                else if (name === 'UpdatePlan') {
+                    this.handleUpdatePlan(input, new Date(event.timestamp));
+                }
+                else if ((name === 'Agent' || name === 'Task') && toolUseId) {
+                    this.handleAgentSpawn(toolUseId, input, new Date(event.timestamp));
+                }
+            }
+            else if (block.type === 'tool_result') {
+                const toolUseId = block.tool_use_id;
+                if (!toolUseId)
+                    continue;
+                const isError = block.is_error ?? false;
+                this.resolveTaskCreate(toolUseId, block.content ?? block.output, event.timestamp, isError);
+                this.resolveAgentResult(toolUseId, isError, event.timestamp);
+            }
+        }
+    }
+    // ═══════════════════════════════════════════════════════════════════════
+    // Private: Task State from FollowEvent
+    // ═══════════════════════════════════════════════════════════════════════
+    extractTaskStateFromFollowEvent(event) {
+        const raw = event.raw;
+        if (event.type === 'tool_use' && event.toolName) {
+            if (!raw?.input)
+                return;
+            const input = raw.input;
+            const toolUseId = raw.id;
+            if (event.toolName === 'TaskCreate' && toolUseId) {
+                this.pendingTaskCreates.set(toolUseId, {
+                    subject: input.subject || 'Untitled',
+                    description: input.description,
+                    activeForm: input.activeForm,
+                    subagentType: input.subagentType,
+                    isGoalGate: input.isGoalGate,
+                    timestamp: new Date(event.timestamp),
+                });
+            }
+            else if (event.toolName === 'TaskUpdate') {
+                this.applyTaskUpdate(input);
+                this.syncPlanStepFromTaskUpdate(input, new Date(event.timestamp));
+            }
+            else if (event.toolName === 'TodoWrite') {
+                this.handleTodoWrite(input, new Date(event.timestamp));
+            }
+            else if (event.toolName === 'UpdatePlan') {
+                this.handleUpdatePlan(input, new Date(event.timestamp));
+            }
+            else if ((event.toolName === 'Agent' || event.toolName === 'Task') && toolUseId) {
+                this.handleAgentSpawn(toolUseId, input, new Date(event.timestamp));
+            }
+        }
+        else if (event.type === 'tool_result') {
+            if (!raw)
+                return;
+            const toolUseId = raw.tool_use_id;
+            if (!toolUseId)
+                return;
+            const isError = raw.is_error ?? false;
+            this.resolveTaskCreate(toolUseId, raw.content, event.timestamp, isError);
+            this.resolveAgentResult(toolUseId, isError, event.timestamp);
+        }
+    }
+    applyTaskUpdate(input) {
+        const taskId = input.taskId;
+        if (!taskId)
+            return;
+        const existing = this.tasks.get(taskId);
+        if (existing) {
+            if (input.status) {
+                const newStatus = input.status;
+                if (newStatus === 'deleted') {
+                    this.tasks.delete(taskId);
+                    if (this.activeTaskId === taskId)
+                        this.activeTaskId = null;
+                    return;
+                }
+                const oldStatus = existing.status;
+                existing.status = newStatus;
+                existing.updatedAt = new Date();
+                if (newStatus === 'in_progress' && oldStatus !== 'in_progress') {
+                    this.activeTaskId = taskId;
+                }
+                else if (oldStatus === 'in_progress' && newStatus !== 'in_progress') {
+                    if (this.activeTaskId === taskId)
+                        this.activeTaskId = null;
+                }
+            }
+            if (input.subject)
+                existing.subject = input.subject;
+            if (input.description)
+                existing.description = input.description;
+            if (input.activeForm)
+                existing.activeForm = input.activeForm;
+            if (input.addBlockedBy && Array.isArray(input.addBlockedBy)) {
+                for (const id of input.addBlockedBy) {
+                    const idStr = String(id);
+                    if (!existing.blockedBy.includes(idStr)) {
+                        existing.blockedBy.push(idStr);
+                    }
+                }
+            }
+            if (input.addBlocks && Array.isArray(input.addBlocks)) {
+                for (const id of input.addBlocks) {
+                    const idStr = String(id);
+                    if (!existing.blocks.includes(idStr)) {
+                        existing.blocks.push(idStr);
+                    }
+                }
+            }
+            // Re-evaluate goal gate after update
+            existing.isGoalGate = this.isGoalGateTask(existing);
+        }
+        else {
+            // TaskUpdate for unknown task — create placeholder
+            const status = input.status || 'pending';
+            if (status === 'deleted')
+                return;
+            const now = new Date();
+            const task = {
+                taskId,
+                subject: input.subject || `Task ${taskId}`,
+                description: input.description,
+                status: status,
+                createdAt: now,
+                updatedAt: now,
+                blockedBy: [],
+                blocks: [],
+                associatedToolCalls: [],
+                activeForm: input.activeForm,
+            };
+            task.isGoalGate = this.isGoalGateTask(task);
+            this.tasks.set(taskId, task);
+            if (status === 'in_progress') {
+                this.activeTaskId = taskId;
+            }
+        }
+    }
+    syncPlanStepFromTaskUpdate(input, now) {
+        if (!this.planState || !input.status)
+            return;
+        const taskId = String(input.taskId ?? input.task_id ?? '');
+        const stepId = taskId.startsWith('plan-') ? `step-${taskId.slice(5)}` : taskId;
+        const step = this.planState.steps.find((candidate) => candidate.id === stepId);
+        if (!step)
+            return;
+        const rawStatus = String(input.status).toLowerCase();
+        const status = rawStatus === 'completed'
+            ? 'completed'
+            : rawStatus === 'in_progress' || rawStatus === 'in-progress'
+                ? 'in_progress'
+                : rawStatus === 'deleted'
+                    ? 'skipped'
+                    : 'pending';
+        if (status === 'in_progress' && step.status !== 'in_progress') {
+            step.startedAt = now.toISOString();
+        }
+        if (status === 'completed' && step.status !== status) {
+            step.startedAt ??= now.toISOString();
+            step.completedAt = now.toISOString();
+            step.durationMs = Math.max(0, now.getTime() - new Date(step.startedAt).getTime());
+        }
+        step.status = status;
+        const completed = this.planState.steps.filter((candidate) => candidate.status === 'completed');
+        this.planState.completionRate =
+            this.planState.steps.length > 0 ? completed.length / this.planState.steps.length : 0;
+        this.planState.active = this.planState.steps.some((candidate) => candidate.status === 'pending' || candidate.status === 'in_progress');
+    }
+    resolveTaskCreate(toolUseId, content, timestamp, isError) {
+        const pending = this.pendingTaskCreates.get(toolUseId);
+        if (!pending)
+            return;
+        this.pendingTaskCreates.delete(toolUseId);
+        // Don't create task on error
+        if (isError)
+            return;
+        const taskId = this.extractTaskIdFromResult(content);
+        if (!taskId)
+            return;
+        const now = new Date(timestamp);
+        const task = {
+            taskId,
+            subject: pending.subject,
+            description: pending.description,
+            status: 'pending',
+            createdAt: pending.timestamp ?? now,
+            updatedAt: now,
+            blockedBy: [],
+            blocks: [],
+            associatedToolCalls: [],
+            activeForm: pending.activeForm,
+            subagentType: pending.subagentType,
+            isGoalGate: pending.isGoalGate,
+        };
+        // Evaluate goal gate from content if not explicitly set
+        task.isGoalGate = task.isGoalGate || this.isGoalGateTask(task);
+        this.tasks.set(taskId, task);
+    }
+    // ═══════════════════════════════════════════════════════════════════════
+    // Private: TodoWrite handling (OpenCode)
+    // ═══════════════════════════════════════════════════════════════════════
+    handleTodoWrite(input, now) {
+        const todos = input.todos;
+        if (!Array.isArray(todos))
+            return;
+        // Remove all non-subagent tasks (subagent tasks should persist)
+        for (const [taskId, task] of this.tasks) {
+            if (!task.isSubagent) {
+                this.tasks.delete(taskId);
+            }
+        }
+        // Reset active task if it was a non-subagent task
+        if (this.activeTaskId && !this.tasks.has(this.activeTaskId)) {
+            this.activeTaskId = null;
+        }
+        for (let i = 0; i < todos.length; i++) {
+            const todo = todos[i];
+            const taskId = `todo-${i}`;
+            const content = String(todo.content || todo.subject || `Todo ${i + 1}`);
+            const rawStatus = String(todo.status || 'pending').toLowerCase();
+            const priority = todo.priority ? String(todo.priority) : undefined;
+            // Map OpenCode todo status values to TaskStatus
+            let status;
+            if (rawStatus === 'completed' || rawStatus === 'done') {
+                status = 'completed';
+            }
+            else if (rawStatus === 'in_progress' || rawStatus === 'in-progress') {
+                status = 'in_progress';
+            }
+            else {
+                status = 'pending';
+            }
+            const task = {
+                taskId,
+                subject: content,
+                description: priority ? `Priority: ${priority}` : undefined,
+                status,
+                createdAt: now,
+                updatedAt: now,
+                blockedBy: [],
+                blocks: [],
+                associatedToolCalls: [],
+            };
+            this.tasks.set(taskId, task);
+            if (status === 'in_progress') {
+                this.activeTaskId = taskId;
+            }
+        }
+        // Second pass: parse dependency info from content text
+        for (let i = 0; i < todos.length; i++) {
+            const task = this.tasks.get(`todo-${i}`);
+            if (!task)
+                continue;
+            // Check for explicit blockedBy field
+            if (Array.isArray(todos[i].blockedBy)) {
+                for (const ref of todos[i].blockedBy) {
+                    const refStr = String(ref);
+                    if (!task.blockedBy.includes(refStr)) {
+                        task.blockedBy.push(refStr);
+                    }
+                }
+            }
+            // Parse dependency references from content text
+            const deps = parseTodoDependencies(String(todos[i].content || ''), todos);
+            for (const depId of deps) {
+                if (depId !== `todo-${i}` && !task.blockedBy.includes(depId)) {
+                    task.blockedBy.push(depId);
+                    const depTask = this.tasks.get(depId);
+                    if (depTask && !depTask.blocks.includes(`todo-${i}`)) {
+                        depTask.blocks.push(`todo-${i}`);
+                    }
+                }
+            }
+        }
+    }
+    // ═══════════════════════════════════════════════════════════════════════
+    // Private: UpdatePlan handling (Codex)
+    // ═══════════════════════════════════════════════════════════════════════
+    handleUpdatePlan(input, now) {
+        const plan = input.plan;
+        if (!Array.isArray(plan))
+            return;
+        const seenPlanTaskIds = new Set();
+        let activePlanTaskId = null;
+        for (let i = 0; i < plan.length; i++) {
+            const entry = plan[i];
+            const step = String(entry.step || '').trim();
+            if (!step)
+                continue;
+            const rawStatus = String(entry.status || 'pending').toLowerCase();
+            let status;
+            if (rawStatus === 'completed')
+                status = 'completed';
+            else if (rawStatus === 'in_progress' || rawStatus === 'in-progress')
+                status = 'in_progress';
+            else
+                status = 'pending';
+            const taskId = `plan-${i}`;
+            seenPlanTaskIds.add(taskId);
+            const existing = this.tasks.get(taskId);
+            if (existing) {
+                existing.subject = step;
+                existing.status = status;
+                existing.updatedAt = now;
+                if (!existing.activeForm) {
+                    existing.activeForm = `Working on ${step}`;
+                }
+            }
+            else {
+                const task = {
+                    taskId,
+                    subject: step,
+                    status,
+                    createdAt: now,
+                    updatedAt: now,
+                    activeForm: `Working on ${step}`,
+                    blockedBy: [],
+                    blocks: [],
+                    associatedToolCalls: [],
+                };
+                this.tasks.set(taskId, task);
+            }
+            if (status === 'in_progress') {
+                activePlanTaskId = taskId;
+            }
+        }
+        // Mark missing synthetic plan tasks as deleted
+        for (const [taskId, task] of this.tasks) {
+            if (!taskId.startsWith('plan-'))
+                continue;
+            if (!seenPlanTaskIds.has(taskId) && task.status !== 'deleted') {
+                task.status = 'deleted';
+                task.updatedAt = now;
+            }
+        }
+        if (activePlanTaskId) {
+            this.activeTaskId = activePlanTaskId;
+        }
+        else if (this.activeTaskId?.startsWith('plan-')) {
+            this.activeTaskId = null;
+        }
+    }
+    // ═══════════════════════════════════════════════════════════════════════
+    // Private: Agent/Task (subagent) as tracked task
+    // ═══════════════════════════════════════════════════════════════════════
+    handleAgentSpawn(toolUseId, input, now) {
+        const agentTaskId = `agent-${toolUseId}`;
+        const description = input.description ? String(input.description) : 'Subagent';
+        const subagentType = input.subagent_type || input.subagentType || undefined;
+        const task = {
+            taskId: agentTaskId,
+            subject: description,
+            status: 'in_progress',
+            createdAt: now,
+            updatedAt: now,
+            activeForm: subagentType ? `Running ${subagentType} agent` : 'Running subagent',
+            blockedBy: [],
+            blocks: [],
+            associatedToolCalls: [],
+            isSubagent: true,
+            subagentType,
+            toolUseId,
+        };
+        this.tasks.set(agentTaskId, task);
+    }
+    resolveAgentResult(toolUseId, isError, timestamp) {
+        const agentTaskId = `agent-${toolUseId}`;
+        const agentTask = this.tasks.get(agentTaskId);
+        if (!agentTask)
+            return;
+        agentTask.status = isError ? 'deleted' : 'completed';
+        agentTask.updatedAt = new Date(timestamp);
+    }
+    // ═══════════════════════════════════════════════════════════════════════
+    // Private: Goal gate detection
+    // ═══════════════════════════════════════════════════════════════════════
+    isGoalGateTask(task) {
+        if (GOAL_GATE_REGEX.test(task.subject))
+            return true;
+        if (task.description && GOAL_GATE_REGEX.test(task.description))
+            return true;
+        if (task.blocks.length >= 3)
+            return true;
+        return false;
+    }
+    // ═══════════════════════════════════════════════════════════════════════
+    // Private: Subagent Tracking from SessionEvent
+    // ═══════════════════════════════════════════════════════════════════════
+    extractSubagentFromEvent(event) {
+        const content = event.message?.content;
+        if (!Array.isArray(content))
+            return;
+        for (const block of content) {
+            if (block.type === 'tool_use' && block.name === 'Task') {
+                const input = block.input;
+                const toolUseId = block.id;
+                if (!input || !toolUseId)
+                    continue;
+                const info = {
+                    id: toolUseId,
+                    description: input.description || 'Unknown task',
+                    subagentType: input.subagent_type || input.subagentType || 'general',
+                    spawnTime: event.timestamp,
+                    status: 'running',
+                };
+                const idx = this.subagents.length;
+                this.subagents.push(info);
+                this.pendingSubagents.set(toolUseId, idx);
+            }
+            else if (block.type === 'tool_result') {
+                const toolUseId = block.tool_use_id;
+                if (!toolUseId)
+                    continue;
+                this.completeSubagent(toolUseId, event.timestamp);
+            }
+        }
+    }
+    // ═══════════════════════════════════════════════════════════════════════
+    // Private: Subagent Tracking from FollowEvent
+    // ═══════════════════════════════════════════════════════════════════════
+    extractSubagentFromFollowEvent(event) {
+        const raw = event.raw;
+        if (event.type === 'tool_use' && event.toolName === 'Task') {
+            if (!raw?.input)
+                return;
+            const input = raw.input;
+            const toolUseId = raw.id || '';
+            const info = {
+                id: toolUseId,
+                description: input.description || 'Unknown task',
+                subagentType: input.subagent_type || input.subagentType || 'general',
+                spawnTime: event.timestamp,
+                status: 'running',
+            };
+            const idx = this.subagents.length;
+            this.subagents.push(info);
+            if (toolUseId) {
+                this.pendingSubagents.set(toolUseId, idx);
+            }
+        }
+        else if (event.type === 'tool_result') {
+            if (!raw)
+                return;
+            const toolUseId = raw.tool_use_id;
+            if (!toolUseId)
+                return;
+            this.completeSubagent(toolUseId, event.timestamp);
+        }
+    }
+    completeSubagent(toolUseId, timestamp) {
+        const idx = this.pendingSubagents.get(toolUseId);
+        if (idx === undefined)
+            return;
+        this.pendingSubagents.delete(toolUseId);
+        const agent = this.subagents[idx];
+        agent.status = 'completed';
+        agent.completionTime = timestamp;
+        const start = new Date(agent.spawnTime).getTime();
+        const end = new Date(timestamp).getTime();
+        if (!isNaN(start) && !isNaN(end) && end >= start) {
+            agent.durationMs = end - start;
+        }
+    }
+    // ═══════════════════════════════════════════════════════════════════════
+    // Private: Plan Extraction from SessionEvent
+    // ═══════════════════════════════════════════════════════════════════════
+    extractPlanFromSessionEvent(event) {
+        // Use toFollowEvents to properly split assistant messages into
+        // per-content-block FollowEvents (one per tool_use + one for text).
+        // This ensures PlanExtractor sees type:'tool_use' for plan tools
+        // like EnterPlanMode, with raw.input set correctly.
+        const providerId = this._providerId ?? 'claude-code';
+        const followEvents = toFollowEvents(event, providerId);
+        for (const fe of followEvents) {
+            this.processPlanFollowEvent(fe);
+        }
+    }
+    processPlanFollowEvent(event) {
+        const now = new Date(event.timestamp);
+        if (event.type === 'tool_use' && event.toolName === 'EnterPlanMode') {
+            this.planEnteredAt = now;
+            this.planState = {
+                active: true,
+                steps: [],
+                enteredAt: now,
+                source: event.providerId,
+            };
+        }
+        const updated = this.planExtractor.processEvent(event);
+        if (updated && this.planExtractor.plan) {
+            this.planState = this.convertExtractedPlanToPlanState(this.planExtractor.plan, now);
+        }
+        if (event.type === 'tool_use' && event.toolName === 'ExitPlanMode' && this.planState) {
+            this.planState.exitedAt = now;
+            if (this.planState.enteredAt) {
+                this.planState.totalDurationMs = now.getTime() - this.planState.enteredAt.getTime();
+            }
+        }
+    }
+    convertExtractedPlanToPlanState(extracted, now) {
+        const previous = this.planState;
+        const previousSteps = new Map((previous?.steps ?? []).map((step) => [`${step.id}\u0000${step.description}`, step]));
+        const completed = extracted.steps.filter((s) => s.status === 'completed').length;
+        const total = extracted.steps.length;
+        const steps = extracted.steps.map((step) => {
+            const old = previousSteps.get(`${step.id}\u0000${step.description}`);
+            const merged = { ...step, ...old, status: step.status };
+            if (step.status === 'in_progress' && old?.status !== 'in_progress' && !merged.startedAt) {
+                merged.startedAt = now.toISOString();
+            }
+            if ((step.status === 'completed' || step.status === 'failed') &&
+                old?.status !== step.status &&
+                !merged.completedAt) {
+                merged.startedAt ??= previous?.enteredAt?.toISOString() ?? now.toISOString();
+                merged.completedAt = now.toISOString();
+                merged.durationMs = Math.max(0, now.getTime() - new Date(merged.startedAt).getTime());
+            }
+            return merged;
+        });
+        return {
+            active: steps.some((step) => step.status === 'pending' || step.status === 'in_progress'),
+            steps,
+            title: extracted.title,
+            source: extracted.source,
+            completionRate: total > 0 ? completed / total : 0,
+            rawMarkdown: extracted.rawMarkdown,
+            enteredAt: previous?.enteredAt ?? this.planEnteredAt ?? now,
+            exitedAt: previous?.exitedAt,
+            totalDurationMs: previous?.totalDurationMs,
+            prompt: previous?.prompt,
+            revision: previous?.revision,
+        };
+    }
+    getActivePlanStep() {
+        return this.planState?.steps.find((step) => step.status === 'in_progress');
+    }
+    attributePlanUsage(tokens, costUsd) {
+        const step = this.getActivePlanStep();
+        if (!step)
+            return;
+        step.tokensUsed = (step.tokensUsed ?? 0) + tokens;
+        if (costUsd > 0)
+            step.costUsd = (step.costUsd ?? 0) + costUsd;
+    }
+    attributePlanToolCall(toolName) {
+        if (['EnterPlanMode', 'ExitPlanMode', 'UpdatePlan', 'TaskUpdate'].includes(toolName))
+            return;
+        const step = this.getActivePlanStep();
+        if (step)
+            step.toolCalls = (step.toolCalls ?? 0) + 1;
+    }
+    // ═══════════════════════════════════════════════════════════════════════
+    // Private: Context Attribution from SessionEvent
+    // ═══════════════════════════════════════════════════════════════════════
+    attributeContextFromEvent(event) {
+        const content = event.message?.content;
+        if (event.type === 'user') {
+            if (Array.isArray(content)) {
+                for (const block of content) {
+                    if (block.type === 'tool_result') {
+                        const text = typeof block.content === 'string'
+                            ? block.content
+                            : JSON.stringify(block.content || '');
+                        this.contextAttribution.toolOutputs += this.estimateTokens(text);
+                    }
+                    else if (block.type === 'text') {
+                        const text = block.text || '';
+                        if (this.isSystemPromptContent(text)) {
+                            this.contextAttribution.systemPrompt += this.estimateTokens(text);
+                        }
+                        else {
+                            this.contextAttribution.userMessages += this.estimateTokens(text);
+                        }
+                    }
+                }
+            }
+            else if (typeof content === 'string') {
+                if (this.isSystemPromptContent(content)) {
+                    this.contextAttribution.systemPrompt += this.estimateTokens(content);
+                }
+                else {
+                    this.contextAttribution.userMessages += this.estimateTokens(content);
+                }
+            }
+        }
+        else if (event.type === 'assistant') {
+            if (Array.isArray(content)) {
+                for (const block of content) {
+                    if (block.type === 'thinking') {
+                        this.contextAttribution.thinking += this.estimateTokens(block.thinking || '');
+                    }
+                    else if (block.type === 'tool_use') {
+                        const input = typeof block.input === 'string' ? block.input : JSON.stringify(block.input || '');
+                        this.contextAttribution.toolInputs += this.estimateTokens(input);
+                    }
+                    else if (block.type === 'text') {
+                        this.contextAttribution.assistantResponses += this.estimateTokens(block.text || '');
+                    }
+                }
+            }
+        }
+        else if (event.type === 'summary') {
+            const text = this.extractTextContent(event) || '';
+            if (text) {
+                this.contextAttribution.other += this.estimateTokens(text);
+            }
+        }
+        else if (event.type === 'system') {
+            const text = this.extractTextContent(event) || '';
+            if (text) {
+                this.contextAttribution.systemPrompt += this.estimateTokens(text);
+            }
+        }
+    }
+    // ═══════════════════════════════════════════════════════════════════════
+    // Private: Context Attribution from FollowEvent
+    // ═══════════════════════════════════════════════════════════════════════
+    attributeContextFromFollowEvent(event) {
+        const raw = event.raw;
+        // Try to get full content blocks from raw.message.content
+        const message = raw?.message;
+        const content = message?.content;
+        if (event.type === 'user') {
+            if (Array.isArray(content)) {
+                for (const block of content) {
+                    if (block.type === 'tool_result') {
+                        const text = typeof block.content === 'string'
+                            ? block.content
+                            : JSON.stringify(block.content || '');
+                        this.contextAttribution.toolOutputs += this.estimateTokens(text);
+                    }
+                    else if (block.type === 'text') {
+                        const text = block.text || '';
+                        if (this.isSystemPromptContent(text)) {
+                            this.contextAttribution.systemPrompt += this.estimateTokens(text);
+                        }
+                        else {
+                            this.contextAttribution.userMessages += this.estimateTokens(text);
+                        }
+                    }
+                }
+            }
+            else if (event.summary) {
+                if (this.isSystemPromptContent(event.summary)) {
+                    this.contextAttribution.systemPrompt += this.estimateTokens(event.summary);
+                }
+                else {
+                    this.contextAttribution.userMessages += this.estimateTokens(event.summary);
+                }
+            }
+        }
+        else if (event.type === 'assistant') {
+            if (Array.isArray(content)) {
+                for (const block of content) {
+                    if (block.type === 'thinking') {
+                        this.contextAttribution.thinking += this.estimateTokens(block.thinking || '');
+                    }
+                    else if (block.type === 'tool_use') {
+                        const input = typeof block.input === 'string' ? block.input : JSON.stringify(block.input || '');
+                        this.contextAttribution.toolInputs += this.estimateTokens(input);
+                    }
+                    else if (block.type === 'text') {
+                        this.contextAttribution.assistantResponses += this.estimateTokens(block.text || '');
+                    }
+                }
+            }
+            else if (event.summary) {
+                this.contextAttribution.assistantResponses += this.estimateTokens(event.summary);
+            }
+        }
+        else if (event.type === 'tool_use') {
+            // Try raw input first (summary is truncated to ~80 chars)
+            const rawInput = raw?.input != null ? JSON.stringify(raw.input) : null;
+            const text = rawInput || event.summary || '';
+            if (text)
+                this.contextAttribution.toolInputs += this.estimateTokens(text);
+        }
+        else if (event.type === 'tool_result') {
+            const rawContent = raw?.content;
+            const text = typeof rawContent === 'string'
+                ? rawContent
+                : rawContent
+                    ? JSON.stringify(rawContent)
+                    : event.summary || '';
+            if (text)
+                this.contextAttribution.toolOutputs += this.estimateTokens(text);
+        }
+        else if (event.type === 'summary') {
+            if (event.summary) {
+                this.contextAttribution.other += this.estimateTokens(event.summary);
+            }
+        }
+    }
+    // ═══════════════════════════════════════════════════════════════════════
+    // Private: Permission Mode
+    // ═══════════════════════════════════════════════════════════════════════
+    trackPermissionMode(event) {
+        if (!event.permissionMode)
+            return;
+        const mode = event.permissionMode;
+        if (mode !== this.currentPermissionMode) {
+            this.permissionModeHistory.push({
+                timestamp: event.timestamp,
+                mode,
+                previousMode: this.currentPermissionMode,
+            });
+            this.currentPermissionMode = mode;
+        }
+    }
+    // ═══════════════════════════════════════════════════════════════════════
+    // Private: Timeline
+    // ═══════════════════════════════════════════════════════════════════════
+    addTimelineFromSessionEvent(event) {
+        // Hard noise: skip entirely
+        if (isHardNoise(event))
+            return;
+        let tlType;
+        let description;
+        let noiseLevel = 'system';
+        const metadata = {};
+        switch (event.type) {
+            case 'user':
+                tlType = 'user_prompt';
+                description = this.extractTextContent(event) ?? 'User prompt';
+                noiseLevel = 'user';
+                break;
+            case 'assistant':
+                tlType = 'assistant_response';
+                description = this.extractTextContent(event) ?? 'Assistant response';
+                noiseLevel = 'ai';
+                if (event.message.model)
+                    metadata.model = event.message.model;
+                {
+                    // Cache-inclusive, like every other token total (see tokenSummary).
+                    const usage = extractNormalizedUsage(event);
+                    if (usage)
+                        metadata.tokenCount = usage.totalTokens;
+                }
+                break;
+            case 'tool_use': {
+                tlType = 'tool_call';
+                // Use rich tool summary formatter
+                const toolName = event.tool?.name ?? 'unknown';
+                const toolSummary = event.tool?.input ? formatToolSummary(toolName, event.tool.input) : '';
+                description = toolSummary ? `${toolName}: ${toolSummary}` : toolName;
+                noiseLevel = 'system';
+                if (event.tool)
+                    metadata.toolName = event.tool.name;
+                break;
+            }
+            case 'tool_result':
+                tlType = 'tool_result';
+                description = event.result ? `Result for tool call` : 'Tool result';
+                noiseLevel = 'noise';
+                if (event.result?.is_error)
+                    metadata.isError = true;
+                break;
+            case 'summary':
+                tlType = 'compaction';
+                description = 'Context compacted';
+                noiseLevel = 'system';
+                break;
+            case 'system':
+                tlType = 'session_start';
+                description =
+                    this.extractTextContent(event) ?? event.message?.sourceLabel ?? 'System event';
+                noiseLevel = 'system';
+                break;
+            default:
+                tlType = 'session_start';
+                description = 'Event';
+                break;
+        }
+        // Truncate description for timeline
+        if (description.length > 200) {
+            description = description.substring(0, 197) + '...';
+        }
+        // Classify noise
+        const softNoiseReason = getSoftNoiseReason(event);
+        const messageClassification = classifyMessage(event);
+        this.timeline.push({
+            type: tlType,
+            timestamp: event.timestamp,
+            description,
+            noiseLevel,
+            softNoiseReason: softNoiseReason ?? undefined,
+            messageClassification,
+            isSidechain: event.isSidechain,
+            metadata: Object.keys(metadata).length > 0 ? metadata : undefined,
+        });
+        // Cap timeline
+        if (this.timeline.length > this.timelineCap) {
+            this.timeline.shift();
+        }
+    }
+    addTimelineFromFollowEvent(event) {
+        // Hard noise: skip entirely
+        if (isHardNoiseFollowEvent(event))
+            return;
+        let tlType;
+        let description = event.summary || '';
+        let noiseLevel = 'system';
+        const metadata = {};
+        switch (event.type) {
+            case 'user':
+                tlType = 'user_prompt';
+                noiseLevel = 'user';
+                break;
+            case 'assistant':
+                tlType = 'assistant_response';
+                noiseLevel = 'ai';
+                if (event.model)
+                    metadata.model = event.model;
+                if (event.tokens) {
+                    metadata.tokenCount =
+                        event.tokens.input +
+                            event.tokens.output +
+                            (event.cacheTokens?.read ?? 0) +
+                            (event.cacheTokens?.write ?? 0);
+                }
+                break;
+            case 'tool_use':
+                tlType = 'tool_call';
+                noiseLevel = 'system';
+                if (event.toolName)
+                    metadata.toolName = event.toolName;
+                break;
+            case 'tool_result':
+                tlType = 'tool_result';
+                noiseLevel = 'noise';
+                break;
+            case 'summary':
+                tlType = 'compaction';
+                noiseLevel = 'system';
+                break;
+            default:
+                tlType = 'session_start';
+                break;
+        }
+        // Truncate description for timeline
+        if (description.length > 200) {
+            description = description.substring(0, 197) + '...';
+        }
+        // Classify message
+        const messageClassification = classifyFollowEvent(event);
+        this.timeline.push({
+            type: tlType,
+            timestamp: event.timestamp,
+            description,
+            noiseLevel,
+            messageClassification,
+            metadata: Object.keys(metadata).length > 0 ? metadata : undefined,
+        });
+        // Cap timeline
+        if (this.timeline.length > this.timelineCap) {
+            this.timeline.shift();
+        }
+    }
+    // ═══════════════════════════════════════════════════════════════════════
+    // Private: Helper methods
+    // ═══════════════════════════════════════════════════════════════════════
+    estimateTokens(text) {
+        return estimateTextTokens(text).count;
+    }
+    hasTextContent(event) {
+        const content = event.message?.content;
+        if (typeof content === 'string')
+            return content.length > 0;
+        if (Array.isArray(content)) {
+            return content.some((b) => b.type === 'text' && typeof b.text === 'string' && b.text.length > 0);
+        }
+        return false;
+    }
+    extractTextContent(event) {
+        const content = event.message?.content;
+        if (typeof content === 'string')
+            return content;
+        if (Array.isArray(content)) {
+            for (const block of content) {
+                if (block.type === 'text' && typeof block.text === 'string') {
+                    return block.text;
+                }
+            }
+        }
+        return null;
+    }
+    extractTaskIdFromResult(content) {
+        const str = typeof content === 'string' ? content : JSON.stringify(content || '');
+        const taskMatch = str.match(/Task #(\d+)/i);
+        if (taskMatch)
+            return taskMatch[1];
+        const jsonMatch = str.match(/"taskId"\s*:\s*"?(\d+)"?/i);
+        if (jsonMatch)
+            return jsonMatch[1];
+        return null;
+    }
+    isSystemPromptContent(text) {
+        return text.includes('<system-reminder>') || text.includes('CLAUDE.md');
+    }
+    // ═══════════════════════════════════════════════════════════════════════
+    // Private: Gonzo/Lazyjournal analytics
+    // ═══════════════════════════════════════════════════════════════════════
+    extractToolNameFromEvent(event) {
+        const content = event.message?.content;
+        if (!Array.isArray(content))
+            return undefined;
+        for (const block of content) {
+            if (block.type === 'tool_use' && typeof block.name === 'string') {
+                return block.name;
+            }
+        }
+        return undefined;
+    }
+    /** Feed event data into frequency trackers, pattern extractor, and heatmap. */
+    feedAnalytics(timestamp, summary, toolName) {
+        // Heatmap: record every event
+        this.heatmapTracker.record(timestamp);
+        // Tool frequency
+        if (toolName) {
+            this.toolFrequency.increment(toolName, timestamp);
+        }
+        // Word frequency: extract significant words from summary
+        if (summary) {
+            const words = summary.split(/\s+/).filter((w) => w.length > 2);
+            for (const word of words) {
+                this.wordFrequency.increment(word.toLowerCase(), timestamp);
+            }
+            // Pattern extraction
+            this.patternExtractor.add(summary);
+        }
+    }
+}