sidekick-shared 0.27.6 → 0.28.0

package/dist/esm/historicalStore.js

@@ -0,0 +1,305 @@
+/**
+ * Pure mutations of the `historical-data.json` store.
+ *
+ * Ported verbatim from the VS Code extension's HistoricalDataService so the
+ * CLI importer and the extension apply session summaries the same way:
+ * a session's previous contribution is subtracted before the new one is
+ * added (idempotent replacement), daily, hourly, monthly, and all-time
+ * buckets are updated together, and the per-session record list is capped
+ * at `HISTORICAL_SESSION_RETENTION_LIMIT`. Browser-safe: no Node imports.
+ *
+ * @module historicalStore
+ */
+import { formatLocalDateKey } from './formatting';
+import { HISTORICAL_SESSION_RETENTION_LIMIT, createEmptyTokenTotals } from './types/historicalData';
+function mergeModelUsage(existing, incoming) {
+    const map = new Map();
+    for (const record of existing)
+        map.set(record.model, { ...record });
+    for (const record of incoming) {
+        const current = map.get(record.model);
+        if (current) {
+            current.calls += record.calls;
+            current.tokens += record.tokens;
+            current.cost += record.cost;
+            // Unpriced taints: if either side was unpriced, the merged row is too.
+            // Legacy v1 records (priced === undefined) are assumed priced.
+            if (record.priced === false || current.priced === false)
+                current.priced = false;
+        }
+        else {
+            map.set(record.model, { ...record });
+        }
+    }
+    return Array.from(map.values());
+}
+function mergeToolUsage(existing, incoming) {
+    const map = new Map();
+    for (const record of existing)
+        map.set(record.tool, { ...record });
+    for (const record of incoming) {
+        const current = map.get(record.tool);
+        if (current) {
+            current.calls += record.calls;
+            current.successCount += record.successCount;
+            current.failureCount += record.failureCount;
+        }
+        else {
+            map.set(record.tool, { ...record });
+        }
+    }
+    return Array.from(map.values());
+}
+function subtractTokenTotals(target, contribution) {
+    target.inputTokens = Math.max(0, target.inputTokens - contribution.inputTokens);
+    target.outputTokens = Math.max(0, target.outputTokens - contribution.outputTokens);
+    target.cacheWriteTokens = Math.max(0, target.cacheWriteTokens - contribution.cacheWriteTokens);
+    target.cacheReadTokens = Math.max(0, target.cacheReadTokens - contribution.cacheReadTokens);
+}
+function subtractModelUsage(existing, outgoing) {
+    const map = new Map(existing.map((record) => [record.model, { ...record }]));
+    for (const record of outgoing) {
+        const current = map.get(record.model);
+        if (!current)
+            continue;
+        current.calls = Math.max(0, current.calls - record.calls);
+        current.tokens = Math.max(0, current.tokens - record.tokens);
+        current.cost = Math.max(0, current.cost - record.cost);
+        if (current.calls === 0 && current.tokens === 0)
+            map.delete(record.model);
+    }
+    return [...map.values()];
+}
+function subtractToolUsage(existing, outgoing) {
+    const map = new Map(existing.map((record) => [record.tool, { ...record }]));
+    for (const record of outgoing) {
+        const current = map.get(record.tool);
+        if (!current)
+            continue;
+        current.calls = Math.max(0, current.calls - record.calls);
+        current.successCount = Math.max(0, current.successCount - record.successCount);
+        current.failureCount = Math.max(0, current.failureCount - record.failureCount);
+        if (current.calls === 0)
+            map.delete(record.tool);
+    }
+    return [...map.values()];
+}
+function subtractSummary(bucket, summary, now) {
+    subtractTokenTotals(bucket.tokens, summary.tokens);
+    bucket.totalCost = Math.max(0, bucket.totalCost - summary.totalCost);
+    bucket.messageCount = Math.max(0, bucket.messageCount - summary.messageCount);
+    bucket.sessionCount = Math.max(0, bucket.sessionCount - 1);
+    bucket.modelUsage = subtractModelUsage(bucket.modelUsage, summary.modelUsage);
+    bucket.toolUsage = subtractToolUsage(bucket.toolUsage, summary.toolUsage);
+    bucket.updatedAt = now.toISOString();
+}
+function accumulateSummary(bucket, summary, now) {
+    bucket.tokens.inputTokens += summary.tokens.inputTokens;
+    bucket.tokens.outputTokens += summary.tokens.outputTokens;
+    bucket.tokens.cacheWriteTokens += summary.tokens.cacheWriteTokens;
+    bucket.tokens.cacheReadTokens += summary.tokens.cacheReadTokens;
+    bucket.totalCost += summary.totalCost;
+    bucket.messageCount += summary.messageCount;
+    bucket.sessionCount += 1;
+    bucket.modelUsage = mergeModelUsage(bucket.modelUsage, summary.modelUsage);
+    bucket.toolUsage = mergeToolUsage(bucket.toolUsage, summary.toolUsage);
+    bucket.updatedAt = now.toISOString();
+}
+function emptyDaily(date, now) {
+    return {
+        date,
+        tokens: createEmptyTokenTotals(),
+        totalCost: 0,
+        messageCount: 0,
+        sessionCount: 0,
+        modelUsage: [],
+        toolUsage: [],
+        updatedAt: now.toISOString(),
+    };
+}
+function emptyMonthly(month, now) {
+    return {
+        month,
+        tokens: createEmptyTokenTotals(),
+        totalCost: 0,
+        messageCount: 0,
+        sessionCount: 0,
+        modelUsage: [],
+        toolUsage: [],
+        updatedAt: now.toISOString(),
+    };
+}
+function refreshAllTimeDateRange(store) {
+    const dates = Object.keys(store.daily).sort();
+    store.allTime.firstDate = dates[0] ?? '';
+    store.allTime.lastDate = dates[dates.length - 1] ?? '';
+}
+/** Subtract a previously saved session's contribution from every bucket. */
+export function removeSessionSummary(store, record, now = new Date()) {
+    const summary = {
+        sessionId: record.sessionId,
+        startTime: record.startTime,
+        endTime: record.endTime,
+        tokens: { ...record.tokens },
+        totalCost: record.totalCost,
+        messageCount: record.messageCount,
+        modelUsage: record.modelUsage?.map((usage) => ({ ...usage })) ?? [],
+        toolUsage: record.toolUsage?.map((usage) => ({ ...usage })) ?? [],
+        unpricedModelIds: record.unpricedModelIds ? [...record.unpricedModelIds] : undefined,
+    };
+    const date = formatLocalDateKey(new Date(record.startTime));
+    const month = date.substring(0, 7);
+    const daily = store.daily[date];
+    if (daily) {
+        subtractSummary(daily, summary, now);
+        if (daily.sessionCount === 0)
+            delete store.daily[date];
+    }
+    const hourly = store.hourly?.[date];
+    if (hourly && store.hourly) {
+        const hour = new Date(record.startTime).getHours();
+        const bucket = hourly.find((entry) => entry.hour === hour);
+        if (bucket) {
+            subtractTokenTotals(bucket.tokens, summary.tokens);
+            bucket.totalCost = Math.max(0, bucket.totalCost - summary.totalCost);
+            bucket.messageCount = Math.max(0, bucket.messageCount - summary.messageCount);
+            bucket.sessionCount = Math.max(0, bucket.sessionCount - 1);
+        }
+        store.hourly[date] = hourly.filter((entry) => entry.sessionCount > 0);
+        if (store.hourly[date].length === 0)
+            delete store.hourly[date];
+    }
+    const monthly = store.monthly[month];
+    if (monthly) {
+        subtractSummary(monthly, summary, now);
+        if (monthly.sessionCount === 0)
+            delete store.monthly[month];
+    }
+    subtractSummary(store.allTime, summary, now);
+}
+/**
+ * Apply a completed session to the daily, hourly, monthly, and all-time
+ * buckets and the capped per-session list. Re-applying the same session id
+ * replaces its earlier contribution instead of double counting it.
+ *
+ * Returns the stored per-session record.
+ */
+export function applySessionSummary(store, summary, options = {}) {
+    const now = options.now ?? new Date();
+    const retentionLimit = options.retentionLimit ?? HISTORICAL_SESSION_RETENTION_LIMIT;
+    const date = formatLocalDateKey(new Date(summary.startTime));
+    const month = date.substring(0, 7);
+    store.sessions ??= [];
+    const previous = store.sessions.find((session) => session.sessionId === summary.sessionId);
+    if (previous)
+        removeSessionSummary(store, previous, now);
+    // Daily
+    store.daily[date] ??= emptyDaily(date, now);
+    accumulateSummary(store.daily[date], summary, now);
+    // Hourly (by the session's local start hour)
+    store.hourly ??= {};
+    store.hourly[date] ??= [];
+    const hour = new Date(summary.startTime).getHours();
+    let hourly = store.hourly[date].find((entry) => entry.hour === hour);
+    if (!hourly) {
+        hourly = {
+            hour,
+            tokens: createEmptyTokenTotals(),
+            totalCost: 0,
+            messageCount: 0,
+            sessionCount: 0,
+        };
+        store.hourly[date].push(hourly);
+    }
+    hourly.tokens.inputTokens += summary.tokens.inputTokens;
+    hourly.tokens.outputTokens += summary.tokens.outputTokens;
+    hourly.tokens.cacheWriteTokens += summary.tokens.cacheWriteTokens;
+    hourly.tokens.cacheReadTokens += summary.tokens.cacheReadTokens;
+    hourly.totalCost += summary.totalCost;
+    hourly.messageCount += summary.messageCount;
+    hourly.sessionCount += 1;
+    // Monthly
+    store.monthly[month] ??= emptyMonthly(month, now);
+    accumulateSummary(store.monthly[month], summary, now);
+    // All-time
+    accumulateSummary(store.allTime, summary, now);
+    if (!store.allTime.firstDate || date < store.allTime.firstDate)
+        store.allTime.firstDate = date;
+    if (!store.allTime.lastDate || date > store.allTime.lastDate)
+        store.allTime.lastDate = date;
+    const record = {
+        sessionId: summary.sessionId,
+        provider: summary.provider ?? 'unknown',
+        project: summary.project ?? 'unknown',
+        startTime: summary.startTime,
+        endTime: summary.endTime,
+        tokens: { ...summary.tokens },
+        totalCost: summary.totalCost,
+        messageCount: summary.messageCount,
+        modelUsage: summary.modelUsage.map((usage) => ({ ...usage })),
+        toolUsage: summary.toolUsage.map((usage) => ({ ...usage })),
+        unpricedModelIds: summary.unpricedModelIds ? [...summary.unpricedModelIds] : undefined,
+        qualityScore: summary.qualityScore ?? 0,
+        qualityFactors: summary.qualityFactors ?? [],
+        additions: summary.additions ?? 0,
+        deletions: summary.deletions ?? 0,
+        costPerChangedLine: summary.costPerChangedLine ?? null,
+    };
+    store.sessions = [
+        ...store.sessions.filter((session) => session.sessionId !== summary.sessionId),
+        record,
+    ].slice(-retentionLimit);
+    refreshAllTimeDateRange(store);
+    return record;
+}
+/** Whether a session file has already been folded into the store. */
+export function isFileImported(store, filePath) {
+    return store.importedFiles?.includes(filePath) ?? false;
+}
+/** Record a session file as imported. Returns false when it was already listed. */
+export function markFileImported(store, filePath, now = new Date()) {
+    store.importedFiles ??= [];
+    if (store.importedFiles.includes(filePath))
+        return false;
+    store.importedFiles.push(filePath);
+    store.lastImportTimestamp = now.toISOString();
+    return true;
+}
+/**
+ * Build the summary the history store expects from unified session stats,
+ * so the CLI importer and the extension's first-activation import store the
+ * same per-model cost, tool success/failure split, and unpriced markers.
+ * Pending tool calls count as successes (stats only split out failures).
+ */
+export function sessionSummaryFromStats(stats, options = {}) {
+    const modelUsage = Object.entries(stats.modelUsage).map(([model, usage]) => ({
+        model,
+        calls: usage.calls,
+        tokens: usage.tokens,
+        cost: usage.costUsd,
+        priced: usage.priced,
+    }));
+    const unpricedModelIds = modelUsage.filter((m) => m.priced === false).map((m) => m.model);
+    const toolUsage = Object.entries(stats.toolUsage).map(([tool, calls]) => {
+        const failureCount = stats.toolFailures[tool] ?? 0;
+        return { tool, calls, successCount: Math.max(0, calls - failureCount), failureCount };
+    });
+    return {
+        sessionId: stats.sessionId,
+        startTime: stats.startTime,
+        endTime: stats.endTime || stats.startTime,
+        tokens: {
+            inputTokens: stats.tokens.input,
+            outputTokens: stats.tokens.output,
+            cacheWriteTokens: stats.tokens.cacheWrite,
+            cacheReadTokens: stats.tokens.cacheRead,
+        },
+        totalCost: stats.costUsd,
+        messageCount: stats.messageCount,
+        modelUsage,
+        toolUsage,
+        ...(unpricedModelIds.length > 0 ? { unpricedModelIds } : {}),
+        provider: options.provider ?? stats.providerId,
+        project: options.project ?? 'unknown',
+    };
+}

package/dist/esm/humanPrompt.js

@@ -0,0 +1,88 @@
+/**
+ * One shared definition of "a prompt a person typed" for Claude Code and
+ * Codex transcripts. Pure: no filesystem access, so it can classify messages
+ * from `readSessionTranscript()` or from `collectPromptHistory()` alike.
+ */
+/**
+ * Claude Code `entrypoint` values treated as a person at the keyboard:
+ * the interactive CLI, Claude Desktop's Code surface, and `claude -p`.
+ * `sdk-ts` / `sdk-py` (Agent SDK programs) are excluded.
+ */
+export const HUMAN_CLAUDE_ENTRYPOINTS = Object.freeze([
+    'cli',
+    'claude-desktop',
+    'sdk-cli',
+]);
+/**
+ * Codex `session_meta.source` values whose sessions carry typed prompts.
+ * Subagent sessions (`{ subagent: … }`) are excluded; they replay parent
+ * history. This is a session-level rule applied by `collectPromptHistory()`.
+ */
+export const HUMAN_CODEX_SOURCES = Object.freeze(['cli', 'vscode', 'exec']);
+/** Claude user text that is harness output rather than something typed. */
+const CLAUDE_INJECTED_PREFIX = /^(?:<(?:local-command-stdout|local-command-stderr|local-command-caveat|task-notification|system-reminder|bash-input|bash-stdout|bash-stderr|user-prompt-submit-hook)\b|\[Request interrupted\b|This session is being continued from a previous conversation)/;
+const COMMAND_NAME = /<command-name>\s*([\s\S]*?)\s*<\/command-name>/;
+const COMMAND_ARGS = /<command-args>\s*([\s\S]*?)\s*<\/command-args>/;
+/** Codex user-role blocks injected by the harness (context, instructions, markers). */
+const CODEX_INJECTED_PREFIX = /^(?:# AGENTS\.md instructions\b|<(?:environment_context|user_instructions|recommended_plugins|turn_aborted|skill|subagent_notification|codex_internal_context|user_shell_command|permissions instructions|collaboration_mode)\b)/;
+/** Codex wraps attached images as `<image name=…>` / `</image>` text blocks. */
+const CODEX_IMAGE_WRAPPER = /^<\/?image\b[^>]*>$/;
+/** Whether a canonical transcript message is a prompt a person typed. */
+export function isHumanPrompt(message, provider) {
+    return humanPromptText(message, provider) !== null;
+}
+/**
+ * The visible text of a human prompt, or `null` when the message is not one.
+ * Claude slash commands are returned as typed (`/review foo`); Codex image
+ * wrappers and injected context blocks are dropped. Text is never truncated.
+ */
+export function humanPromptText(message, provider) {
+    if (message.role !== 'user')
+        return null;
+    if ((message.source.originalRole ?? 'user') !== 'user')
+        return null;
+    return provider === 'claude-code' ? claudePromptText(message) : codexPromptText(message);
+}
+function claudePromptText(message) {
+    const source = message.source;
+    if (!source.entrypoint || !HUMAN_CLAUDE_ENTRYPOINTS.includes(source.entrypoint))
+        return null;
+    if (source.isMeta === true || source.isSidechain === true)
+        return null;
+    if (source.isCompactSummary === true)
+        return null;
+    if (source.originKind !== undefined && source.originKind !== 'human')
+        return null;
+    if (source.promptSource === 'system')
+        return null;
+    const text = textBlocks(message).join('\n');
+    const trimmed = text.trim();
+    if (!trimmed)
+        return null;
+    if (CLAUDE_INJECTED_PREFIX.test(trimmed))
+        return null;
+    const command = trimmed.match(COMMAND_NAME);
+    if (command && /^<command-(?:name|message)>/.test(trimmed)) {
+        const name = command[1].trim();
+        if (!name)
+            return null;
+        const args = trimmed.match(COMMAND_ARGS)?.[1].trim() ?? '';
+        const visible = name.startsWith('/') ? name : `/${name}`;
+        return args ? `${visible} ${args}` : visible;
+    }
+    return text;
+}
+function codexPromptText(message) {
+    const typed = textBlocks(message).filter((text) => {
+        const trimmed = text.trim();
+        return (trimmed.length > 0 &&
+            !CODEX_INJECTED_PREFIX.test(trimmed) &&
+            !CODEX_IMAGE_WRAPPER.test(trimmed));
+    });
+    return typed.length > 0 ? typed.join('\n') : null;
+}
+function textBlocks(message) {
+    return message.content
+        .filter((block) => block.type === 'text' && typeof block.text === 'string')
+        .map((block) => block.text);
+}

package/dist/esm/index.js

@@ -0,0 +1,213 @@
+/**
+ * Public API for sidekick-shared.
+ */
+export { normalizeProviderUsage, extractNormalizedUsage, calculateNormalizedUsageCost, } from './usageNormalization';
+export { formatTokenBreakdown, summarizeTokens, sumTokenTotals, TOKEN_CONTEXT_LABEL, TOKEN_MAIN_THREAD_LABEL, TOKEN_SESSION_TOTAL_LABEL, TOKEN_SUBAGENTS_LABEL, TOKEN_TOTAL_LABEL, } from './tokenSummary';
+export { ASCII_CHARS_PER_TOKEN, estimateTextTokens, estimateSerializedTokens, } from './tokenEstimation';
+export { projectSessionTranscript } from './transcript';
+export { listRecentSessions, readSessionTranscript } from './sessionTranscripts';
+export { collectPromptHistory, isPromptHistorySessionSettled, parsePromptHistoryCursor, } from './promptHistory';
+export { collectSessionPromptHistory } from './sessionPromptHistory';
+export { HUMAN_CLAUDE_ENTRYPOINTS, HUMAN_CODEX_SOURCES, humanPromptText, isHumanPrompt, } from './humanPrompt';
+export { computeSessionFileStats, firstUserPrompt, providerContextSizeFn, readSessionFileStats, } from './sessionStats';
+export { readSessionReportInputs } from './report/sessionReportInputs';
+export { fingerprintString, sessionFingerprintParts } from './sessionFingerprint';
+export { STATE_FILE_NAME, STATE_FILE_SCHEMA_VERSION, billingBlockToStateFile, getStateFilePath, quotaToStateFile, readStateFile, writeStateFile, } from './stateFile';
+export { BILLING_BLOCK_DURATION_MS, computeBillingBlocks, findActiveBillingBlock, } from './usage/billingBlocks';
+export { MAX_USAGE_CACHE_FILES, USAGE_CACHE_VERSION, collectUsageEvents, getUsageCacheDir, pruneUsageCache, } from './usage/usageEvents';
+export { applySessionSummary, isFileImported, markFileImported, removeSessionSummary, sessionSummaryFromStats, } from './historicalStore';
+export { ACTIVE_SESSION_MTIME_THRESHOLD_MS, importSessionHistory, } from './usage/importSessionHistory';
+export { bucketUsage, summarizeUsageRows, usageBucketKey, weekKey } from './usage/usageReports';
+export { ObservedSessionCollector, observedSessionSourceFromProvider, fileFingerprint, fileFingerprintParts, } from './observedSessionCollector';
+export { DirectoryListingCache, splitWatchedPath } from './providers/directoryListingCache';
+export { isAggregateCodexLimit } from './types/codex';
+export { TASK_PERSISTENCE_SCHEMA_VERSION, normalizeTaskStatus } from './types/taskPersistence';
+export { DECISION_LOG_SCHEMA_VERSION } from './types/decisionLog';
+export { KNOWLEDGE_NOTE_SCHEMA_VERSION, IMPORTANCE_DECAY_FACTORS, STALENESS_THRESHOLDS, } from './types/knowledgeNote';
+export { HISTORICAL_DATA_SCHEMA_VERSION, HISTORICAL_SESSION_RETENTION_LIMIT, createEmptyTokenTotals, createEmptyDataStore, } from './types/historicalData';
+export { PLAN_SCHEMA_VERSION, MAX_PLANS_PER_PROJECT } from './types/plan';
+// Paths
+export { CONFIG_DIR_ENV_VAR, getConfigDir, getConfigDirOverride, getDefaultConfigDir, setConfigDir, getProjectDataPath, getGlobalDataPath, encodeWorkspacePath, getProjectSlug, getProjectSlugRaw, resolveProjectIdentity, } from './paths';
+export { migrateLegacyProjectStores } from './projectMigration';
+// Readers
+export { readTasks } from './readers/tasks';
+export { readDecisions } from './readers/decisions';
+export { readNotes } from './readers/notes';
+export { readHistory } from './readers/history';
+export { readLatestHandoff } from './readers/handoff';
+export { readPlans, getLatestPlan, writePlans, getPlanAnalytics, readClaudeCodePlanFiles, } from './readers/plans';
+// Atomic persistence writers
+export { atomicWriteJson, atomicWriteJsonSync, atomicWriteFileSync, updateJsonStoreAtomic, updateJsonStoreAtomicSync, withFileLockSync, } from './writers/atomic';
+export { addTask, completeTask } from './writers/tasks';
+export { addDecision, decisionFingerprint } from './writers/decisions';
+export { addNote } from './writers/notes';
+export { renderHandoffUrlTemplate } from './handoffUrl';
+export { SESSION_PROVIDER_IDS } from './providers/types';
+export { createSessionProviders } from './providers/factory';
+export { createProviderSessionAdapterV1, derivePendingUserRequestV1, getObservedActivityReason, } from './types/observedSessionV1';
+export { _resetProviderDetectionCache, detectProvider, getAllDetectedProviders, } from './providers/detect';
+export { ClaudeCodeProvider } from './providers/claudeCode';
+export { OpenCodeProvider, getOpenCodeDataDir } from './providers/openCode';
+export { CodexProvider, findCodexRolloutFile } from './providers/codex';
+export { walkRolloutFiles, walkRolloutFilesAsync } from './providers/rolloutWalker';
+// Parsers — JSONL
+export { JsonlParser, TRUNCATION_PATTERNS } from './parsers/jsonl';
+// Parsers — OpenCode
+export { normalizeToolName, normalizeToolInput, detectPlanModeFromText, convertOpenCodeMessage, parseDbMessageData, parseDbPartData, } from './parsers/openCodeParser';
+// Parsers — Codex
+export { CodexRolloutParser, DEFAULT_MAX_TRACKED_TOOL_CALLS, extractPatchFilePaths, normalizeCodexToolName, normalizeCodexToolInput, resolveCodexCallUsage, } from './parsers/codexParser';
+// Parsers — Subagent scanning
+export { scanSubagentDir, extractTaskInfo, readAgentMeta } from './parsers/subagentScanner';
+// Usage — split-line dedupe, subagent tokens, session totals
+export { ClaudeUsageDeduper, SYNTHETIC_MODEL, dedupedRawClaudeUsage, normalizeClaudeUsage, } from './usage/claudeUsageDedupe';
+export { addUsageToSubagent } from './usage/subagentUsage';
+export { collectSessionTokenTotals, combineSessionTokenTotals, readMainThreadTokenTotals, scanSessionSubagents, subagentTokenTotals, } from './sessionTokenTotals';
+// Parsers — Session activity detection
+export { classifySessionActivity, detectSessionActivity, refreshSessionActivityState, SESSION_ACTIVITY_GRACE_PERIOD_MS, SESSION_ACTIVITY_STALENESS_MS, } from './parsers/sessionActivityDetector';
+// Parsers — Session path resolution (Claude Code)
+export { encodeWorkspacePath as encodeClaudeWorkspacePath, getSessionDirectory as getClaudeSessionDirectory, discoverSessionDirectory, findActiveSession as findActiveClaudeSession, findAllSessions as findAllClaudeSessions, findSessionsInDirectory, findSessionFilesWithStats, findSubdirectorySessionDirs, getMostRecentlyActiveSessionDir, decodeEncodedPath, getAllProjectFolders as getAllClaudeProjectFolders, resolveWorktreeMainRepo, discoverWorktreeSiblings, findAllSessionsWithWorktrees, } from './parsers/sessionPathResolver';
+// Parsers — Subagent traces
+export { scanSubagentTraces } from './parsers/subagentTraceParser';
+// Parsers — MCP tool names
+export { parseMcpToolName } from './parsers/mcpToolName';
+// Parsers — Codex native history
+export { readCodexHistory } from './parsers/codexHistory';
+// Session previews (bounded, stat-first)
+export { listSessionPreviews, listSessionPreviewsAsync, readSessionPreview, readSessionPreviewAsync, } from './sessionPreviews';
+// Parsers — Debug log parsing
+export { parseDebugLog, filterByLevel, collapseDuplicates, discoverDebugLogs, } from './parsers/debugLogParser';
+// Database wrappers
+export { OpenCodeDatabase } from './providers/openCodeDatabase';
+export { CodexDatabase } from './providers/codexDatabase';
+// Search
+export { searchSessions } from './search/sessionSearch';
+export { FilterEngine } from './search/advancedFilter';
+// Context
+export { composeContext } from './context/composer';
+export { buildSessionContextSnapshot, calculateSessionContextPressure, createSessionContextProjector, readSessionContextSnapshot, } from './context/sessionContext';
+// Assistant turn projection
+export { assistantTurnEventsFromSessionEvents, extractTurnSubagents, isAssistantTurnSubagentTool, reasoningSummary, segmentAssistantTurn, } from './turns/assistantTurn';
+// Plan Extraction
+export { PlanExtractor, parsePlanMarkdown as parsePlanMarkdownShared, extractProposedPlan as extractProposedPlanShared, } from './parsers/planExtractor';
+// Changelog Parsing
+export { parseChangelog } from './parsers/changelogParser';
+export { createWatcher, resolveSessionPath } from './watchers/factory';
+export { toFollowEvents } from './watchers/eventBridge';
+export { createJsonlTail, DEFAULT_JSONL_TAIL_MAX_LINE_BYTES, DEFAULT_JSONL_TAIL_READ_BYTES, } from './watchers/jsonlTail';
+// Formatters
+export { addLocalDays, formatDurationMs, formatLocalDateKey, formatTokenCount, parseLocalDateKey, } from './formatting';
+export { formatToolSummary } from './formatters/toolSummary';
+export { isHardNoise, isHardNoiseFollowEvent, getSoftNoiseReason, classifyMessage, classifyFollowEvent, shouldMergeWithPrevious, classifyNoise, } from './formatters/noiseClassifier';
+export { formatSessionText, formatSessionMarkdown, formatSessionJson, } from './formatters/sessionDump';
+export { highlight as highlightEvent, clearHighlightCache, HIGHLIGHT_CSS, } from './formatters/eventHighlighter';
+// Phrases
+export { ALL_PHRASES, PHRASE_CATEGORIES, getRandomPhrase } from './phrases';
+// Aggregation
+export { EventAggregator, parseTodoDependencies } from './aggregation/EventAggregator';
+export { SessionMonitor } from './sessionMonitor';
+export { saveSnapshot, loadSnapshot, deleteSnapshot, isSnapshotValid, pruneSnapshots, MAX_SNAPSHOT_FILES, getSnapshotPath, } from './aggregation/snapshot';
+export { ERROR_HISTORY_SCHEMA_VERSION, MAX_ERROR_HISTORY_SESSIONS, appendErrorHistory, getTopFailingTools, readErrorHistory, } from './errorHistory';
+// Aggregation — analytics engines
+export { FrequencyTracker } from './aggregation/FrequencyTracker';
+export { HeatmapTracker } from './aggregation/HeatmapTracker';
+export { PatternExtractor } from './aggregation/PatternExtractor';
+export { calculateQualityTrend, scoreSessionQuality } from './analytics/qualityScore';
+export { calculateCodeImpact } from './analytics/codeImpact';
+export { classifyCostProvenance, describeCostProvenance } from './aggregation/costProvenance';
+export { calculateCompactionLedger, formatCompactionLedger } from './analytics/compactionLedger';
+// Report — HTML session report generation
+export { generateHtmlReport, parseTranscript, parseTranscriptFromEvents, openInBrowser, } from './report';
+// Credential I/O (platform-aware: Keychain on macOS, file on Linux/Windows)
+export { readActiveCredentials, readClaudeCredentialStore, writeActiveCredentials, deleteStoredCredentials, ClaudeCredentialWriteError, SIDEKICK_KEYCHAIN_COMMENT_PREFIX, } from './credentialIO';
+export { decideLiveClaudeWrite } from './claudeLiveGuard';
+export { readClaudeCredentialLedger, getClaudeCredentialLedgerPath, } from './claudeCredentialLedger';
+export { inspectClaudeCredentialStores, repairClaudeCredentialStores, parseKeychainDump, } from './claudeCredentialDoctor';
+// Credentials
+export { readClaudeMaxCredentials, readClaudeMaxCredentialsRaw, readClaudeMaxAccessTokenSync, } from './credentials';
+export { parseClaudeCredentialBlob, claudeCredentialFreshness, isNewerClaudeCredential, resolveClaudeRefreshExpiry, claudeRefreshFingerprint, claudeLoginOnly, mergeClaudeLoginIntoLive, CLAUDE_ACCESS_TOKEN_LIFETIME_MS, CLAUDE_REFRESH_TOKEN_LIFETIME_ESTIMATE_MS, } from './claudeCredentials';
+export { parseAuthJson as parseCodexAuthJson, readAuthIdentityFromRaw as readCodexAuthIdentity, readLastRefresh as readCodexLastRefresh, readAccessTokenExpiry as readCodexAccessTokenExpiry, identitiesMatch as codexIdentitiesMatch, } from './codexAuth';
+// Accounts
+export { ensureDefaultAccounts } from './ensureDefaultAccounts';
+export { readAccountRegistry, writeAccountRegistry, readActiveClaudeAccount, addCurrentAccount, switchToAccount, switchToAccountAsync, syncClaudeLiveState, cleanupAbandonedClaudeLogins, resolveActiveClaudeHome, applyActiveClaudeToLiveHome, reconcileClaudeAuthState, removeAccount, listAccounts, getActiveAccount, resolveActiveClaudeAccount, isMultiAccountEnabled, } from './accounts';
+export { beginAccountLogin, getAccountLoginStatus, getAccountLoginStatusAsync, finalizeAccountLogin, finalizeAccountLoginAsync, spawnAccountLogin, switchAccount, switchAccountAsync, undoLastSwitch, getLastSwitch, listAllAccounts, resolveClaudeLoginCommand, discardAccountLogin, } from './accountManager';
+export { readLastSwitch, getLastSwitchPath } from './accountSwitch';
+export { syncLiveAccountState, syncLiveAccountStateSync, cleanupAbandonedLogins, } from './accountSync';
+export { getAccountHealth, listAccountsWithHealth, readHealthSidecar, getHealthSidecarPath, } from './accountHealth';
+export { getAccountLaunchEnv } from './accountLaunch';
+export { refreshInactiveAccounts, keepAliveCommand } from './keepAlive';
+export { findRunningProcesses, findRunningProcessesSync, detectRunningAccountConsumers, detectRunningAccountConsumersSync, describeAccountConsumer, ACCOUNT_CONSUMER_REACHABILITY, } from './processDetection';
+export { getAccountsDir, readSavedAccountRegistry, writeSavedAccountRegistry, listSavedAccountProfiles, getActiveSavedAccount, upsertSavedAccountProfile, setActiveSavedAccount, replaceSavedAccountProfiles, removeSavedAccountProfile, } from './accountRegistry';
+export { ACCOUNT_PROVIDER_IDS } from './accountRegistry';
+export { getActiveAccountStatus } from './accountStatus';
+export { onAccountsChanged } from './accountChanges';
+export { getClaudeProfilesDir, getClaudeProfileHome, getClaudeConfigPath, claudeKeychainSuffix, claudeKeychainService, claudeKeychainAccountName, buildClaudeChildEnv, CLAUDE_SECURESTORAGE_CONFIG_DIR_ENV, isClaudeProfileAuthenticated, readClaudeProfileIdentity, readLiveClaudeIdentity, } from './claudeProfiles';
+export { getLiveClaudeHome, getDefaultClaudeHome, isDefaultClaudeHome, getClaudeProjectsDir, } from './claudePaths';
+export { getCodexProfilesDir, getCodexProfileHome, getCodexMonitoringHomes, getSystemCodexHome, listCodexAccounts, getActiveCodexAccount, resolveActiveCodexAccount, resolveSidekickCodexHome, getCodexExecutionEnv, prepareCodexAccount, prepareCodexAccountAsync, finalizeCodexAccount, finalizeCodexAccountAsync, switchToCodexAccount, switchToCodexAccountAsync, removeCodexAccount, syncCodexLiveState, cleanupAbandonedCodexLogins, getCodexCredentialStoreMode, CODEX_KEYRING_FIX_HINT, } from './codexProfiles';
+export { writeAccountLauncher, writeLauncher, removeLauncher } from './terminalSync';
+export { DEFAULT_AUTO_SWITCH_CONFIG, decideAutoSwitch, AutoSwitchController } from './autoSwitch';
+// Quota
+export { FIVE_HOUR_WINDOW_MS, QUOTA_PROVIDER_IDS, SEVEN_DAY_WINDOW_MS, fetchQuota, projectQuotaWindow, withQuotaProjections, } from './quota';
+export { describeQuotaFailure } from './quotaPresentation';
+export { QuotaPoller } from './quotaPoller';
+export { readQuotaSnapshot, writeQuotaSnapshot } from './quotaSnapshots';
+export { resolveQuota } from './quotaResolver';
+export { classifyQuotaFreshness, formatQuotaAge, QUOTA_AGING_MAX_AGE_MS, QUOTA_FRESH_MAX_AGE_MS, } from './quota';
+export { DEFAULT_QUOTA_THRESHOLDS, describeQuotaThresholdAlert, evaluateQuotaThresholds, } from './quotaThresholds';
+export { parseClaudeStatuslinePayload, quotaFromStatuslinePayload, } from './statusline/claudeStatuslinePayload';
+export { appendQuotaHistorySample, readQuotaHistoryRange, readQuotaHistoryDailyBuckets, pruneQuotaHistory, getWorkspaceIdFromPath, } from './quotaHistory';
+export { fetchCodexResetCreditsFromApi, fetchCodexQuotaFromApi, quotaFromCodexRateLimits, readLatestCodexQuotaFromRollouts, resolveCodexQuota, resolveCodexQuotaFromLocalSources, } from './codexQuota';
+export { CodexQuotaWatcher } from './codexQuotaWatcher';
+export { fetchZaiQuotaFromApi, quotaStateFromZaiQuotaLimitPayload, readZaiCredentials, resolveZaiQuota, } from './zaiQuotaApi';
+export { MultiProviderQuotaService } from './multiProviderQuotaService';
+export { RUNTIME_QUOTA_PROVIDER_IDS } from './providerQuota';
+export { BurnRateCalculator, estimateTimeToQuota } from './statusline/BurnRateCalculator';
+export { formatStatusline, selectStatuslineAccount } from './statusline/formatter';
+// Model Context
+export { getModelContextWindowSize, resolveModelContextWindow, DEFAULT_CONTEXT_WINDOW, } from './modelContext';
+// Model Info & Pricing
+export { parseModelId, getModelPricing, resolveModelPricing, getModelInfo, calculateCost, calculateCostWithPricing, calculateCostWithProvenance, mergeCostSources, shortModelName, getModelDisplayInfo, compareModelIds, sortModelIds, formatCost, MODEL_PROVIDER_IDS, } from './modelInfo';
+export { exportResolvedModelCatalog, importResolvedModelCatalog, registerModelAlias, resolveModelAlias, RESOLVED_MODEL_CATALOG_SCHEMA_VERSION, } from './modelCatalog';
+// Pricing Catalog (LiteLLM hydration) — Node-only. Safe for extension host
+// and CLI; do NOT import from browser bundles (webviews).
+export { hydratePricingCatalog, normalizeLiteLlmCatalog, normalizeLiteLlmContextWindows, LITELLM_CATALOG_URL, } from './pricingCatalog';
+// Observed context windows (provider-reported, persisted) — Node-only.
+export { loadObservedContextWindows, recordObservedContextWindow, getObservedContextWindowPath, } from './observedContextWindows';
+// Extractors — per-event token usage and tool call extraction
+export { extractTokenUsage } from './extractors/tokenUsage';
+// Extractors — actionable session assets. Node-only: safe for CLI and
+// extension-host code, not for browser/webview bundles.
+export { extractUrls, extractFilePaths, extractCommands } from './extractors/sessionAssets';
+export { readClaudeAssets, claudeSessions } from './extractors/sources/claudeAssets';
+export { readCodexAssets, codexSessions } from './extractors/sources/codexAssets';
+export { gatherAssetsForCwd } from './extractors/gatherAssets';
+export { categorizeError, extractErrorMessage } from './extractors/errorTaxonomy';
+export { extractToolCall, extractToolCalls, ToolCallTracker } from './extractors/toolCall';
+// Schemas — Zod runtime validation for session events
+export { messageUsageSchema, sessionMessageSchema, sessionEventSchema, permissionModeSchema, extractSessionEvents, } from './schemas/sessionEvent';
+// Schemas — Zod runtime validation for quota / provider quota / peak hours
+export { quotaWindowSchema, quotaStateSchema, quotaFailureKindSchema, quotaProviderIdSchema, quotaSourceSchema, codexResetCreditSchema, codexResetCreditsSnapshotSchema, peakHoursStateSchema, quotaFailureDescriptorSchema, runtimeQuotaProviderSchema, providerQuotaStateSchema, claudeProviderQuotaStateSchema, codexProviderQuotaStateSchema, zaiProviderQuotaStateSchema, providerQuotaMapSchema, } from './schemas/quota';
+// Schemas — Zod runtime validation for quota history
+export { quotaHistoryRuntimeProviderSchema, quotaHistorySampleSchema, quotaHistoryDailyBucketSchema, } from './schemas/quotaHistory';
+// Schemas — Zod runtime validation for provider-failure diagnoses
+export { providerAuthenticationEvidenceSchema, providerFailureEvidenceSchema, providerRetryAfterSchema, providerFailureDiagnosisSchema, } from './schemas/providerFailure';
+// Schemas — Zod runtime validation for account status
+export { activeProviderAccountStatusSchema, activeAccountStatusSchema, } from './schemas/accountStatus';
+export { accountProviderIdSchema, accountManagerResultSchema, beginAccountLoginResultSchema, accountLoginStatusSchema, accountEntrySchema, savedAccountProfileSchema, listAllAccountsResultSchema, } from './schemas/accountManager';
+export { assistantTurnEventSchema, assistantTurnEventTypeSchema, assistantTurnNarrationStepSchema, assistantTurnProcessSchema, assistantTurnProcessStepSchema, assistantTurnProjectionSchema, assistantTurnReasoningTimelineItemSchema, assistantTurnSubagentSchema, assistantTurnSubagentStatusSchema, assistantTurnTimelineItemSchema, assistantTurnToolGroupStepSchema, assistantTurnToolRefSchema, } from './schemas/assistantTurn';
+// Provider Status
+export { fetchProviderStatus, fetchOpenAIStatus, toLegacyProviderStatus } from './providerStatus';
+// Shared diagnostics / health report
+export { formatHealthReport, getSessionDiagnostics, runDoctor } from './doctor';
+// Peak Hours (PromoClock — third-party)
+export { _resetPeakHoursCache, createPeakHoursNotApplicableState, DEFAULT_PEAK_HOURS_TIMEOUT_MS, fetchPeakHoursStatus, getScheduledPeakHoursState, isClaudeCodeSessionProvider, PEAK_HOURS_CACHE_MS, PEAK_HOURS_DESCRIPTION, scopePeakHoursToSessionProvider, } from './peakHours';
+export { FAILING_TOOL_TREND_ARROWS, failingToolTrend, mergeFailingToolWindows, } from './failingTools';
+export { diagnoseProviderFailure, PROVIDER_AUTHENTICATION_SOURCES, PROVIDER_AUTHENTICATION_STATES, PROVIDER_CREDENTIAL_KINDS, PROVIDER_FAILURE_CODES, PROVIDER_FAILURE_EVIDENCE_SOURCES, PROVIDER_RECOVERY_ACTIONS, } from './providerFailure';
+export { fetchProviderServiceStatus } from './providerServiceStatus';
+export { inspectCodexCredentialStores, repairCodexCredentialStores } from './codexCredentialDoctor';
+export { readStoredCodexAccount, syncCodexLiveStateAsync } from './codexProfiles';
+// Codex rollout directories (live and archived)
+export { getCodexSessionsDirs, CODEX_SESSIONS_SUBDIR, CODEX_ARCHIVED_SESSIONS_SUBDIR, } from './codexPaths';
+// Tool categories across providers
+export { classifyTool, TOOL_CATEGORIES } from './toolCategory';
+// Workspace roots (realpath plus git worktree expansion)
+export { resolveWorkspaceRoots } from './workspaceRoots';