sidekick-shared 0.26.0 → 0.26.2

package/dist/quotaResolver.d.ts

@@ -3,7 +3,7 @@
  *
  * `sidekick quota`, `quota --all`, the MCP facts server, and both dashboards
  * used to pick between the live API, session logs, and the persisted snapshot
- * in four different orders. `resolveQuota()` applies one precedence:
+ * in four different orders. `resolveQuota()` defaults to this precedence:
  *
  * 1. a fresh persisted snapshot (younger than `QUOTA_FRESH_MAX_AGE_MS`, whatever
  *    its origin: the official status-line sample, a session log, or an earlier
@@ -14,7 +14,9 @@
  * 4. an aging or stale snapshot, labelled as such, with the API failure attached;
  * 5. an unavailable state describing why nothing could be resolved.
  *
- * `preferFresh: false` skips step 1 (the `--refresh` flag). Every result carries
+ * `preferFresh: false` asks the API first when allowed (the `--refresh` flag
+ * and one-shot Codex queries). On failure, the newer session or persisted
+ * sample wins, with ties going to the persisted sample. Every result carries
  * `source`, `capturedSource`, `freshness`, `ageMs`, and a `resolution` tag.
  */
 import type { ResolvedActiveAccount, SavedAccountProfile } from './accountRegistry';
@@ -38,9 +40,9 @@ export interface ResolveQuotaOptions<T extends QuotaResolveProviderId = QuotaRes
     accountId?: string;
     /** Workspace whose Codex rollouts are searched first for session-derived rate limits. */
     workspacePath?: string;
-    /** Use a fresh persisted snapshot before anything else (default true). `--refresh` passes false. */
+    /** Prefer local samples (default true). False asks the API before any local sample when allowed. */
     preferFresh?: boolean;
-    /** Allow a provider API call when no fresh local sample exists (default true). */
+    /** Allow provider API calls (default true), including when preferFresh is false. */
     allowApi?: boolean;
     /** Re-point a stale saved-account pointer while resolving the account (default true). */
     selfHeal?: boolean;

package/dist/quotaResolver.js

@@ -4,7 +4,7 @@
  *
  * `sidekick quota`, `quota --all`, the MCP facts server, and both dashboards
  * used to pick between the live API, session logs, and the persisted snapshot
- * in four different orders. `resolveQuota()` applies one precedence:
+ * in four different orders. `resolveQuota()` defaults to this precedence:
  *
  * 1. a fresh persisted snapshot (younger than `QUOTA_FRESH_MAX_AGE_MS`, whatever
  *    its origin: the official status-line sample, a session log, or an earlier
@@ -15,7 +15,9 @@
  * 4. an aging or stale snapshot, labelled as such, with the API failure attached;
  * 5. an unavailable state describing why nothing could be resolved.
  *
- * `preferFresh: false` skips step 1 (the `--refresh` flag). Every result carries
+ * `preferFresh: false` asks the API first when allowed (the `--refresh` flag
+ * and one-shot Codex queries). On failure, the newer session or persisted
+ * sample wins, with ties going to the persisted sample. Every result carries
  * `source`, `capturedSource`, `freshness`, `ageMs`, and a `resolution` tag.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
@@ -146,6 +148,10 @@ function snapshotResolution(state) {
         return 'snapshot-aging';
     return 'snapshot-stale';
 }
+function captureTimeMs(state) {
+    const capturedMs = state.capturedAt ? Date.parse(state.capturedAt) : NaN;
+    return Number.isFinite(capturedMs) ? capturedMs : Number.NEGATIVE_INFINITY;
+}
 /**
  * Resolve the current quota for one provider with the shared precedence
  * described at the top of this file.
@@ -160,6 +166,7 @@ async function resolveQuota(options) {
     const capturedAt = now.toISOString();
     const preferFresh = options.preferFresh ?? true;
     const allowApi = options.allowApi ?? true;
+    const apiFirst = !preferFresh && allowApi;
     const readSnapshot = options.readSnapshot ?? quotaSnapshots_1.readQuotaSnapshot;
     const writeSnapshot = options.writeSnapshot ?? quotaSnapshots_1.writeQuotaSnapshot;
     const identity = resolveIdentity(options);
@@ -178,19 +185,27 @@ async function resolveQuota(options) {
     if (preferFresh && snapshot && snapshot.freshness === 'fresh') {
         return finish(snapshot, 'snapshot-fresh');
     }
-    if (providerId === 'codex') {
-        const local = (0, codexQuota_1.resolveCodexQuotaFromLocalSources)({
-            workspacePath: options.workspacePath,
-            provider: options.codexProvider,
-            activeAccount: identity.codexAccount,
-            codexHome: options.codexHome,
-            // Only rollout hits count as "session-derived"; the snapshot fallback is
-            // handled below so it can be labelled by age.
-            readSnapshot: () => null,
-            writeSnapshot,
-        });
-        if (local)
-            return finish(local, 'session');
+    const readLocalCodex = () => (0, codexQuota_1.resolveCodexQuotaFromLocalSources)({
+        workspacePath: options.workspacePath,
+        provider: options.codexProvider,
+        activeAccount: identity.codexAccount,
+        codexHome: options.codexHome,
+        // Only rollout hits count as "session-derived"; the snapshot fallback is
+        // handled below so it can be labelled by age.
+        readSnapshot: () => null,
+        // Inspect candidates without overwriting the persisted fallback. Only
+        // the selected session sample is written, using the resolved account key.
+        writeSnapshot: () => { },
+    });
+    const finishLocal = (local) => {
+        if (identity.accountId)
+            writeSnapshot('codex', identity.accountId, local);
+        return finish(local, 'session');
+    };
+    if (providerId === 'codex' && !apiFirst) {
+        const local = readLocalCodex();
+        if (local?.available)
+            return finishLocal(local);
     }
     let apiState = null;
     if (allowApi) {
@@ -202,6 +217,12 @@ async function resolveQuota(options) {
             return finish(apiState, 'api');
         }
     }
+    if (providerId === 'codex' && apiFirst) {
+        const local = readLocalCodex();
+        if (local?.available && (!snapshot || captureTimeMs(local) > captureTimeMs(snapshot))) {
+            return { ...finishLocal(local), failure: (0, quotaPresentation_1.describeQuotaFailure)(apiState) };
+        }
+    }
     if (snapshot) {
         const fallback = finish(snapshot, snapshotResolution(snapshot));
         return apiState ? { ...fallback, failure: (0, quotaPresentation_1.describeQuotaFailure)(apiState) } : fallback;

package/dist/search/sessionSearch.d.ts

@@ -1,6 +1,4 @@
-/**
- * Provider-aware cross-session search.
- */
+/** Provider-aware cross-session search. */
 import type { SessionProviderBase, ProviderId } from '../providers/types';
 export interface SearchResult {
     providerId: ProviderId;
@@ -10,7 +8,13 @@ export interface SearchResult {
     eventType: string;
     timestamp: string;
 }
-export declare function searchSessions(provider: SessionProviderBase, query: string, opts?: {
+export interface SessionSearchOptions {
+    /** Workspace path, resolved canonically. Takes precedence over projectSlug. */
+    projectPath?: string;
+    /** Legacy provider-encoded project identifier. */
     projectSlug?: string;
     maxResults?: number;
-}): Promise<SearchResult[]>;
+    /** Stop obsolete interactive searches between session reads. */
+    signal?: AbortSignal;
+}
+export declare function searchSessions(provider: SessionProviderBase, query: string, options?: SessionSearchOptions): Promise<SearchResult[]>;

package/dist/search/sessionSearch.js

@@ -1,98 +1,69 @@
 "use strict";
-/**
- * Provider-aware cross-session search.
- */
-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;
-    };
-})();
+/** Provider-aware cross-session search. */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.searchSessions = searchSessions;
-const fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
-async function searchSessions(provider, query, opts) {
-    const maxResults = opts?.maxResults ?? 50;
+const paths_1 = require("../paths");
+async function enumerateSessions(provider, options) {
+    const workspace = options.projectPath
+        ? (0, paths_1.resolveProjectIdentity)(options.projectPath).resolvedCwd
+        : undefined;
+    if (!options.projectSlug || workspace) {
+        if (provider.listSessionFilesAsync)
+            return provider.listSessionFilesAsync(workspace);
+        if (workspace) {
+            return provider
+                .findAllSessions(workspace)
+                .map((path) => ({ path, mtime: new Date(0), workspacePath: workspace }));
+        }
+        if (provider.listAllSessionFiles)
+            return provider.listAllSessionFiles();
+    }
+    // Older/custom providers can expose virtual project directories. Let the
+    // provider enumerate them instead of assuming a particular on-disk layout.
+    const files = [];
+    for (const folder of provider.getAllProjectFolders()) {
+        if (options.signal?.aborted)
+            break;
+        if (options.projectSlug && folder.encodedName !== options.projectSlug)
+            continue;
+        const paths = provider.id === 'codex'
+            ? provider.findAllSessions(folder.name)
+            : provider.findSessionsInDirectory(folder.dir);
+        files.push(...paths.map((path) => ({ path, mtime: folder.lastModified, workspacePath: folder.name })));
+    }
+    return files;
+}
+async function searchSessions(provider, query, options = {}) {
+    const maxResults = options.maxResults ?? 50;
     const results = [];
-    const baseDir = provider.getProjectsBaseDir();
-    try {
-        if (!fs.existsSync(baseDir))
-            return results;
-        // Get all project folders
-        const folders = provider.getAllProjectFolders();
-        for (const folder of folders) {
-            if (results.length >= maxResults)
-                break;
-            // If projectSlug specified, filter by encoded name
-            if (opts?.projectSlug && folder.encodedName !== opts.projectSlug)
-                continue;
-            // Get session files in this folder
-            let sessionFiles = [];
-            try {
-                const dir = folder.dir;
-                if (fs.existsSync(dir)) {
-                    const entries = fs
-                        .readdirSync(dir)
-                        .filter((f) => f.endsWith('.jsonl') || f.endsWith('.json'));
-                    sessionFiles = entries.map((f) => path.join(dir, f));
-                }
-            }
-            catch {
-                /* skip */
-            }
-            // If no files found from dir scan, try findAllSessions with the folder name
-            if (sessionFiles.length === 0) {
-                // Let canonical directory discovery handle synthetic DB-backed paths.
-                sessionFiles = provider.findSessionsInDirectory(folder.dir);
-            }
-            for (const sessionPath of sessionFiles) {
-                if (results.length >= maxResults)
-                    break;
-                const remaining = maxResults - results.length;
-                const hits = provider.searchInSession(sessionPath, query, remaining);
-                for (const hit of hits) {
-                    results.push({
-                        providerId: provider.id,
-                        projectPath: hit.projectPath || folder.name,
-                        sessionPath: hit.sessionPath,
-                        snippet: hit.line,
-                        eventType: hit.eventType,
-                        timestamp: hit.timestamp,
-                    });
-                }
+    if (maxResults <= 0 || !query.trim() || options.signal?.aborted)
+        return results;
+    const files = await enumerateSessions(provider, options);
+    const seen = new Set();
+    files.sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
+    for (const file of files) {
+        if (results.length >= maxResults || options.signal?.aborted)
+            break;
+        if (seen.has(file.path))
+            continue;
+        seen.add(file.path);
+        try {
+            const hits = provider.searchInSession(file.path, query, maxResults - results.length);
+            for (const hit of hits.slice(0, maxResults - results.length)) {
+                results.push({
+                    providerId: provider.id,
+                    projectPath: hit.projectPath || file.workspacePath || '',
+                    sessionPath: hit.sessionPath,
+                    snippet: hit.line,
+                    eventType: hit.eventType,
+                    timestamp: hit.timestamp,
+                });
             }
         }
+        catch {
+            // An unreadable session must not hide matches in the remaining sessions.
+        }
+        await new Promise((resolve) => setImmediate(resolve));
     }
-    catch {
-        /* skip */
-    }
-    return results.slice(0, maxResults);
+    return results;
 }

package/dist/watchers/factory.js

@@ -38,17 +38,11 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveSessionPath = resolveSessionPath;
 exports.createWatcher = createWatcher;
-const os = __importStar(require("os"));
 const path = __importStar(require("path"));
+const openCode_1 = require("../providers/openCode");
 const jsonlWatcher_1 = require("./jsonlWatcher");
 const providerReaderWatcher_1 = require("./providerReaderWatcher");
 const sqliteWatcher_1 = require("./sqliteWatcher");
-function getOpenCodeDataDir() {
-    const xdg = process.env.XDG_DATA_HOME;
-    if (xdg)
-        return path.join(xdg, 'opencode');
-    return path.join(os.homedir(), '.local', 'share', 'opencode');
-}
 /**
  * Resolve the session a command should act on: an exact or unique-prefix
  * match of `sessionId` among the workspace's sessions, or the most recent
@@ -94,7 +88,7 @@ function createWatcherForProvider(provider, sessionPath, callbacks) {
         case 'codex':
             return new providerReaderWatcher_1.ProviderReaderSessionWatcher(provider, sessionPath, callbacks);
         case 'opencode': {
-            const dataDir = getOpenCodeDataDir();
+            const dataDir = (0, openCode_1.getOpenCodeDataDir)();
             const dbPath = path.join(dataDir, 'opencode.db');
             // Session ID is the basename without extension
             const sid = path.basename(sessionPath, '.json');

package/dist/watchers/jsonlTail.js

@@ -42,6 +42,26 @@ const fs = __importStar(require("fs"));
 const jsonl_1 = require("../parsers/jsonl");
 const DEFAULT_DEBOUNCE_MS = 100;
 const DEFAULT_CATCHUP_INTERVAL_MS = 30_000;
+/** Skip old complete events while retaining an in-progress final line. */
+function lastCompleteLineOffset(filePath) {
+    const fd = fs.openSync(filePath, 'r');
+    try {
+        let end = fs.fstatSync(fd).size;
+        const buffer = Buffer.alloc(64 * 1024);
+        while (end > 0) {
+            const start = Math.max(0, end - buffer.length);
+            const count = fs.readSync(fd, buffer, 0, end - start, start);
+            const newline = buffer.subarray(0, count).lastIndexOf(0x0a);
+            if (newline >= 0)
+                return start + newline + 1;
+            end = start;
+        }
+        return 0;
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
 function createJsonlTail(options) {
     return new JsonlTailReader(options);
 }
@@ -79,7 +99,7 @@ class JsonlTailReader {
         this.active = true;
         if (this.options.startAtEnd && this.options.startOffset === undefined) {
             try {
-                this.readOffset = fs.statSync(this.options.path).size;
+                this.readOffset = lastCompleteLineOffset(this.options.path);
             }
             catch {
                 this.readOffset = 0;
@@ -179,7 +199,11 @@ class JsonlTailReader {
             this.fsWatcher = fs.watch(this.options.path, { persistent: false }, () => {
                 this.debouncedRead();
             });
-            this.fsWatcher.on('error', (error) => this.options.onError?.(error));
+            this.fsWatcher.on('error', (error) => {
+                this.fsWatcher?.close();
+                this.fsWatcher = null;
+                this.options.onError?.(error);
+            });
         }
         catch {
             // Polling still covers filesystems where fs.watch is unavailable.

package/dist/watchers/jsonlWatcher.d.ts

@@ -5,26 +5,20 @@
 import type { ProviderId } from '../providers/types';
 import type { SessionWatcher, SessionWatcherCallbacks } from './types';
 export declare class JsonlSessionWatcher implements SessionWatcher {
-    private _isActive;
-    private filePosition;
-    private fsWatcher;
-    private catchupTimer;
-    private debounceTimer;
-    private codexInPlanMode;
-    private readonly parser;
     private readonly providerId;
     private readonly sessionPath;
     private readonly callbacks;
+    private tail;
+    private startOffset;
+    private codexInPlanMode;
     constructor(providerId: ProviderId, sessionPath: string, callbacks: SessionWatcherCallbacks);
     get isActive(): boolean;
-    /** Seek to a byte offset. Must be called before start(). */
+    /** Seek to a committed byte offset before starting replay. */
     seekTo(position: number): void;
-    /** Get the current byte position. */
+    /** Position after the last complete JSONL line. */
     getPosition(): number;
     start(replay: boolean): void;
     stop(): void;
-    private debouncedRead;
-    private readNewBytes;
     private handleRawEvent;
     private normalizeCodexEvent;
 }

package/dist/watchers/jsonlWatcher.js

@@ -3,47 +3,11 @@
  * JSONL session watcher for Claude Code and Codex.
  * Uses byte-offset tracking + fs.watch with debounce + catch-up polling.
  */
-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.JsonlSessionWatcher = void 0;
-const fs = __importStar(require("fs"));
-const jsonl_1 = require("../parsers/jsonl");
+const jsonlTail_1 = require("./jsonlTail");
 const codexParser_1 = require("../parsers/codexParser");
 const toolSummary_1 = require("../formatters/toolSummary");
-const DEBOUNCE_MS = 100;
-const CATCHUP_INTERVAL_MS = 30_000;
 // ── Normalizers ──
 function normalizeClaudeCodeEvent(raw) {
     const events = [];
@@ -220,139 +184,46 @@ function truncate(text, maxLen) {
 }
 // ── Watcher ──
 class JsonlSessionWatcher {
-    _isActive = false;
-    filePosition = 0;
-    fsWatcher = null;
-    catchupTimer = null;
-    debounceTimer = null;
-    codexInPlanMode = false;
-    parser;
     providerId;
     sessionPath;
     callbacks;
+    tail;
+    startOffset;
+    codexInPlanMode = false;
     constructor(providerId, sessionPath, callbacks) {
         this.providerId = providerId;
         this.sessionPath = sessionPath;
         this.callbacks = callbacks;
-        this.parser = new jsonl_1.JsonlParser({
-            onEvent: (event) => this.handleRawEvent(event),
-            onError: (err) => callbacks.onError?.(err),
-        });
     }
     get isActive() {
-        return this._isActive;
+        return this.tail?.isActive ?? false;
     }
-    /** Seek to a byte offset. Must be called before start(). */
+    /** Seek to a committed byte offset before starting replay. */
     seekTo(position) {
-        this.filePosition = position;
-        this.parser.reset();
+        this.startOffset = Math.max(0, position);
+        this.tail?.seekTo(this.startOffset);
     }
-    /** Get the current byte position. */
+    /** Position after the last complete JSONL line. */
     getPosition() {
-        return this.filePosition;
+        return this.tail?.getOffset() ?? this.startOffset ?? 0;
     }
     start(replay) {
-        if (this._isActive)
+        if (this.isActive)
             return;
-        this._isActive = true;
-        if (replay) {
-            // Read entire file from offset 0
-            this.readNewBytes();
-        }
-        else {
-            // Skip to end of file
-            try {
-                const stat = fs.statSync(this.sessionPath);
-                this.filePosition = stat.size;
-            }
-            catch {
-                this.filePosition = 0;
-            }
-        }
-        // Watch for changes
-        try {
-            this.fsWatcher = fs.watch(this.sessionPath, { persistent: false }, () => {
-                this.debouncedRead();
-            });
-            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 {
-            // fs.watch not available, rely on polling only
-        }
-        // Catch-up polling
-        this.catchupTimer = setInterval(() => {
-            if (this._isActive)
-                this.readNewBytes();
-        }, CATCHUP_INTERVAL_MS);
+        this.tail = (0, jsonlTail_1.createJsonlTail)({
+            path: this.sessionPath,
+            startOffset: replay ? this.getPosition() : undefined,
+            startAtEnd: !replay,
+            onEvent: (event) => this.handleRawEvent(event),
+            onBatchComplete: () => this.callbacks.onBatchComplete?.(),
+            onError: (error) => this.callbacks.onError?.(error),
+        });
+        this.tail.start();
     }
     stop() {
-        if (!this._isActive)
-            return;
-        this._isActive = false;
-        if (this.debounceTimer) {
-            clearTimeout(this.debounceTimer);
-            this.debounceTimer = null;
-        }
-        if (this.fsWatcher) {
-            this.fsWatcher.close();
-            this.fsWatcher = null;
-        }
-        if (this.catchupTimer) {
-            clearInterval(this.catchupTimer);
-            this.catchupTimer = null;
-        }
-        this.parser.flush();
+        this.tail?.stop();
         this.codexInPlanMode = false;
     }
-    debouncedRead() {
-        if (this.debounceTimer)
-            clearTimeout(this.debounceTimer);
-        this.debounceTimer = setTimeout(() => {
-            this.readNewBytes();
-        }, DEBOUNCE_MS);
-    }
-    readNewBytes() {
-        if (!this._isActive)
-            return;
-        let fd = null;
-        try {
-            const stat = fs.statSync(this.sessionPath);
-            // Handle file truncation (shouldn't happen with append-only, but be safe)
-            if (stat.size < this.filePosition) {
-                this.filePosition = 0;
-                this.parser.reset();
-            }
-            if (stat.size <= this.filePosition)
-                return;
-            fd = fs.openSync(this.sessionPath, 'r');
-            const bytesToRead = stat.size - this.filePosition;
-            const buffer = Buffer.alloc(bytesToRead);
-            const bytesRead = fs.readSync(fd, buffer, 0, bytesToRead, this.filePosition);
-            fs.closeSync(fd);
-            fd = null;
-            if (bytesRead > 0) {
-                this.filePosition += bytesRead;
-                const chunk = buffer.toString('utf-8', 0, bytesRead);
-                this.parser.processChunk(chunk);
-            }
-        }
-        catch (err) {
-            if (fd !== null) {
-                try {
-                    fs.closeSync(fd);
-                }
-                catch {
-                    /* ignore */
-                }
-            }
-            this.callbacks.onError?.(err instanceof Error ? err : new Error(String(err)));
-        }
-    }
     handleRawEvent(event) {
         // For codex, raw events don't match RawSessionEvent shape exactly, but
         // JsonlParser parses any JSON object. Cast to Record for codex normalizer.

package/dist/watchers/providerReaderWatcher.js

@@ -112,12 +112,13 @@ class ProviderReaderSessionWatcher {
             clearInterval(this.catchupTimer);
             this.catchupTimer = null;
         }
-        this.reader.flush();
+        // Keep unfinished input buffered so a later start can resume losslessly.
     }
     seekToEnd() {
         try {
-            const stat = fs.statSync(this.sessionPath);
-            this.reader.seekTo(stat.size);
+            // Consume existing complete records to retain parser context and any
+            // unfinished line, without emitting historical events.
+            this.reader.readNew();
         }
         catch {
             this.reader.reset();
@@ -143,6 +144,7 @@ class ProviderReaderSessionWatcher {
                     this.callbacks.onEvent(followEvent);
                 }
             }
+            this.callbacks.onBatchComplete?.();
         }
         catch (err) {
             this.callbacks.onError?.(err instanceof Error ? err : new Error(String(err)));

package/dist/watchers/sqliteWatcher.js

@@ -312,6 +312,7 @@ class SqliteSessionWatcher {
                 if (part.time_updated > this.lastPartTime)
                     this.lastPartTime = part.time_updated;
             }
+            this.callbacks.onBatchComplete?.();
         }
         catch (err) {
             this.callbacks.onError?.(err instanceof Error ? err : new Error(String(err)));