@tom2012/cc-web 2026.4.19-n → 2026.4.19-p

package/backend/dist/session-manager.d.ts

@@ -1,27 +1,22 @@
 /**
- * SessionManager — reads conversation history directly from Claude Code's
- * native JSONL files at ~/.claude/projects/{encoded-path}/{sessionId}.jsonl
+ * SessionManager — reads conversation history directly from the CLI's
+ * native JSONL files (e.g. ~/.claude/projects/{encoded-path}/{uuid}.jsonl).
  *
- * No PTY parsing, no ANSI stripping, no heuristics needed.
+ * No PTY parsing, no ANSI stripping, no heuristics. The JSONL is the single
+ * source of truth; ccweb maintains no separate conversation store.
  */
 import { EventEmitter } from 'events';
 import type { CliTool } from './types';
-export interface SessionMessage {
-    role: 'user' | 'assistant';
-    content: string;
-    timestamp: string;
-}
-export interface Session {
-    id: string;
-    projectId: string;
-    startedAt: string;
-    messages: SessionMessage[];
-}
 export interface ChatBlockItem {
     type: 'text' | 'thinking' | 'tool_use' | 'tool_result';
     content: string;
 }
 export interface ChatBlock {
+    /** Stable block id for dedup between WS replay and HTTP history. Derived
+     *  from sha1(jsonlPath + source) so it's idempotent across restarts and
+     *  unique per entry. Optional on older code paths; always populated by
+     *  session-manager. */
+    id?: string;
     role: 'user' | 'assistant';
     timestamp: string;
     blocks: ChatBlockItem[];
@@ -41,13 +36,45 @@ declare class SessionManager extends EventEmitter {
     getAllSemanticStatus(): Record<string, SemanticStatus>;
     /** Return the JSONL file path currently being tailed for this project. */
     getJsonlPath(projectId: string): string | null;
-    /** Return all parsed ChatBlocks from the current session file (for replay on chat_subscribe). */
+    /** Return all parsed ChatBlocks from the project's latest JSONL file.
+     *
+     *  Resolution order:
+     *    1. Active watcher already has `jsonlPath` discovered via hooks → use it.
+     *    2. Watcher exists but hasn't discovered the file yet → lazily scan the
+     *       adapter's session dir, pick the latest JSONL, cache on the watcher.
+     *    3. No watcher (stopped project, user just navigated in) → resolve
+     *       project config on-the-fly and pick the latest JSONL. Do NOT
+     *       persist to `this.watchers` because a watcher without a PTY
+     *       would drift (no hooks, no triggerRead).
+     *
+     *  This indirection exists because chat history has to be loadable without
+     *  a hook ever firing (e.g. immediately after ccweb restart — triggerRead
+     *  only runs when Claude Code's hooks call `/api/hooks`).
+     */
     getChatHistory(projectId: string): ChatBlock[];
+    /** Parse a JSONL/JSON session file into ChatBlocks with stable ids. */
+    private parseJsonlFile;
+    /** Find the latest JSONL file for a project (single source of truth for
+     *  both chat-history HTTP and hook-driven tail paths).
+     *
+     *  Strategy: pick the newest file (by mtime) in the adapter's session dir.
+     *  For adapters that store sessions in a shared tree (e.g. Codex's
+     *  date-partitioned dir), use `getSessionFilesForProject` to scope by cwd.
+     *
+     *  Deliberately has NO startedAt/recency filter — historical requirement
+     *  was for "the file THIS session is writing", but that caused HTTP and
+     *  WS paths to disagree on which file to read, breaking block-id dedup.
+     *  Using "newest" works because Claude --continue updates the mtime of
+     *  the continued file, and any new file it creates has the highest mtime.
+     *  The caller (triggerRead) handles mid-session file switches by re-
+     *  checking on each call.
+     */
+    private findLatestJsonlForProject;
     registerChatListener(projectId: string, cb: (msg: ChatBlock) => void): void;
     unregisterChatListener(projectId: string, cb: (msg: ChatBlock) => void): void;
-    /** Call when a new PTY starts for a project */
+    /** Call when a new PTY starts for a project. Registers a watcher so that
+     *  subsequent hook-driven `triggerRead()` calls can tail the JSONL. */
     startSession(projectId: string, folderPath: string, cliTool?: CliTool): void;
-    private pruneOldSessions;
     /** Stop the session poller for a project (public for cleanup on terminal stop) */
     stopWatcherForProject(projectId: string): void;
     private stopWatcher;
@@ -55,33 +82,19 @@ declare class SessionManager extends EventEmitter {
      *  Updates semantic status directly from env var — does NOT read JSONL
      *  (JSONL has not been written yet at this point). */
     handleHookPreTool(projectId: string, toolName: string): void;
-    /** Called by hooks route on PostToolUse/Stop.
-     *  Immediately reads any new lines from the JSONL file. */
+    /** Called by hooks route on PostToolUse/Stop. Discovers the latest JSONL
+     *  file if not already cached, detects mid-session file switches (e.g.
+     *  Claude --continue creating a fresh JSONL), then reads new content and
+     *  emits block events to chat listeners. */
     triggerRead(projectId: string): void;
     /** Called by hooks route on Stop — clears semantic status before reading final text. */
     clearSemanticStatus(projectId: string): void;
-    /** Find the newest session file created after startedAt in the tool's session dir */
-    private findJsonl;
     /** Read new data from the session file and extract messages */
     private readNewLines;
     /** Read whole-file JSON session (Gemini etc.) — re-parse on each trigger, diff against last known state */
     private readWholeFileSession;
     /** Incremental JSONL reading (Claude, Codex) */
     private readJsonlIncremental;
-    private appendMessages;
-    /** Overwrite all messages (for whole-file JSON tools that re-parse the entire session) */
-    private overwriteMessages;
-    /** Resolve folderPath for a project — from active watcher or project config */
-    private resolveFolderPath;
-    /** Read session files from a directory */
-    private readSessionsFromDir;
-    listSessions(projectId: string): (Omit<Session, 'messages'> & {
-        messageCount: number;
-        isCurrent: boolean;
-    })[];
-    /** Validate sessionId to prevent path traversal */
-    private isValidSessionId;
-    getSession(projectId: string, sessionId: string): Session | null;
 }
 export declare const sessionManager: SessionManager;
 export {};

package/backend/dist/session-manager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"session-manager.d.ts","sourceRoot":"","sources":["../src/session-manager.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"session-manager.d.ts","sourceRoot":"","sources":["../src/session-manager.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAKH,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AAGtC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AAIvC,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,GAAG,UAAU,GAAG,UAAU,GAAG,aAAa,CAAC;IACvD,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,SAAS;IACxB;;;2BAGuB;IACvB,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,GAAG,WAAW,CAAC;IAC3B,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,aAAa,EAAE,CAAC;CACzB;AAWD,MAAM,MAAM,aAAa,GAAG,UAAU,GAAG,UAAU,GAAG,aAAa,GAAG,MAAM,CAAC;AAE7E,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,aAAa,CAAC;IACrB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;CACnB;AAeD,cAAM,cAAe,SAAQ,YAAY;IACvC,OAAO,CAAC,QAAQ,CAAiC;IACjD,OAAO,CAAC,aAAa,CAAoD;IACzE,OAAO,CAAC,cAAc,CAAqC;;IAM3D,iBAAiB,CAAC,SAAS,EAAE,MAAM,GAAG,cAAc,GAAG,IAAI;IAI3D,oBAAoB,IAAI,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC;IAQtD,0EAA0E;IAC1E,YAAY,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAI9C;;;;;;;;;;;;;;OAcG;IACH,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,EAAE;IA0B9C,uEAAuE;IACvE,OAAO,CAAC,cAAc;IA2BtB;;;;;;;;;;;;;;OAcG;IACH,OAAO,CAAC,yBAAyB;IA6BjC,oBAAoB,CAAC,SAAS,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,GAAG,EAAE,SAAS,KAAK,IAAI,GAAG,IAAI;IAK3E,sBAAsB,CAAC,SAAS,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,GAAG,EAAE,SAAS,KAAK,IAAI,GAAG,IAAI;IAO7E;2EACuE;IACvE,YAAY,CAAC,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,OAAO,GAAE,OAAkB,GAAG,IAAI;IAYtF,kFAAkF;IAClF,qBAAqB,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI;IAI9C,OAAO,CAAC,WAAW;IAKnB;;0DAEsD;IACtD,iBAAiB,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI;IAU5D;;;gDAG4C;IAC5C,WAAW,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI;IA2CpC,wFAAwF;IACxF,mBAAmB,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI;IAM5C,+DAA+D;IAC/D,OAAO,CAAC,YAAY;IAepB,2GAA2G;IAC3G,OAAO,CAAC,oBAAoB;IAmC5B,gDAAgD;IAChD,OAAO,CAAC,oBAAoB;CAgD7B;AAED,eAAO,MAAM,cAAc,gBAAuB,CAAC"}

package/backend/dist/session-manager.js

@@ -1,9 +1,10 @@
 "use strict";
 /**
- * SessionManager — reads conversation history directly from Claude Code's
- * native JSONL files at ~/.claude/projects/{encoded-path}/{sessionId}.jsonl
+ * SessionManager — reads conversation history directly from the CLI's
+ * native JSONL files (e.g. ~/.claude/projects/{encoded-path}/{uuid}.jsonl).
  *
- * No PTY parsing, no ANSI stripping, no heuristics needed.
+ * No PTY parsing, no ANSI stripping, no heuristics. The JSONL is the single
+ * source of truth; ccweb maintains no separate conversation store.
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -42,25 +43,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.sessionManager = void 0;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
+const crypto = __importStar(require("crypto"));
 const events_1 = require("events");
-const uuid_1 = require("uuid");
 const config_1 = require("./config");
 const adapters_1 = require("./adapters");
-// ── Path helpers ─────────────────────────────────────────────────────────────
-const LEGACY_SESSIONS_DIR = path.join(config_1.DATA_DIR, 'sessions');
-/** New location: {folderPath}/.ccweb/sessions/ */
-function projectSessionsDir(folderPath) {
-    return (0, config_1.ccwebSessionsDir)(folderPath);
-}
-function projectSessionFile(folderPath, sessionId) {
-    return path.join(projectSessionsDir(folderPath), `${sessionId}.json`);
-}
-/** Legacy location: data/sessions/{projectId}/ */
-function legacySessionsDir(projectId) {
-    return path.join(LEGACY_SESSIONS_DIR, projectId);
-}
-function legacySessionFile(projectId, sessionId) {
-    return path.join(legacySessionsDir(projectId), `${sessionId}.json`);
+/** Generate a stable 16-hex-char id for a chat block.
+ *  `source` is the original JSONL line for line-based tools (Claude/Codex),
+ *  or `timestamp + JSON.stringify(blocks)` for whole-file tools (Gemini). */
+function makeBlockId(jsonlPath, source) {
+    return crypto.createHash('sha1').update(jsonlPath + '\0' + source).digest('hex').slice(0, 16);
 }
 // ── SessionManager ────────────────────────────────────────────────────────────
 class SessionManager extends events_1.EventEmitter {
@@ -84,17 +75,57 @@ class SessionManager extends events_1.EventEmitter {
     getJsonlPath(projectId) {
         return this.watchers.get(projectId)?.jsonlPath ?? null;
     }
-    /** Return all parsed ChatBlocks from the current session file (for replay on chat_subscribe). */
+    /** Return all parsed ChatBlocks from the project's latest JSONL file.
+     *
+     *  Resolution order:
+     *    1. Active watcher already has `jsonlPath` discovered via hooks → use it.
+     *    2. Watcher exists but hasn't discovered the file yet → lazily scan the
+     *       adapter's session dir, pick the latest JSONL, cache on the watcher.
+     *    3. No watcher (stopped project, user just navigated in) → resolve
+     *       project config on-the-fly and pick the latest JSONL. Do NOT
+     *       persist to `this.watchers` because a watcher without a PTY
+     *       would drift (no hooks, no triggerRead).
+     *
+     *  This indirection exists because chat history has to be loadable without
+     *  a hook ever firing (e.g. immediately after ccweb restart — triggerRead
+     *  only runs when Claude Code's hooks call `/api/hooks`).
+     */
     getChatHistory(projectId) {
         const state = this.watchers.get(projectId);
-        if (!state?.jsonlPath)
+        if (state) {
+            if (!state.jsonlPath) {
+                state.jsonlPath = this.findLatestJsonlForProject(state.folderPath, state.cliTool);
+            }
+            if (!state.jsonlPath)
+                return [];
+            return this.parseJsonlFile(state.jsonlPath, state.cliTool);
+        }
+        // No active watcher — fall back to project config for stopped projects
+        const project = (0, config_1.getProject)(projectId);
+        if (!project) {
+            console.warn(`[SessionManager] getChatHistory(${projectId}): project not in registry`);
             return [];
-        const adapter = (0, adapters_1.getAdapter)(state.cliTool);
+        }
+        const cliTool = project.cliTool ?? 'claude';
+        const jsonlPath = this.findLatestJsonlForProject(project.folderPath, cliTool);
+        if (!jsonlPath) {
+            console.warn(`[SessionManager] getChatHistory(${projectId}): no JSONL found for ${project.folderPath} (${cliTool})`);
+            return [];
+        }
+        return this.parseJsonlFile(jsonlPath, cliTool);
+    }
+    /** Parse a JSONL/JSON session file into ChatBlocks with stable ids. */
+    parseJsonlFile(jsonlPath, cliTool) {
+        const adapter = (0, adapters_1.getAdapter)(cliTool);
         try {
-            const content = fs.readFileSync(state.jsonlPath, 'utf-8');
+            const content = fs.readFileSync(jsonlPath, 'utf-8');
             // Whole-file JSON tools (e.g. Gemini): parse entire file at once
             if (typeof adapter.parseSessionFile === 'function') {
-                return adapter.parseSessionFile(content);
+                const blocks = adapter.parseSessionFile(content);
+                return blocks.map((b) => ({
+                    ...b,
+                    id: b.id ?? makeBlockId(jsonlPath, b.timestamp + '|' + JSON.stringify(b.blocks)),
+                }));
             }
             // JSONL tools (Claude, Codex): parse line by line
             const lines = content.split('\n').filter((l) => l.trim());
@@ -102,7 +133,7 @@ class SessionManager extends events_1.EventEmitter {
             for (const line of lines) {
                 const block = adapter.parseLineBlocks(line);
                 if (block)
-                    blocks.push(block);
+                    blocks.push({ ...block, id: makeBlockId(jsonlPath, line) });
             }
             return blocks;
         }
@@ -110,6 +141,53 @@ class SessionManager extends events_1.EventEmitter {
             return [];
         }
     }
+    /** Find the latest JSONL file for a project (single source of truth for
+     *  both chat-history HTTP and hook-driven tail paths).
+     *
+     *  Strategy: pick the newest file (by mtime) in the adapter's session dir.
+     *  For adapters that store sessions in a shared tree (e.g. Codex's
+     *  date-partitioned dir), use `getSessionFilesForProject` to scope by cwd.
+     *
+     *  Deliberately has NO startedAt/recency filter — historical requirement
+     *  was for "the file THIS session is writing", but that caused HTTP and
+     *  WS paths to disagree on which file to read, breaking block-id dedup.
+     *  Using "newest" works because Claude --continue updates the mtime of
+     *  the continued file, and any new file it creates has the highest mtime.
+     *  The caller (triggerRead) handles mid-session file switches by re-
+     *  checking on each call.
+     */
+    findLatestJsonlForProject(folderPath, cliTool) {
+        const adapter = (0, adapters_1.getAdapter)(cliTool);
+        if (typeof adapter.getSessionFilesForProject === 'function') {
+            const files = adapter.getSessionFilesForProject(folderPath);
+            if (files.length === 0)
+                return null;
+            try {
+                return files
+                    .map((f) => ({ f, mtime: fs.statSync(f).mtimeMs }))
+                    .sort((a, b) => b.mtime - a.mtime)[0].f;
+            }
+            catch {
+                return null;
+            }
+        }
+        const dir = adapter.getSessionDir(folderPath);
+        if (!dir || !fs.existsSync(dir))
+            return null;
+        const ext = typeof adapter.getSessionFileExtension === 'function'
+            ? adapter.getSessionFileExtension()
+            : '.jsonl';
+        try {
+            const files = fs.readdirSync(dir)
+                .filter((f) => f.endsWith(ext))
+                .map((f) => ({ f, mtime: fs.statSync(path.join(dir, f)).mtimeMs }))
+                .sort((a, b) => b.mtime - a.mtime);
+            return files.length > 0 ? path.join(dir, files[0].f) : null;
+        }
+        catch {
+            return null;
+        }
+    }
     registerChatListener(projectId, cb) {
         if (!this.chatListeners.has(projectId))
             this.chatListeners.set(projectId, new Set());
@@ -123,51 +201,18 @@ class SessionManager extends events_1.EventEmitter {
         if (listeners.size === 0)
             this.chatListeners.delete(projectId);
     }
-    /** Call when a new PTY starts for a project */
+    /** Call when a new PTY starts for a project. Registers a watcher so that
+     *  subsequent hook-driven `triggerRead()` calls can tail the JSONL. */
     startSession(projectId, folderPath, cliTool = 'claude') {
-        // Stop any previous watcher
         this.stopWatcher(projectId);
-        const sessionId = `${Date.now()}-${(0, uuid_1.v4)().slice(0, 8)}`;
-        const startedAt = Date.now();
-        // Create our session file in .ccweb/sessions/
-        fs.mkdirSync(projectSessionsDir(folderPath), { recursive: true });
-        const session = { id: sessionId, projectId, startedAt: new Date(startedAt).toISOString(), messages: [] };
-        fs.writeFileSync(projectSessionFile(folderPath, sessionId), JSON.stringify(session, null, 2), 'utf-8');
-        const state = {
-            sessionId,
+        this.watchers.set(projectId, {
             folderPath,
             cliTool,
             jsonlPath: null,
             fileOffset: 0,
-            startedAt,
-        };
-        this.watchers.set(projectId, state);
-        // Prune old sessions (keep latest 20)
-        this.pruneOldSessions(folderPath, projectId);
-        console.log(`[SessionManager] Started session ${sessionId} for project ${projectId}`);
-    }
-    pruneOldSessions(folderPath, projectId, keep = 20) {
-        const dirs = [projectSessionsDir(folderPath), legacySessionsDir(projectId)];
-        for (const dir of dirs) {
-            if (!fs.existsSync(dir))
-                continue;
-            try {
-                const files = fs.readdirSync(dir)
-                    .filter((f) => f.endsWith('.json'))
-                    .sort(); // session filenames start with timestamp, so sort = chronological
-                if (files.length <= keep)
-                    continue;
-                const toDelete = files.slice(0, files.length - keep);
-                for (const f of toDelete) {
-                    try {
-                        fs.unlinkSync(path.join(dir, f));
-                    }
-                    catch { /**/ }
-                }
-                console.log(`[SessionManager] Pruned ${toDelete.length} old sessions in ${dir}`);
-            }
-            catch { /**/ }
-        }
+            startedAt: Date.now(),
+        });
+        console.log(`[SessionManager] Started watcher for project ${projectId}`);
     }
     /** Stop the session poller for a project (public for cleanup on terminal stop) */
     stopWatcherForProject(projectId) {
@@ -189,49 +234,55 @@ class SessionManager extends events_1.EventEmitter {
         this.semanticStatus.set(projectId, newStatus);
         this.emit('semantic', { projectId, status: newStatus });
     }
-    /** Called by hooks route on PostToolUse/Stop.
-     *  Immediately reads any new lines from the JSONL file. */
+    /** Called by hooks route on PostToolUse/Stop. Discovers the latest JSONL
+     *  file if not already cached, detects mid-session file switches (e.g.
+     *  Claude --continue creating a fresh JSONL), then reads new content and
+     *  emits block events to chat listeners. */
     triggerRead(projectId) {
         const state = this.watchers.get(projectId);
         if (!state)
             return;
-        // If JSONL not found yet, retry up to 3 times (handles race where hook fires before first write)
+        // Re-check latest file each call: shares the single `findLatestJsonlForProject`
+        // path with getChatHistory so HTTP and WS paths always agree on which file
+        // is authoritative (→ consistent block ids → frontend dedup works).
+        const latest = this.findLatestJsonlForProject(state.folderPath, state.cliTool);
+        if (latest && latest !== state.jsonlPath) {
+            state.jsonlPath = latest;
+            state.fileOffset = 0;
+        }
         if (!state.jsonlPath) {
-            state.jsonlPath = this.findJsonl(state.folderPath, state.startedAt, state.cliTool);
-            if (!state.jsonlPath) {
-                // Guard: skip if a retry chain is already running for this project
-                if (state.retrying)
-                    return;
-                state.retrying = true;
-                const delays = [500, 1000, 2000];
-                const retry = (attempt) => {
-                    setTimeout(() => {
-                        const s = this.watchers.get(projectId);
-                        if (!s)
-                            return;
-                        if (s.jsonlPath) {
-                            s.retrying = false;
-                            return;
-                        }
-                        s.jsonlPath = this.findJsonl(s.folderPath, s.startedAt, s.cliTool);
-                        if (s.jsonlPath) {
-                            s.retrying = false;
-                            s.fileOffset = 0;
-                            this.readNewLines(projectId, s);
-                        }
-                        else if (attempt + 1 < delays.length) {
-                            retry(attempt + 1);
-                        }
-                        else {
-                            s.retrying = false;
-                            console.warn(`[SessionManager] JSONL file not found for project ${projectId} after ${delays.length} retries — chat history unavailable`);
-                        }
-                    }, delays[attempt]);
-                };
-                retry(0);
+            // Brand-new project or session dir not yet created — retry a few times
+            if (state.retrying)
                 return;
-            }
-            state.fileOffset = 0;
+            state.retrying = true;
+            const delays = [500, 1000, 2000];
+            const retry = (attempt) => {
+                setTimeout(() => {
+                    const s = this.watchers.get(projectId);
+                    if (!s)
+                        return;
+                    if (s.jsonlPath) {
+                        s.retrying = false;
+                        return;
+                    }
+                    const later = this.findLatestJsonlForProject(s.folderPath, s.cliTool);
+                    if (later) {
+                        s.retrying = false;
+                        s.jsonlPath = later;
+                        s.fileOffset = 0;
+                        this.readNewLines(projectId, s);
+                    }
+                    else if (attempt + 1 < delays.length) {
+                        retry(attempt + 1);
+                    }
+                    else {
+                        s.retrying = false;
+                        console.warn(`[SessionManager] JSONL file not found for project ${projectId} after ${delays.length} retries — chat history unavailable`);
+                    }
+                }, delays[attempt]);
+            };
+            retry(0);
+            return;
         }
         this.readNewLines(projectId, state);
     }
@@ -242,27 +293,6 @@ class SessionManager extends events_1.EventEmitter {
         this.semanticStatus.delete(projectId);
         this.emit('semantic', { projectId, status: null });
     }
-    /** Find the newest session file created after startedAt in the tool's session dir */
-    findJsonl(folderPath, startedAt, cliTool = 'claude') {
-        const adapter = (0, adapters_1.getAdapter)(cliTool);
-        const dir = adapter.getSessionDir(folderPath);
-        if (!dir || !fs.existsSync(dir))
-            return null;
-        const ext = typeof adapter.getSessionFileExtension === 'function'
-            ? adapter.getSessionFileExtension()
-            : '.jsonl';
-        try {
-            const files = fs.readdirSync(dir)
-                .filter((f) => f.endsWith(ext))
-                .map((f) => ({ f, mtime: fs.statSync(path.join(dir, f)).mtimeMs }))
-                .filter(({ mtime }) => mtime >= startedAt - 5000) // 5s grace
-                .sort((a, b) => b.mtime - a.mtime);
-            return files.length > 0 ? path.join(dir, files[0].f) : null;
-        }
-        catch {
-            return null;
-        }
-    }
     /** Read new data from the session file and extract messages */
     readNewLines(projectId, state) {
         if (!state.jsonlPath)
@@ -287,22 +317,14 @@ class SessionManager extends events_1.EventEmitter {
             const blocks = adapter.parseSessionFile(content);
             if (blocks.length === 0)
                 return;
-            // Extract SessionMessages for our ccweb session file
-            const newMsgs = [];
-            for (const block of blocks) {
-                const text = block.blocks.filter(b => b.type === 'text').map(b => b.content).join('\n').trim();
-                if (text) {
-                    newMsgs.push({ role: block.role, content: text, timestamp: block.timestamp });
-                }
-            }
-            if (newMsgs.length > 0) {
-                // Overwrite (not append) since we re-parsed the whole file
-                this.overwriteMessages(state.folderPath, state.sessionId, newMsgs);
-            }
             // Emit latest blocks to chat listeners + update semantic status
             for (const block of blocks) {
-                if (block.role === 'assistant' && block.blocks.length > 0) {
-                    const lastBlock = block.blocks[block.blocks.length - 1];
+                const blockWithId = {
+                    ...block,
+                    id: block.id ?? makeBlockId(state.jsonlPath, block.timestamp + '|' + JSON.stringify(block.blocks)),
+                };
+                if (blockWithId.role === 'assistant' && blockWithId.blocks.length > 0) {
+                    const lastBlock = blockWithId.blocks[blockWithId.blocks.length - 1];
                     const detail = lastBlock.type === 'tool_use' ? lastBlock.content.split('(')[0] : undefined;
                     const newStatus = { phase: lastBlock.type, detail, updatedAt: Date.now() };
                     this.semanticStatus.set(projectId, newStatus);
@@ -312,7 +334,7 @@ class SessionManager extends events_1.EventEmitter {
                 if (listeners) {
                     for (const cb of listeners) {
                         try {
-                            cb(block);
+                            cb(blockWithId);
                         }
                         catch { /**/ }
                     }
@@ -336,21 +358,11 @@ class SessionManager extends events_1.EventEmitter {
             fs.readSync(fd, buf, 0, toRead, state.fileOffset);
             state.fileOffset = stat.size;
             const lines = buf.toString('utf-8').split('\n').filter((l) => l.trim());
-            let changed = false;
-            const newMsgs = [];
-            for (const line of lines) {
-                const msg = adapter.parseLine(line);
-                if (msg)
-                    newMsgs.push(msg);
-            }
-            if (newMsgs.length > 0) {
-                this.appendMessages(state.folderPath, state.sessionId, newMsgs);
-                changed = true;
-            }
             // Emit to chat listeners + update semantic status
             for (const line of lines) {
-                const block = adapter.parseLineBlocks(line);
-                if (block) {
+                const parsed = adapter.parseLineBlocks(line);
+                if (parsed) {
+                    const block = { ...parsed, id: makeBlockId(state.jsonlPath, line) };
                     if (block.role === 'assistant' && block.blocks.length > 0) {
                         const lastBlock = block.blocks[block.blocks.length - 1];
                         const detail = lastBlock.type === 'tool_use'
@@ -375,9 +387,6 @@ class SessionManager extends events_1.EventEmitter {
                     }
                 }
             }
-            if (changed) {
-                console.log(`[SessionManager] Updated session ${state.sessionId}`);
-            }
         }
         catch {
             // file may be temporarily locked or missing — try again next poll
@@ -390,116 +399,6 @@ class SessionManager extends events_1.EventEmitter {
                 catch { /**/ }
         }
     }
-    appendMessages(folderPath, sessionId, msgs) {
-        const file = projectSessionFile(folderPath, sessionId);
-        try {
-            const session = JSON.parse(fs.readFileSync(file, 'utf-8'));
-            session.messages.push(...msgs);
-            const tmpPath = file + `.tmp.${process.pid}`;
-            fs.writeFileSync(tmpPath, JSON.stringify(session, null, 2), 'utf-8');
-            fs.renameSync(tmpPath, file);
-        }
-        catch (err) {
-            console.error(`[SessionManager] Failed to append messages to session ${sessionId}:`, err);
-        }
-    }
-    /** Overwrite all messages (for whole-file JSON tools that re-parse the entire session) */
-    overwriteMessages(folderPath, sessionId, msgs) {
-        const file = projectSessionFile(folderPath, sessionId);
-        try {
-            const session = JSON.parse(fs.readFileSync(file, 'utf-8'));
-            session.messages = msgs;
-            const tmpPath = file + `.tmp.${process.pid}`;
-            fs.writeFileSync(tmpPath, JSON.stringify(session, null, 2), 'utf-8');
-            fs.renameSync(tmpPath, file);
-        }
-        catch (err) {
-            console.error(`[SessionManager] Failed to overwrite messages for session ${sessionId}:`, err);
-        }
-    }
-    // ── Query API ──────────────────────────────────────────────────────────────
-    /** Resolve folderPath for a project — from active watcher or project config */
-    resolveFolderPath(projectId) {
-        const watcher = this.watchers.get(projectId);
-        if (watcher)
-            return watcher.folderPath;
-        const project = (0, config_1.getProject)(projectId);
-        return project?.folderPath ?? null;
-    }
-    /** Read session files from a directory */
-    readSessionsFromDir(dir, currentId) {
-        if (!fs.existsSync(dir))
-            return [];
-        try {
-            return fs.readdirSync(dir)
-                .filter((f) => f.endsWith('.json'))
-                .map((f) => {
-                try {
-                    const s = JSON.parse(fs.readFileSync(path.join(dir, f), 'utf-8'));
-                    return {
-                        id: s.id,
-                        projectId: s.projectId,
-                        startedAt: s.startedAt,
-                        messageCount: s.messages.length,
-                        isCurrent: s.id === currentId,
-                    };
-                }
-                catch {
-                    return null;
-                }
-            })
-                .filter((s) => s !== null);
-        }
-        catch {
-            return [];
-        }
-    }
-    listSessions(projectId) {
-        const currentId = this.watchers.get(projectId)?.sessionId;
-        const folderPath = this.resolveFolderPath(projectId);
-        // Collect from .ccweb/sessions/ (primary) and legacy data/sessions/ (fallback)
-        const results = [];
-        const seenIds = new Set();
-        if (folderPath) {
-            for (const s of this.readSessionsFromDir(projectSessionsDir(folderPath), currentId)) {
-                results.push(s);
-                seenIds.add(s.id);
-            }
-        }
-        // Legacy fallback — include sessions not already in .ccweb/
-        for (const s of this.readSessionsFromDir(legacySessionsDir(projectId), currentId)) {
-            if (!seenIds.has(s.id)) {
-                results.push(s);
-            }
-        }
-        return results.sort((a, b) => b.startedAt.localeCompare(a.startedAt));
-    }
-    /** Validate sessionId to prevent path traversal */
-    isValidSessionId(sessionId) {
-        return /^[\w-]+$/.test(sessionId) && !sessionId.includes('..');
-    }
-    getSession(projectId, sessionId) {
-        if (!this.isValidSessionId(sessionId))
-            return null;
-        const folderPath = this.resolveFolderPath(projectId);
-        // Try .ccweb/ first
-        if (folderPath) {
-            const file = projectSessionFile(folderPath, sessionId);
-            try {
-                if (fs.existsSync(file)) {
-                    return JSON.parse(fs.readFileSync(file, 'utf-8'));
-                }
-            }
-            catch { /* fall through */ }
-        }
-        // Legacy fallback
-        try {
-            return JSON.parse(fs.readFileSync(legacySessionFile(projectId, sessionId), 'utf-8'));
-        }
-        catch {
-            return null;
-        }
-    }
 }
 exports.sessionManager = new SessionManager();
 //# sourceMappingURL=session-manager.js.map