sidekick-shared 0.23.0 → 0.24.0

package/dist/types/historicalData.d.ts

@@ -51,6 +51,13 @@ export interface DailyData {
     toolUsage: ToolUsageRecord[];
     updatedAt: string;
 }
+export interface HourlyData {
+    hour: number;
+    tokens: TokenTotals;
+    totalCost: number;
+    messageCount: number;
+    sessionCount: number;
+}
 export interface MonthlyData {
     month: string;
     tokens: TokenTotals;
@@ -75,6 +82,8 @@ export interface AllTimeStats {
 export interface HistoricalDataStore {
     schemaVersion: number;
     daily: Record<string, DailyData>;
+    /** Hourly buckets keyed by local YYYY-MM-DD. */
+    hourly?: Record<string, HourlyData[]>;
     monthly: Record<string, MonthlyData>;
     allTime: AllTimeStats;
     lastSaved: string;
@@ -92,6 +101,10 @@ export interface SessionHistoryRecord {
     tokens: TokenTotals;
     totalCost: number;
     messageCount: number;
+    /** Schema v3 additive fields used to make aggregate replacement idempotent. */
+    modelUsage?: ModelUsageRecord[];
+    toolUsage?: ToolUsageRecord[];
+    unpricedModelIds?: string[];
     qualityScore: number;
     qualityFactors: Array<{
         id: string;
@@ -132,3 +145,4 @@ export interface SessionSummary {
     costPerChangedLine?: number | null;
 }
 export declare function createEmptyTokenTotals(): TokenTotals;
+export declare function createEmptyDataStore(): HistoricalDataStore;

package/dist/types/historicalData.js

@@ -18,6 +18,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HISTORICAL_SESSION_RETENTION_LIMIT = exports.HISTORICAL_DATA_SCHEMA_VERSION = void 0;
 exports.createEmptyTokenTotals = createEmptyTokenTotals;
+exports.createEmptyDataStore = createEmptyDataStore;
 exports.HISTORICAL_DATA_SCHEMA_VERSION = 3;
 exports.HISTORICAL_SESSION_RETENTION_LIMIT = 500;
 function createEmptyTokenTotals() {
@@ -28,3 +29,24 @@ function createEmptyTokenTotals() {
         cacheReadTokens: 0,
     };
 }
+function createEmptyDataStore() {
+    const now = new Date().toISOString();
+    return {
+        schemaVersion: exports.HISTORICAL_DATA_SCHEMA_VERSION,
+        daily: {},
+        monthly: {},
+        sessions: [],
+        allTime: {
+            tokens: createEmptyTokenTotals(),
+            totalCost: 0,
+            messageCount: 0,
+            sessionCount: 0,
+            firstDate: '',
+            lastDate: '',
+            modelUsage: [],
+            toolUsage: [],
+            updatedAt: now,
+        },
+        lastSaved: now,
+    };
+}

package/dist/types/observedSessionV1.d.ts

@@ -1,5 +1,6 @@
 import type { SessionEvent } from './sessionEvent';
 import type { ProviderId, SessionProviderBase } from '../providers/types';
+import type { CanonicalTranscriptUsageTotals } from '../transcript';
 export type ObservationProvenanceV1 = 'reported' | 'estimated' | 'inferred';
 export interface SessionEvidenceRefV1 {
     schemaVersion: 1;
@@ -40,7 +41,8 @@ export interface ObservedAgentSessionV1 {
         outputTokens: ObservedValueV1<number>;
         cacheReadTokens: ObservedValueV1<number>;
         cacheWriteTokens: ObservedValueV1<number>;
-        costUsd: ObservedValueV1<number>;
+        normalized?: ObservedValueV1<CanonicalTranscriptUsageTotals>;
+        costUsd: ObservedValueV1<number | null>;
     };
     pendingUserRequest: PendingUserRequestV1 | null;
     observedAt: string;

package/dist/types/observedSessionV1.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.derivePendingUserRequestV1 = derivePendingUserRequestV1;
 exports.createProviderSessionAdapterV1 = createProviderSessionAdapterV1;
+const transcript_1 = require("../transcript");
 function evidence(provider, sessionId, sourcePath, event, eventIndex) {
     return [
         {
@@ -10,7 +11,7 @@ function evidence(provider, sessionId, sourcePath, event, eventIndex) {
             sessionId,
             sourcePath,
             eventIndex,
-            eventId: event?.message.id,
+            eventId: event?.message?.id,
             timestamp: event?.timestamp,
         },
     ];
@@ -29,7 +30,7 @@ function derivePendingUserRequestV1(provider, sessionId, sourcePath, events) {
             const refs = evidence(provider, sessionId, sourcePath, event, index);
             return {
                 schemaVersion: 1,
-                id: `${provider}:${sessionId}:${request.id ?? event.message.id ?? index}`,
+                id: `${provider}:${sessionId}:${request.id ?? event.message?.id ?? index}`,
                 provider,
                 sessionId,
                 kind: observed(request.kind, 'inferred', request.kind === 'question' ? 0.95 : 0.9, refs),
@@ -45,11 +46,12 @@ function derivePendingUserRequestV1(provider, sessionId, sourcePath, events) {
 }
 function waitingToolRequest(event) {
     const calls = [];
+    const message = event.message;
     if (event.type === 'tool_use') {
-        calls.push({ id: event.message.id, name: event.tool?.name, input: event.tool?.input });
+        calls.push({ id: message?.id, name: event.tool?.name, input: event.tool?.input });
     }
-    if (Array.isArray(event.message.content)) {
-        for (const block of event.message.content) {
+    if (Array.isArray(message?.content)) {
+        for (const block of message.content) {
             if (!block || typeof block !== 'object')
                 continue;
             const value = block;
@@ -120,11 +122,18 @@ function createProviderSessionAdapterV1(sessionProvider, options = {}) {
         async read(sessionPath, cwd = '') {
             const stats = sessionProvider.readSessionStats(sessionPath);
             const events = sessionProvider.createReader(sessionPath).readAll();
+            const transcript = (0, transcript_1.projectSessionTranscript)(events, {
+                provider: sessionProvider.id,
+                sessionId: stats.sessionId,
+                sourcePath: sessionPath,
+            });
             const refs = evidence(sessionProvider.id, stats.sessionId, sessionPath);
             const model = Object.entries(stats.modelUsage).sort((left, right) => right[1].calls - left[1].calls)[0]?.[0] ?? null;
             const metadata = sessionProvider.getSessionMetadata?.(sessionPath);
             const modifiedAt = metadata?.mtime.getTime() ?? Date.parse(stats.endTime);
             const recent = Number.isFinite(modifiedAt) && Date.now() - modifiedAt < 2 * 60_000;
+            const allCostsReported = transcript.usage.costs.length > 0 &&
+                transcript.usage.costs.every((cost) => cost.source === 'provider-reported');
             return {
                 schemaVersion: 1,
                 identity: {
@@ -140,7 +149,12 @@ function createProviderSessionAdapterV1(sessionProvider, options = {}) {
                     outputTokens: observed(stats.tokens.output, 'reported', 1, refs),
                     cacheReadTokens: observed(stats.tokens.cacheRead, 'reported', 1, refs),
                     cacheWriteTokens: observed(stats.tokens.cacheWrite, 'reported', 1, refs),
-                    costUsd: observed(stats.reportedCost, stats.reportedCost > 0 ? 'reported' : 'estimated', stats.reportedCost > 0 ? 1 : 0.5, refs),
+                    normalized: observed(transcript.usage.totals, 'reported', 1, refs),
+                    costUsd: observed(transcript.usage.totalCostUsd, allCostsReported
+                        ? 'reported'
+                        : transcript.usage.totalCostUsd === null
+                            ? 'inferred'
+                            : 'estimated', allCostsReported ? 1 : transcript.usage.totalCostUsd === null ? 0.5 : 0.9, refs),
                 },
                 pendingUserRequest: derivePendingUserRequestV1(sessionProvider.id, stats.sessionId, sessionPath, events),
                 observedAt: new Date().toISOString(),

package/dist/types/sessionEvent.d.ts

@@ -43,6 +43,8 @@ export interface SessionMessage {
     model?: string;
     /** Token usage statistics (only present in assistant messages) */
     usage?: MessageUsage;
+    /** Authoritative disjoint usage projection, when normalized by a provider parser. */
+    normalizedUsage?: import('../usageNormalization').NormalizedUsage;
     /** Message content (may be string or structured content) */
     content?: unknown;
 }
@@ -52,11 +54,7 @@ export interface SessionMessage {
  * Events are normalized from provider-specific formats into this common shape.
  * Each event represents a single interaction in a CLI agent session.
  */
-export interface SessionEvent {
-    /** Event type discriminator */
-    type: 'user' | 'assistant' | 'tool_use' | 'tool_result' | 'summary' | 'system';
-    /** Message data containing role, model, usage */
-    message: SessionMessage;
+export interface SessionEventBase {
     /** ISO 8601 timestamp of event */
     timestamp: string;
     /** Whether this is a subagent/sidechain event */
@@ -83,6 +81,8 @@ export interface SessionEvent {
     };
     /** Provider-specific signals normalized for shared analytics. */
     providerMetadata?: {
+        providerId?: string;
+        source?: string;
         retryAttempts?: number[];
         finishReasons?: string[];
         providerError?: {
@@ -91,18 +91,76 @@ export interface SessionEvent {
             code?: string | number;
         };
     };
-    /** Tool use details (when type is 'tool_use') */
+    /** Optional on the base so consumers can inspect legacy enriched events. */
     tool?: {
         name: string;
         input: Record<string, unknown>;
     };
-    /** Tool result details (when type is 'tool_result') */
+    /** Optional on the base so consumers can inspect legacy enriched events. */
     result?: {
         tool_use_id: string;
         output?: unknown;
         is_error?: boolean;
     };
 }
+export interface UserSessionEvent extends SessionEventBase {
+    type: 'user';
+    message: SessionMessage;
+}
+export interface AssistantSessionEvent extends SessionEventBase {
+    type: 'assistant';
+    message: SessionMessage;
+}
+export type MessageSessionEvent = UserSessionEvent | AssistantSessionEvent;
+/** Providers must emit textual summary data, exact compaction counts, or both. */
+export type SummarySessionEvent = SessionEventBase & {
+    type: 'summary';
+} & ({
+    message: SessionMessage;
+    summary?: string;
+    compaction?: {
+        tokensBefore: number;
+        tokensAfter: number;
+    };
+} | {
+    message?: SessionMessage;
+    summary: string;
+    compaction?: {
+        tokensBefore: number;
+        tokensAfter: number;
+    };
+} | {
+    message?: SessionMessage;
+    summary?: string;
+    compaction: {
+        tokensBefore: number;
+        tokensAfter: number;
+    };
+});
+export interface SystemSessionEvent extends SessionEventBase {
+    type: 'system';
+    /** Bookkeeping-only system rows legitimately have no message. */
+    message?: SessionMessage;
+}
+export interface ToolUseSessionEvent extends SessionEventBase {
+    type: 'tool_use';
+    message?: SessionMessage;
+    tool: {
+        name: string;
+        input: Record<string, unknown>;
+    };
+}
+export interface ToolResultSessionEvent extends SessionEventBase {
+    type: 'tool_result';
+    message?: SessionMessage;
+    result: {
+        tool_use_id: string;
+        output?: unknown;
+        is_error?: boolean;
+    };
+}
+/** Canonical provider-neutral event contract. */
+export type SessionEvent = UserSessionEvent | AssistantSessionEvent | SummarySessionEvent | SystemSessionEvent | ToolUseSessionEvent | ToolResultSessionEvent;
 /**
  * Permission mode values from Claude Code JSONL.
  */
@@ -221,6 +279,7 @@ export interface TimelineEvent {
     metadata?: {
         model?: string;
         toolName?: string;
+        toolUseId?: string;
         isError?: boolean;
         tokenCount?: number;
         fullText?: string;

package/dist/usageNormalization.d.ts

@@ -0,0 +1,69 @@
+import { type ModelPricing } from './modelInfo';
+import type { SessionEvent } from './types/sessionEvent';
+export type UsageProvider = 'anthropic' | 'openai' | 'sidekick' | (string & {});
+export type UsageSemantics = 'anthropic-additive-cache' | 'openai-inclusive-cache' | 'sidekick-disjoint';
+export interface UsageNormalizationProvenance {
+    provider?: UsageProvider;
+    semantics: UsageSemantics;
+    source?: string;
+}
+interface ProviderUsageBase {
+    provider?: UsageProvider;
+    source?: string;
+    model?: string;
+    reportedCostUsd?: number | null;
+    inputTokens?: number;
+    outputTokens?: number;
+    cacheReadTokens?: number;
+    cacheWriteTokens?: number;
+    reasoningTokens?: number;
+}
+/** Anthropic input and cache categories are additive. */
+export interface AnthropicUsageInput extends ProviderUsageBase {
+    semantics: 'anthropic';
+    reasoningIncludedInOutput?: boolean;
+}
+/** OpenAI cached input is a subset of input and reasoning is normally a subset of output. */
+export interface OpenAIUsageInput extends ProviderUsageBase {
+    semantics: 'openai';
+    reasoningIncludedInOutput?: boolean;
+}
+/** Already-disjoint usage. Reasoning inclusion must be stated explicitly. */
+export interface SidekickUsageInput extends ProviderUsageBase {
+    semantics: 'sidekick';
+    reasoningIncludedInOutput: boolean;
+}
+export type ProviderUsageInput = AnthropicUsageInput | OpenAIUsageInput | SidekickUsageInput;
+export interface NormalizedUsage {
+    uncachedInputTokens: number;
+    cacheReadTokens: number;
+    cacheWriteTokens: number;
+    outputTokens: number;
+    reasoningTokens: number;
+    reasoningIncludedInOutput: boolean;
+    cacheInclusiveInputTokens: number;
+    billableOutputTokens: number;
+    totalTokens: number;
+    model?: string;
+    reportedCostUsd?: number;
+    provenance: UsageNormalizationProvenance;
+}
+export type PricingProvenance = 'provider-reported' | 'explicit-pricing' | 'model-catalog' | 'unpriced';
+export interface NormalizedUsageCostInput {
+    usage: NormalizedUsage;
+    modelId?: string;
+    pricing?: ModelPricing | null;
+}
+export interface NormalizedUsageCost {
+    costUsd: number | null;
+    source: PricingProvenance;
+    modelId?: string;
+    usage: NormalizedUsage;
+}
+/** Convert provider-specific counters into finite, nonnegative, disjoint categories. */
+export declare function normalizeProviderUsage(input: ProviderUsageInput): NormalizedUsage;
+/** Extract normalized usage from an event, preserving parser-owned semantics when present. */
+export declare function extractNormalizedUsage(event: SessionEvent): NormalizedUsage | null;
+/** Price normalized, disjoint usage without double-counting reasoning tokens. */
+export declare function calculateNormalizedUsageCost(input: NormalizedUsageCostInput): NormalizedUsageCost;
+export {};

package/dist/usageNormalization.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeProviderUsage = normalizeProviderUsage;
+exports.extractNormalizedUsage = extractNormalizedUsage;
+exports.calculateNormalizedUsageCost = calculateNormalizedUsageCost;
+const modelInfo_1 = require("./modelInfo");
+function tokenCount(value) {
+    return typeof value === 'number' && Number.isFinite(value) && value > 0
+        ? Math.min(Number.MAX_SAFE_INTEGER, Math.floor(value))
+        : 0;
+}
+function reportedCost(value) {
+    return typeof value === 'number' && Number.isFinite(value) && value >= 0 ? value : undefined;
+}
+/** Convert provider-specific counters into finite, nonnegative, disjoint categories. */
+function normalizeProviderUsage(input) {
+    const rawInput = tokenCount(input.inputTokens);
+    const cacheReadTokens = tokenCount(input.cacheReadTokens);
+    const cacheWriteTokens = tokenCount(input.cacheWriteTokens);
+    const outputTokens = tokenCount(input.outputTokens);
+    const reasoningTokens = tokenCount(input.reasoningTokens);
+    const isOpenAI = input.semantics === 'openai';
+    const uncachedInputTokens = isOpenAI ? Math.max(0, rawInput - cacheReadTokens) : rawInput;
+    const reasoningIncludedInOutput = input.reasoningIncludedInOutput ?? input.semantics === 'openai';
+    const cacheInclusiveInputTokens = uncachedInputTokens + cacheReadTokens + cacheWriteTokens;
+    const billableOutputTokens = outputTokens + (reasoningIncludedInOutput ? 0 : reasoningTokens);
+    const totalTokens = cacheInclusiveInputTokens + billableOutputTokens;
+    const semantics = isOpenAI
+        ? 'openai-inclusive-cache'
+        : input.semantics === 'anthropic'
+            ? 'anthropic-additive-cache'
+            : 'sidekick-disjoint';
+    return {
+        uncachedInputTokens,
+        cacheReadTokens,
+        cacheWriteTokens,
+        outputTokens,
+        reasoningTokens,
+        reasoningIncludedInOutput,
+        cacheInclusiveInputTokens,
+        billableOutputTokens,
+        totalTokens,
+        ...(input.model ? { model: input.model } : {}),
+        ...(reportedCost(input.reportedCostUsd) !== undefined
+            ? { reportedCostUsd: reportedCost(input.reportedCostUsd) }
+            : {}),
+        provenance: {
+            semantics,
+            ...(input.provider ? { provider: input.provider } : {}),
+            ...(input.source ? { source: input.source } : {}),
+        },
+    };
+}
+/** Extract normalized usage from an event, preserving parser-owned semantics when present. */
+function extractNormalizedUsage(event) {
+    if (event.message?.normalizedUsage)
+        return event.message.normalizedUsage;
+    const usage = event.message?.usage;
+    if (!usage)
+        return null;
+    const providerId = event.providerMetadata?.providerId;
+    return normalizeProviderUsage({
+        semantics: 'sidekick',
+        provider: providerId,
+        source: event.providerMetadata?.source ?? 'legacy-message-usage',
+        model: event.message?.model,
+        inputTokens: usage.input_tokens,
+        outputTokens: usage.output_tokens,
+        cacheReadTokens: usage.cache_read_input_tokens,
+        cacheWriteTokens: usage.cache_creation_input_tokens,
+        reasoningTokens: usage.reasoning_tokens,
+        reasoningIncludedInOutput: providerId === 'codex' || providerId === 'openai',
+        reportedCostUsd: usage.reported_cost,
+    });
+}
+/** Price normalized, disjoint usage without double-counting reasoning tokens. */
+function calculateNormalizedUsageCost(input) {
+    const { usage } = input;
+    const modelId = input.modelId ?? usage.model;
+    if (usage.reportedCostUsd !== undefined) {
+        return { costUsd: usage.reportedCostUsd, source: 'provider-reported', modelId, usage };
+    }
+    const explicit = input.pricing !== undefined;
+    const pricing = explicit ? input.pricing : modelId ? (0, modelInfo_1.getModelPricing)(modelId) : null;
+    if (!pricing)
+        return { costUsd: null, source: 'unpriced', modelId, usage };
+    const costUsd = (usage.uncachedInputTokens / 1_000_000) * pricing.inputCostPerMillion +
+        (usage.cacheReadTokens / 1_000_000) * pricing.cacheReadCostPerMillion +
+        (usage.cacheWriteTokens / 1_000_000) * pricing.cacheWriteCostPerMillion +
+        (usage.billableOutputTokens / 1_000_000) * pricing.outputCostPerMillion;
+    if (!Number.isFinite(costUsd) || costUsd < 0) {
+        return { costUsd: null, source: 'unpriced', modelId, usage };
+    }
+    return {
+        costUsd,
+        source: explicit ? 'explicit-pricing' : 'model-catalog',
+        modelId,
+        usage,
+    };
+}

package/dist/watchers/factory.js

@@ -56,14 +56,25 @@ function createWatcher(options) {
     }
     let sessionPath;
     if (sessionId) {
-        const match = sessions.find((s) => s.includes(sessionId));
-        if (!match) {
+        const matches = sessions.map((sessionPath) => ({
+            sessionPath,
+            id: provider.getSessionId(sessionPath),
+        }));
+        const exact = matches.filter((candidate) => candidate.id === sessionId);
+        const candidates = exact.length > 0 ? exact : matches.filter((candidate) => candidate.id.startsWith(sessionId));
+        if (candidates.length === 0) {
             throw new Error(`Session ${sessionId} not found. Available: ${sessions
                 .slice(0, 5)
                 .map((s) => path.basename(s))
                 .join(', ')}`);
         }
-        sessionPath = match;
+        if (candidates.length > 1) {
+            throw new Error(`Session ${sessionId} is ambiguous. Matches: ${candidates
+                .slice(0, 5)
+                .map((candidate) => candidate.id)
+                .join(', ')}`);
+        }
+        sessionPath = candidates[0].sessionPath;
     }
     else {
         sessionPath = sessions[0]; // most recent

package/dist/watchers/jsonlTail.js

@@ -48,7 +48,11 @@ function createJsonlTail(options) {
 class JsonlTailReader {
     options;
     active = false;
-    offset;
+    /** Physical byte position already read from the file. */
+    readOffset;
+    /** Resume-safe byte position ending immediately after a newline. */
+    committedOffset;
+    pendingBytes = Buffer.alloc(0);
     fsWatcher = null;
     debounceTimer = null;
     catchupTimer = null;
@@ -56,7 +60,8 @@ class JsonlTailReader {
     parser;
     constructor(options) {
         this.options = options;
-        this.offset = options.startOffset ?? 0;
+        this.readOffset = options.startOffset ?? 0;
+        this.committedOffset = this.readOffset;
         this.parser = new jsonl_1.JsonlParser({
             onEvent: (event) => {
                 this.eventsInCurrentBatch += 1;
@@ -74,11 +79,12 @@ class JsonlTailReader {
         this.active = true;
         if (this.options.startAtEnd && this.options.startOffset === undefined) {
             try {
-                this.offset = fs.statSync(this.options.path).size;
+                this.readOffset = fs.statSync(this.options.path).size;
             }
             catch {
-                this.offset = 0;
+                this.readOffset = 0;
             }
+            this.committedOffset = this.readOffset;
         }
         this.readNow();
         this.watchFile();
@@ -112,27 +118,39 @@ class JsonlTailReader {
         let fd = null;
         try {
             const stat = fs.statSync(this.options.path);
-            if (stat.size < this.offset) {
-                this.offset = 0;
+            if (stat.size < this.readOffset) {
+                this.readOffset = 0;
+                this.committedOffset = 0;
+                this.pendingBytes = Buffer.alloc(0);
                 this.parser.reset();
             }
-            if (stat.size <= this.offset)
+            if (stat.size <= this.readOffset)
                 return;
-            const bytesToRead = stat.size - this.offset;
+            const bytesToRead = stat.size - this.readOffset;
             const buffer = Buffer.alloc(bytesToRead);
             fd = fs.openSync(this.options.path, 'r');
-            const bytesRead = fs.readSync(fd, buffer, 0, bytesToRead, this.offset);
+            const bytesRead = fs.readSync(fd, buffer, 0, bytesToRead, this.readOffset);
             fs.closeSync(fd);
             fd = null;
             if (bytesRead <= 0)
                 return;
-            this.offset += bytesRead;
+            this.readOffset += bytesRead;
             this.eventsInCurrentBatch = 0;
-            this.parser.processChunk(buffer.toString('utf-8', 0, bytesRead));
+            const combined = Buffer.concat([this.pendingBytes, buffer.subarray(0, bytesRead)]);
+            const lastNewline = combined.lastIndexOf(0x0a);
+            if (lastNewline >= 0) {
+                const completeLines = combined.subarray(0, lastNewline + 1);
+                this.pendingBytes = Buffer.from(combined.subarray(lastNewline + 1));
+                this.parser.processChunk(completeLines.toString('utf8'));
+            }
+            else {
+                this.pendingBytes = combined;
+            }
+            this.committedOffset = this.readOffset - this.pendingBytes.length;
             this.options.onBatchComplete?.({
                 bytesRead,
                 eventsRead: this.eventsInCurrentBatch,
-                offset: this.offset,
+                offset: this.committedOffset,
             });
         }
         catch (error) {
@@ -148,10 +166,12 @@ class JsonlTailReader {
         }
     }
     getOffset() {
-        return this.offset;
+        return this.committedOffset;
     }
     seekTo(offset) {
-        this.offset = Math.max(0, offset);
+        this.readOffset = Math.max(0, offset);
+        this.committedOffset = this.readOffset;
+        this.pendingBytes = Buffer.alloc(0);
         this.parser.reset();
     }
     watchFile() {

package/dist/watchers/jsonlWatcher.js

@@ -274,9 +274,11 @@ class JsonlSessionWatcher {
             this.fsWatcher = fs.watch(this.sessionPath, { persistent: false }, () => {
                 this.debouncedRead();
             });
-            this.fsWatcher.on('error', () => {
-                // File may have been deleted; stop gracefully
-                this.stop();
+            this.fsWatcher.on('error', (error) => {
+                // Degrade to catch-up polling without killing the live session.
+                this.fsWatcher?.close();
+                this.fsWatcher = null;
+                this.callbacks.onError?.(error);
             });
         }
         catch {

package/dist/watchers/providerReaderWatcher.js

@@ -82,8 +82,10 @@ class ProviderReaderSessionWatcher {
             this.fsWatcher = fs.watch(this.sessionPath, { persistent: false }, () => {
                 this.debouncedRead();
             });
-            this.fsWatcher.on('error', () => {
-                this.stop();
+            this.fsWatcher.on('error', (error) => {
+                this.fsWatcher?.close();
+                this.fsWatcher = null;
+                this.callbacks.onError?.(error);
             });
         }
         catch {

package/dist/watchers/sqliteWatcher.d.ts

@@ -7,6 +7,8 @@ export declare class SqliteSessionWatcher implements SessionWatcher {
     private _isActive;
     private lastMessageTime;
     private lastPartTime;
+    private seenMessageVersions;
+    private seenPartVersions;
     private fsWatcher;
     private walWatcher;
     private pollTimer;