@threadbase-sh/streamer 1.23.0 → 1.23.1

package/dist/index.d.cts

@@ -454,7 +454,24 @@ declare class ConversationCache {
     getSessionName(sessionId: string): string | null;
     listSessionNames(): Record<string, string>;
     invalidate(id?: string): void;
-    invalidateByFilePath(filePath: string): string | null;
+    /**
+     * Drop the cached row for a file. Two callers with opposite intent:
+     *  - a directory-watch "change" event (the file was appended to) — pass
+     *    `skipIfTailed: true`. A cached tail means the row is being actively
+     *    maintained from the file's real content by the live-tail
+     *    (updateFromLines) or warm-up path, fresher than any scanner-derived
+     *    view. Both watchers fire on the same append with no ordering guarantee;
+     *    without this guard the invalidate can land after the tail write and wipe
+     *    the just-cached row, flickering the conversation out of
+     *    /api/conversations on nearly every message (CRITICAL #2). The debounced
+     *    rescan still re-derives metadata, so skipping the eager drop loses
+     *    nothing.
+     *  - a genuine unlink (the file is gone) — leave `skipIfTailed` false so the
+     *    row is always removed, otherwise a deleted session ghosts in the cache.
+     */
+    invalidateByFilePath(filePath: string, opts?: {
+        skipIfTailed?: boolean;
+    }): string | null;
     /**
      * Drop rows whose `file_path` no longer exists on disk AND which have no
      * cached tail to fall back to. Rows with a tail are left alone so

package/dist/index.d.ts

@@ -454,7 +454,24 @@ declare class ConversationCache {
     getSessionName(sessionId: string): string | null;
     listSessionNames(): Record<string, string>;
     invalidate(id?: string): void;
-    invalidateByFilePath(filePath: string): string | null;
+    /**
+     * Drop the cached row for a file. Two callers with opposite intent:
+     *  - a directory-watch "change" event (the file was appended to) — pass
+     *    `skipIfTailed: true`. A cached tail means the row is being actively
+     *    maintained from the file's real content by the live-tail
+     *    (updateFromLines) or warm-up path, fresher than any scanner-derived
+     *    view. Both watchers fire on the same append with no ordering guarantee;
+     *    without this guard the invalidate can land after the tail write and wipe
+     *    the just-cached row, flickering the conversation out of
+     *    /api/conversations on nearly every message (CRITICAL #2). The debounced
+     *    rescan still re-derives metadata, so skipping the eager drop loses
+     *    nothing.
+     *  - a genuine unlink (the file is gone) — leave `skipIfTailed` false so the
+     *    row is always removed, otherwise a deleted session ghosts in the cache.
+     */
+    invalidateByFilePath(filePath: string, opts?: {
+        skipIfTailed?: boolean;
+    }): string | null;
     /**
      * Drop rows whose `file_path` no longer exists on disk AND which have no
      * cached tail to fall back to. Rows with a tail are left alone so

package/dist/index.js

@@ -2532,7 +2532,10 @@ var ConversationCache = class _ConversationCache {
           model         = excluded.model,
           account       = excluded.account,
           branch        = excluded.branch,
-          message_count = excluded.message_count,
+          -- message_count is incremented by live tailing but recounted from
+          -- scratch by a scanner rescan; a stale rescan must not carry a live
+          -- session's count backwards, so take the max instead of overwriting.
+          message_count = MAX(conversation_meta.message_count, excluded.message_count),
           last_activity = excluded.last_activity,
           first_message = excluded.first_message,
           last_message  = excluded.last_message,
@@ -2809,6 +2812,7 @@ var ConversationCache = class _ConversationCache {
           fileSize = s.size;
         } catch {
         }
+        const seq = ++this.tailSeq;
         this.stmts.upsertFull.run({
           id,
           file_path: m.filePath,
@@ -2823,7 +2827,7 @@ var ConversationCache = class _ConversationCache {
           first_message: m.firstMessage ? JSON.stringify(m.firstMessage) : null,
           last_message: m.lastMessage ? JSON.stringify(m.lastMessage) : null,
           preview: m.preview ?? null,
-          updated_at: 0,
+          updated_at: seq,
           mtime_ms: mtimeMs,
           file_size: fileSize,
           provider: m.provider ?? CLAUDE_CODE_PROVIDER
@@ -3040,9 +3044,25 @@ var ConversationCache = class _ConversationCache {
       this.fileIndex.clear();
     }
   }
-  invalidateByFilePath(filePath) {
+  /**
+   * Drop the cached row for a file. Two callers with opposite intent:
+   *  - a directory-watch "change" event (the file was appended to) — pass
+   *    `skipIfTailed: true`. A cached tail means the row is being actively
+   *    maintained from the file's real content by the live-tail
+   *    (updateFromLines) or warm-up path, fresher than any scanner-derived
+   *    view. Both watchers fire on the same append with no ordering guarantee;
+   *    without this guard the invalidate can land after the tail write and wipe
+   *    the just-cached row, flickering the conversation out of
+   *    /api/conversations on nearly every message (CRITICAL #2). The debounced
+   *    rescan still re-derives metadata, so skipping the eager drop loses
+   *    nothing.
+   *  - a genuine unlink (the file is gone) — leave `skipIfTailed` false so the
+   *    row is always removed, otherwise a deleted session ghosts in the cache.
+   */
+  invalidateByFilePath(filePath, opts) {
     const row = this.stmts.getIdByFilePath.get(filePath);
     if (!row) return null;
+    if (opts?.skipIfTailed && this.stmts.hasTail.get(row.id)) return null;
     this.invalidate(row.id);
     return row.id;
   }
@@ -4268,7 +4288,7 @@ var StreamerServer = class {
         }
       },
       onConversationChanged: (filePath) => {
-        this.cache?.invalidateByFilePath(filePath);
+        this.cache?.invalidateByFilePath(filePath, { skipIfTailed: true });
         this.markScannerStaleDebounced();
         this.log.debug?.(`Scanner invalidated by directory event: ${filePath}`, {
           filePath,