sidekick-shared 0.13.2

package/dist/aggregation/types.d.ts

@@ -0,0 +1,121 @@
+/**
+ * Aggregated metrics output types for EventAggregator.
+ * Re-exports canonical types from sessionEvent and defines aggregation-specific shapes.
+ */
+export type { SessionEvent, ClaudeSessionEvent, MessageUsage, TokenUsage, ToolCall, ToolAnalytics, TimelineEvent, PendingToolCall, TrackedTask, TaskState, TaskStatus, SubagentStats, PlanState, PlanStep, CompactionEvent, TruncationEvent, ContextAttribution, TurnAttribution, ContextSizePoint, PendingUserRequest, ResponseLatency, LatencyStats, SessionStats, PermissionMode, PermissionModeChange, } from '../types/sessionEvent';
+import type { ContextAttribution, ContextSizePoint, CompactionEvent, TruncationEvent, ToolAnalytics, TimelineEvent, TaskState, PlanState, LatencyStats, PermissionMode, PermissionModeChange } from '../types/sessionEvent';
+/** Configuration options for EventAggregator. */
+export interface EventAggregatorOptions {
+    /** Maximum timeline events to retain (default 200). */
+    timelineCap?: number;
+    /** Maximum latency records to retain (default 100). */
+    latencyCap?: number;
+    /** Burn rate sliding window in ms (default 5 * 60_000). */
+    burnWindowMs?: number;
+    /** Burn rate sample interval in ms (default 10_000). */
+    burnSampleMs?: number;
+    /** Provider-specific context size computation (default: input + cacheWrite + cacheRead). */
+    computeContextSize?: (usage: {
+        inputTokens: number;
+        outputTokens: number;
+        cacheWriteTokens: number;
+        cacheReadTokens: number;
+        reasoningTokens?: number;
+    }) => number;
+    /** Provider ID for timeline events. */
+    providerId?: 'claude-code' | 'opencode' | 'codex';
+    /** Read a plan file from disk (fallback when Edit tool is used instead of Write). */
+    readPlanFile?: (path: string) => string | null;
+}
+/** Token accumulation totals (aggregation-specific, includes reportedCost). */
+export interface AggregatedTokens {
+    inputTokens: number;
+    outputTokens: number;
+    cacheWriteTokens: number;
+    cacheReadTokens: number;
+    reportedCost: number;
+}
+/** Per-model usage breakdown. */
+export interface ModelUsageStats {
+    model: string;
+    calls: number;
+    tokens: number;
+    inputTokens: number;
+    outputTokens: number;
+    cacheWriteTokens: number;
+    cacheReadTokens: number;
+    cost: number;
+}
+/** Burn rate info. */
+export interface BurnRateInfo {
+    /** Current tokens per minute. */
+    tokensPerMinute: number;
+    /** Sampled burn rate points for charting. */
+    points: number[];
+    /** Number of samples in the window. */
+    sampleCount: number;
+}
+/** Subagent lifecycle info (for tracking spawn/completion from tool events). */
+export interface SubagentLifecycle {
+    id: string;
+    description: string;
+    subagentType: string;
+    spawnTime: string;
+    completionTime?: string;
+    status: 'running' | 'completed';
+    durationMs?: number;
+}
+/** Frequency entry for tool/word frequency tracking. */
+export interface FrequencyMetric {
+    name: string;
+    count: number;
+}
+/** Pattern cluster from event summary clustering. */
+export interface PatternMetric {
+    template: string;
+    count: number;
+    examples: string[];
+}
+/** Heatmap bucket for activity visualization. */
+export interface HeatmapBucketMetric {
+    timestamp: string;
+    count: number;
+}
+/** Full aggregated metrics snapshot. */
+export interface AggregatedMetrics {
+    sessionStartTime: string | null;
+    lastEventTime: string | null;
+    messageCount: number;
+    eventCount: number;
+    currentModel: string | null;
+    providerId: string | null;
+    tokens: AggregatedTokens;
+    modelStats: ModelUsageStats[];
+    currentContextSize: number;
+    contextAttribution: ContextAttribution;
+    compactionCount: number;
+    compactionEvents: CompactionEvent[];
+    truncationCount: number;
+    truncationEvents: TruncationEvent[];
+    toolStats: ToolAnalytics[];
+    burnRate: BurnRateInfo;
+    taskState: TaskState;
+    subagents: SubagentLifecycle[];
+    plan: PlanState | null;
+    /** Current permission mode (default | acceptEdits | bypassPermissions | plan) */
+    permissionMode: PermissionMode | null;
+    /** History of permission mode changes */
+    permissionModeHistory: PermissionModeChange[];
+    /** Context size over time for visualization */
+    contextTimeline: ContextSizePoint[];
+    timeline: TimelineEvent[];
+    latencyStats: LatencyStats | null;
+    /** Top tool names by usage frequency. */
+    toolFrequency: FrequencyMetric[];
+    /** Top words from event summaries. */
+    wordFrequency: FrequencyMetric[];
+    /** Detected event patterns from summary clustering. */
+    patterns: PatternMetric[];
+    /** Rolling activity heatmap buckets (minute resolution). */
+    heatmapBuckets: HeatmapBucketMetric[];
+}

package/dist/aggregation/types.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * Aggregated metrics output types for EventAggregator.
+ * Re-exports canonical types from sessionEvent and defines aggregation-specific shapes.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/context/composer.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Context composer — aggregates all readers with fidelity tiers.
+ */
+import type { PersistedTask } from '../types/taskPersistence';
+import type { DecisionEntry } from '../types/decisionLog';
+import type { KnowledgeNote } from '../types/knowledgeNote';
+import type { TokenTotals } from '../types/historicalData';
+import type { SessionProvider, SessionFileStats, ProviderId } from '../providers/types';
+export type Fidelity = 'full' | 'compact' | 'brief';
+export interface ContextResult {
+    provider: ProviderId;
+    tasks: {
+        items: PersistedTask[];
+        total: number;
+    };
+    decisions: {
+        items: DecisionEntry[];
+        total: number;
+    };
+    notes: {
+        items: KnowledgeNote[];
+        total: number;
+    };
+    handoff: string | null;
+    stats: {
+        tokens: TokenTotals;
+        cost: number;
+    } | null;
+    sessionSummaries: SessionFileStats[];
+}
+export declare function composeContext(slug: string, fidelity: Fidelity, provider: SessionProvider, workspacePath?: string): Promise<ContextResult>;

package/dist/context/composer.js

@@ -0,0 +1,72 @@
+"use strict";
+/**
+ * Context composer — aggregates all readers with fidelity tiers.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.composeContext = composeContext;
+const tasks_1 = require("../readers/tasks");
+const decisions_1 = require("../readers/decisions");
+const notes_1 = require("../readers/notes");
+const history_1 = require("../readers/history");
+const handoff_1 = require("../readers/handoff");
+async function composeContext(slug, fidelity, provider, workspacePath) {
+    // Fetch all data in parallel
+    const [allTasks, allDecisions, allNotes, history, handoff] = await Promise.all([
+        (0, tasks_1.readTasks)(slug),
+        (0, decisions_1.readDecisions)(slug),
+        (0, notes_1.readNotes)(slug),
+        (0, history_1.readHistory)(),
+        (0, handoff_1.readLatestHandoff)(slug),
+    ]);
+    // Get session summaries
+    const sessionFiles = workspacePath ? provider.findAllSessions(workspacePath) : [];
+    const sessionSummaries = [];
+    // Read stats for session files based on fidelity
+    const FIDELITY_SESSION_LIMIT = { full: 5, compact: 2, brief: 1 };
+    const sessionLimit = FIDELITY_SESSION_LIMIT[fidelity];
+    const sessionPaths = sessionFiles.slice(0, sessionLimit);
+    for (const sp of sessionPaths) {
+        try {
+            sessionSummaries.push(provider.readSessionStats(sp));
+        }
+        catch { /* skip */ }
+    }
+    // Apply fidelity filtering
+    let tasks;
+    let decisions;
+    let notes;
+    let stats = null;
+    switch (fidelity) {
+        case 'full':
+            tasks = allTasks;
+            decisions = allDecisions;
+            notes = allNotes.filter(n => n.status === 'active' || n.status === 'needs_review');
+            if (history) {
+                stats = { tokens: { ...history.allTime.tokens }, cost: history.allTime.totalCost };
+            }
+            break;
+        case 'compact':
+            tasks = allTasks.filter(t => t.status === 'pending');
+            decisions = allDecisions.slice(0, 10);
+            notes = allNotes.filter(n => n.status === 'active');
+            if (history) {
+                stats = { tokens: { ...history.allTime.tokens }, cost: history.allTime.totalCost };
+            }
+            break;
+        case 'brief':
+            tasks = allTasks.filter(t => t.status === 'pending').slice(0, 3);
+            decisions = []; // Count only
+            notes = allNotes.filter(n => n.importance === 'critical');
+            stats = null;
+            break;
+    }
+    return {
+        provider: provider.id,
+        tasks: { items: tasks, total: allTasks.length },
+        decisions: { items: decisions, total: allDecisions.length },
+        notes: { items: notes, total: allNotes.length },
+        handoff,
+        stats,
+        sessionSummaries,
+    };
+}

package/dist/credentials.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Read Claude Max OAuth credentials from disk.
+ *
+ * Shared by sidekick-cli, sidekick-vscode, and any external consumer.
+ */
+export interface ClaudeMaxCredentials {
+    accessToken: string;
+    refreshToken?: string;
+    expiresAt?: number;
+    scopes?: string[];
+    subscriptionType?: string;
+}
+/**
+ * Reads Claude Max OAuth credentials from `~/.claude/.credentials.json`.
+ *
+ * Returns `null` if the file does not exist, the token is missing, or the
+ * token is expired. Never throws.
+ */
+export declare function readClaudeMaxCredentials(): Promise<ClaudeMaxCredentials | null>;
+/**
+ * Synchronous convenience — returns just the access token or `null`.
+ */
+export declare function readClaudeMaxAccessTokenSync(): string | null;

package/dist/credentials.js

@@ -0,0 +1,96 @@
+"use strict";
+/**
+ * Read Claude Max OAuth credentials from disk.
+ *
+ * Shared by sidekick-cli, sidekick-vscode, and any external consumer.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readClaudeMaxCredentials = readClaudeMaxCredentials;
+exports.readClaudeMaxAccessTokenSync = readClaudeMaxAccessTokenSync;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+/**
+ * Reads Claude Max OAuth credentials from `~/.claude/.credentials.json`.
+ *
+ * Returns `null` if the file does not exist, the token is missing, or the
+ * token is expired. Never throws.
+ */
+async function readClaudeMaxCredentials() {
+    const credPath = path.join(os.homedir(), '.claude', '.credentials.json');
+    try {
+        if (!fs.existsSync(credPath))
+            return null;
+        const content = await fs.promises.readFile(credPath, 'utf8');
+        const parsed = JSON.parse(content);
+        const oauth = parsed?.claudeAiOauth;
+        if (!oauth?.accessToken)
+            return null;
+        if (oauth.expiresAt && Date.now() > oauth.expiresAt)
+            return null;
+        return {
+            accessToken: oauth.accessToken,
+            refreshToken: oauth.refreshToken,
+            expiresAt: oauth.expiresAt,
+            scopes: oauth.scopes,
+            subscriptionType: oauth.subscriptionType,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Synchronous convenience — returns just the access token or `null`.
+ */
+function readClaudeMaxAccessTokenSync() {
+    const credPath = path.join(os.homedir(), '.claude', '.credentials.json');
+    try {
+        if (!fs.existsSync(credPath))
+            return null;
+        const content = fs.readFileSync(credPath, 'utf8');
+        const parsed = JSON.parse(content);
+        const oauth = parsed?.claudeAiOauth;
+        if (!oauth?.accessToken)
+            return null;
+        if (oauth.expiresAt && Date.now() > oauth.expiresAt)
+            return null;
+        return oauth.accessToken;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/formatters/eventHighlighter.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Keyword-based semantic syntax highlighting for session event text.
+ *
+ * Applies cascading word-by-word colorization based on keyword categories:
+ * errors=red, success=green, warnings=yellow, actions=cyan, numbers=blue,
+ * URLs/paths=magenta, HTTP status codes and methods colored by semantics.
+ *
+ * Supports blessed (CLI), ANSI (terminal), and HTML (VS Code webview) output formats.
+ *
+ * @module formatters/eventHighlighter
+ */
+export type HighlightFormat = 'blessed' | 'ansi' | 'html';
+/**
+ * Apply keyword-based semantic highlighting to text.
+ *
+ * Splits text on whitespace and colors each word based on keyword category.
+ * Words not matching any category pass through uncolored.
+ *
+ * @param text - The text to highlight.
+ * @param format - Output format: 'blessed' (CLI), 'ansi' (terminal), or 'html' (webview).
+ * @returns The highlighted text with format-appropriate tags.
+ */
+export declare function highlight(text: string, format: HighlightFormat): string;
+/**
+ * CSS class definitions for HTML highlight format.
+ * Include this in webview stylesheets.
+ */
+export declare const HIGHLIGHT_CSS = "\n.sk-hl-error { color: var(--vscode-charts-red, #f44747); }\n.sk-hl-success { color: var(--vscode-charts-green, #89d185); }\n.sk-hl-warning { color: var(--vscode-charts-yellow, #cca700); }\n.sk-hl-action { color: var(--vscode-charts-blue, #4fc1ff); }\n.sk-hl-number { color: var(--vscode-charts-purple, #b180d7); }\n.sk-hl-path { color: var(--vscode-charts-orange, #cca700); }\n.sk-hl-muted { opacity: 0.6; }\n.sk-hl-default { }\n.sk-search-match { background-color: var(--vscode-editor-findMatchHighlightBackground, rgba(234, 92, 0, 0.33)); }\n";
+/** Clear the highlight cache (for testing or memory pressure). */
+export declare function clearHighlightCache(): void;

package/dist/formatters/eventHighlighter.js

@@ -0,0 +1,217 @@
+"use strict";
+/**
+ * Keyword-based semantic syntax highlighting for session event text.
+ *
+ * Applies cascading word-by-word colorization based on keyword categories:
+ * errors=red, success=green, warnings=yellow, actions=cyan, numbers=blue,
+ * URLs/paths=magenta, HTTP status codes and methods colored by semantics.
+ *
+ * Supports blessed (CLI), ANSI (terminal), and HTML (VS Code webview) output formats.
+ *
+ * @module formatters/eventHighlighter
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HIGHLIGHT_CSS = void 0;
+exports.highlight = highlight;
+exports.clearHighlightCache = clearHighlightCache;
+const BLESSED_COLORS = {
+    red: ['{red-fg}', '{/red-fg}'],
+    green: ['{green-fg}', '{/green-fg}'],
+    yellow: ['{yellow-fg}', '{/yellow-fg}'],
+    cyan: ['{cyan-fg}', '{/cyan-fg}'],
+    blue: ['{blue-fg}', '{/blue-fg}'],
+    magenta: ['{magenta-fg}', '{/magenta-fg}'],
+    grey: ['{grey-fg}', '{/grey-fg}'],
+    white: ['{white-fg}', '{/white-fg}'],
+};
+const ANSI_COLORS = {
+    red: ['\x1b[31m', '\x1b[0m'],
+    green: ['\x1b[32m', '\x1b[0m'],
+    yellow: ['\x1b[33m', '\x1b[0m'],
+    cyan: ['\x1b[36m', '\x1b[0m'],
+    blue: ['\x1b[34m', '\x1b[0m'],
+    magenta: ['\x1b[35m', '\x1b[0m'],
+    grey: ['\x1b[90m', '\x1b[0m'],
+    white: ['\x1b[37m', '\x1b[0m'],
+};
+const HTML_COLORS = {
+    red: ['<span class="sk-hl-error">', '</span>'],
+    green: ['<span class="sk-hl-success">', '</span>'],
+    yellow: ['<span class="sk-hl-warning">', '</span>'],
+    cyan: ['<span class="sk-hl-action">', '</span>'],
+    blue: ['<span class="sk-hl-number">', '</span>'],
+    magenta: ['<span class="sk-hl-path">', '</span>'],
+    grey: ['<span class="sk-hl-muted">', '</span>'],
+    white: ['<span class="sk-hl-default">', '</span>'],
+};
+function getColors(format) {
+    switch (format) {
+        case 'blessed': return BLESSED_COLORS;
+        case 'ansi': return ANSI_COLORS;
+        case 'html': return HTML_COLORS;
+    }
+}
+const ERROR_KEYWORDS = new Set([
+    'error', 'errors', 'err', 'fail', 'failed', 'failure', 'failures',
+    'fatal', 'panic', 'crash', 'crashed', 'exception', 'exceptions',
+    'critical', 'alert', 'abort', 'aborted', 'denied', 'forbidden',
+    'rejected', 'invalid', 'illegal', 'corrupt', 'corrupted',
+    'broken', 'bug', 'segfault', 'timeout', 'timedout', 'timed-out',
+    'deadlock', 'overflow', 'underflow', 'null', 'undefined', 'nan',
+    'unhandled', 'uncaught', 'unreachable', 'missing', 'notfound',
+    'not-found', 'unavailable', 'disconnected', 'dropped',
+]);
+const SUCCESS_KEYWORDS = new Set([
+    'success', 'successful', 'succeeded', 'ok', 'done', 'complete',
+    'completed', 'passed', 'pass', 'resolved', 'fixed', 'ready',
+    'active', 'running', 'started', 'created', 'connected',
+    'established', 'accepted', 'approved', 'merged', 'deployed',
+    'installed', 'loaded', 'enabled', 'healthy', 'valid', 'verified',
+]);
+const WARNING_KEYWORDS = new Set([
+    'warn', 'warning', 'warnings', 'caution', 'deprecated',
+    'slow', 'retry', 'retrying', 'retries', 'pending', 'waiting',
+    'queued', 'stale', 'expired', 'expiring', 'limited',
+    'throttled', 'throttling', 'degraded', 'unstable', 'flaky',
+    'skipped', 'skip', 'ignored', 'unknown', 'unrecognized',
+]);
+const ACTION_KEYWORDS = new Set([
+    'read', 'write', 'edit', 'delete', 'create', 'update', 'insert',
+    'remove', 'add', 'modify', 'patch', 'merge', 'push', 'pull',
+    'fetch', 'send', 'receive', 'request', 'response', 'query',
+    'search', 'find', 'list', 'get', 'set', 'put', 'post',
+    'build', 'compile', 'test', 'deploy', 'install', 'run',
+    'execute', 'start', 'stop', 'restart', 'init', 'initialize',
+    'configure', 'spawn', 'call', 'invoke',
+]);
+const HTTP_METHODS = new Map([
+    ['GET', 'green'],
+    ['HEAD', 'green'],
+    ['OPTIONS', 'green'],
+    ['POST', 'yellow'],
+    ['PUT', 'yellow'],
+    ['PATCH', 'yellow'],
+    ['DELETE', 'red'],
+]);
+// ── Patterns ──
+const NUMBER_PATTERN = /^-?\d+(\.\d+)?(%|ms|s|m|h|d|k|K|M|G|T|B)?$/;
+const PATH_PATTERN = /^[.~]?\/[\w./-]+|^[\w-]+\/[\w./-]+|^[\w-]+\.[\w.]+$/;
+const URL_PATTERN = /^https?:\/\//;
+/**
+ * Classify an HTTP status code by color.
+ * Returns null if the word is not a status code.
+ */
+function httpStatusColor(word) {
+    if (!/^\d{3}$/.test(word))
+        return null;
+    const code = parseInt(word, 10);
+    if (code >= 200 && code < 300)
+        return 'green';
+    if (code >= 300 && code < 400)
+        return 'yellow';
+    if (code >= 400)
+        return 'red';
+    return null;
+}
+/**
+ * Determine the color for a single word based on keyword categories.
+ * Priority: errors > warnings > success > HTTP > actions > paths > numbers
+ */
+function classifyWord(word) {
+    const lower = word.toLowerCase();
+    // Strip common punctuation for keyword matching
+    const stripped = lower.replace(/[.,;:!?()[\]{}'"]+$/g, '').replace(/^['"([\]{}]+/, '');
+    if (ERROR_KEYWORDS.has(stripped))
+        return 'red';
+    if (WARNING_KEYWORDS.has(stripped))
+        return 'yellow';
+    if (SUCCESS_KEYWORDS.has(stripped))
+        return 'green';
+    // HTTP methods
+    const httpMethod = HTTP_METHODS.get(word.toUpperCase());
+    if (httpMethod)
+        return httpMethod;
+    // HTTP status codes
+    const statusColor = httpStatusColor(stripped);
+    if (statusColor)
+        return statusColor;
+    if (ACTION_KEYWORDS.has(stripped))
+        return 'cyan';
+    // Paths and URLs
+    if (URL_PATTERN.test(word) || PATH_PATTERN.test(word))
+        return 'magenta';
+    // Numbers
+    if (NUMBER_PATTERN.test(stripped))
+        return 'blue';
+    return null;
+}
+// ── LRU cache for highlighted results ──
+const CACHE_MAX = 500;
+const highlightCache = new Map();
+function cacheKey(text, format) {
+    return `${format}:${text}`;
+}
+/**
+ * Apply keyword-based semantic highlighting to text.
+ *
+ * Splits text on whitespace and colors each word based on keyword category.
+ * Words not matching any category pass through uncolored.
+ *
+ * @param text - The text to highlight.
+ * @param format - Output format: 'blessed' (CLI), 'ansi' (terminal), or 'html' (webview).
+ * @returns The highlighted text with format-appropriate tags.
+ */
+function highlight(text, format) {
+    if (!text)
+        return text;
+    const key = cacheKey(text, format);
+    const cached = highlightCache.get(key);
+    if (cached !== undefined)
+        return cached;
+    const colors = getColors(format);
+    const words = text.split(/(\s+)/); // Split preserving whitespace
+    const parts = [];
+    for (const segment of words) {
+        // Preserve whitespace segments as-is
+        if (/^\s+$/.test(segment)) {
+            parts.push(segment);
+            continue;
+        }
+        const color = classifyWord(segment);
+        if (color) {
+            const [open, close] = colors[color];
+            parts.push(`${open}${segment}${close}`);
+        }
+        else {
+            parts.push(segment);
+        }
+    }
+    const result = parts.join('');
+    // LRU cache: evict oldest if full
+    if (highlightCache.size >= CACHE_MAX) {
+        const first = highlightCache.keys().next().value;
+        if (first !== undefined)
+            highlightCache.delete(first);
+    }
+    highlightCache.set(key, result);
+    return result;
+}
+/**
+ * CSS class definitions for HTML highlight format.
+ * Include this in webview stylesheets.
+ */
+exports.HIGHLIGHT_CSS = `
+.sk-hl-error { color: var(--vscode-charts-red, #f44747); }
+.sk-hl-success { color: var(--vscode-charts-green, #89d185); }
+.sk-hl-warning { color: var(--vscode-charts-yellow, #cca700); }
+.sk-hl-action { color: var(--vscode-charts-blue, #4fc1ff); }
+.sk-hl-number { color: var(--vscode-charts-purple, #b180d7); }
+.sk-hl-path { color: var(--vscode-charts-orange, #cca700); }
+.sk-hl-muted { opacity: 0.6; }
+.sk-hl-default { }
+.sk-search-match { background-color: var(--vscode-editor-findMatchHighlightBackground, rgba(234, 92, 0, 0.33)); }
+`;
+/** Clear the highlight cache (for testing or memory pressure). */
+function clearHighlightCache() {
+    highlightCache.clear();
+}

package/dist/formatters/noiseClassifier.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Noise classification pipeline for session events.
+ *
+ * Multi-layer classification system that filters system noise, sidechains,
+ * synthetic messages, and soft noise (system-reminder tags, empty outputs).
+ * Inspired by tail-claude's noise filtering.
+ *
+ * @module formatters/noiseClassifier
+ */
+import type { SessionEvent } from '../types/sessionEvent';
+import type { FollowEvent } from '../watchers/types';
+export type MessageClassification = 'user' | 'ai' | 'system' | 'teammate' | 'compact';
+export interface NoiseResult {
+    /** Whether this event should be dropped entirely */
+    isHardNoise: boolean;
+    /** Reason for soft noise classification, or null if not soft noise */
+    softNoiseReason: string | null;
+    /** Semantic message classification */
+    messageClassification: MessageClassification;
+}
+/**
+ * Determines if an event is "hard noise" and should be dropped entirely.
+ *
+ * Hard noise includes:
+ * - System-type events (non-content)
+ * - Specific infrastructure event types (file-history-snapshot, queue-operation, progress)
+ * - Sidechain/subagent events (when filtering to main conversation)
+ * - Synthetic model entries (model starts with `<synthetic>`)
+ */
+export declare function isHardNoise(event: SessionEvent): boolean;
+/**
+ * FollowEvent variant of hard noise detection.
+ */
+export declare function isHardNoiseFollowEvent(event: FollowEvent): boolean;
+/**
+ * Checks for soft noise that can be hidden but not dropped.
+ *
+ * Soft noise includes:
+ * - system-reminder XML tags in content
+ * - Command caveats (IMPORTANT/Note instructions)
+ * - Empty tool outputs
+ * - User interruption markers
+ *
+ * @returns A reason string if soft noise is detected, null otherwise.
+ */
+export declare function getSoftNoiseReason(event: SessionEvent): string | null;
+/**
+ * Classifies a SessionEvent into semantic message categories.
+ *
+ * Categories:
+ * - `user` — human prompts
+ * - `ai` — assistant responses (text or tool calls)
+ * - `system` — tool results, compaction, infrastructure
+ * - `teammate` — teammate/subagent messages (from `<teammate-message>` blocks)
+ * - `compact` — compaction/summary events
+ */
+export declare function classifyMessage(event: SessionEvent): MessageClassification;
+/**
+ * FollowEvent variant of message classification.
+ */
+export declare function classifyFollowEvent(event: FollowEvent): MessageClassification;
+/**
+ * Determines if the current event should be merged with the previous one.
+ *
+ * Consecutive assistant text messages (without tool calls between them)
+ * can be merged into a single display entry.
+ */
+export declare function shouldMergeWithPrevious(current: SessionEvent, previous: SessionEvent | null): boolean;
+/**
+ * Performs full noise classification on a SessionEvent.
+ * Combines hard noise detection, soft noise detection, and message classification.
+ */
+export declare function classifyNoise(event: SessionEvent): NoiseResult;