@alexjbarnes/cockpit 0.1.1 → 0.2.0

package/dist/src/server/session-manager.js

@@ -54,6 +54,7 @@ class SessionManager {
             lastActiveAt: now,
             status: "idle",
             model: defaults.model || undefined,
+            pendingRequestCount: 0,
         };
         this.sessions.set(id, {
             info,
@@ -100,6 +101,7 @@ class SessionManager {
                     lastActiveAt: now,
                     status: "idle",
                     model: prefs?.model || defaults.model || undefined,
+                    pendingRequestCount: 0,
                 },
                 process: null,
                 stdin: null,
@@ -146,12 +148,15 @@ class SessionManager {
             this.ensureSession(id, cwd);
             session = this.sessions.get(id);
         }
-        const result = await (0, transcript_1.loadTranscript)(session.cliSessionId, session.info.cwd, { tailLines: 150 });
+        const stitching = (0, defaults_1.getDefaults)().messageStitching;
+        const willStitch = stitching && session.previousCliSessionIds.length > 0;
+        // Load full current session when stitching to avoid losing middle messages.
+        // Without stitching, tail-read is fine because byteOffset stays pointing at
+        // the current session's file for backward pagination.
+        const result = await (0, transcript_1.loadTranscript)(session.cliSessionId, session.info.cwd, willStitch ? undefined : { tailLines: 150 });
         let { messages, byteOffset, totalSize, lastUsage } = result;
         session.bufferCliSessionId = session.cliSessionId;
-        // Stitch previous session messages across /clear boundaries so the full
-        // conversation is visible on refresh instead of only post-clear messages.
-        if (session.previousCliSessionIds.length > 0) {
+        if (willStitch) {
             const currentMessages = messages;
             for (let i = session.previousCliSessionIds.length - 1; i >= 0; i--) {
                 const prevId = session.previousCliSessionIds[i];
@@ -178,11 +183,11 @@ class SessionManager {
         session.transcriptByteOffset = byteOffset;
         session.transcriptTotalSize = totalSize;
         // Fresh pagination copy so getMoreHistory doesn't consume the canonical list
-        session.paginationPrevIds = [...session.previousCliSessionIds];
+        session.paginationPrevIds = stitching ? [...session.previousCliSessionIds] : [];
         // Send last 50 to client, keep rest in buffer
         const PAGE = 50;
         const clientMessages = messages.length > PAGE ? messages.slice(-PAGE) : messages;
-        const hasMore = messages.length > PAGE || byteOffset > 0 || session.previousCliSessionIds.length > 0;
+        const hasMore = messages.length > PAGE || byteOffset > 0 || (stitching && session.previousCliSessionIds.length > 0);
         const defaultName = node_path_1.default.basename(session.info.cwd) || session.info.cwd;
         if (session.info.name === defaultName && messages.length > 0) {
             const firstUser = messages.find((m) => m.role === "user" && m.content && !m.content.startsWith("[") && !m.content.startsWith("<"));
@@ -195,12 +200,12 @@ class SessionManager {
     async getSessionByCwd(id, cwd) {
         this.ensureSession(id, cwd);
         const session = this.sessions.get(id);
-        const result = await (0, transcript_1.loadTranscript)(session.cliSessionId, cwd, { tailLines: 150 });
+        const stitching = (0, defaults_1.getDefaults)().messageStitching;
+        const willStitch = stitching && session.previousCliSessionIds.length > 0;
+        const result = await (0, transcript_1.loadTranscript)(session.cliSessionId, cwd, willStitch ? undefined : { tailLines: 150 });
         let { messages, byteOffset, totalSize, lastUsage } = result;
         session.bufferCliSessionId = session.cliSessionId;
-        // Stitch previous session messages across /clear boundaries so the full
-        // conversation is visible on refresh instead of only post-clear messages.
-        if (session.previousCliSessionIds.length > 0) {
+        if (willStitch) {
             const currentMessages = messages;
             for (let i = session.previousCliSessionIds.length - 1; i >= 0; i--) {
                 const prevId = session.previousCliSessionIds[i];
@@ -227,11 +232,11 @@ class SessionManager {
         session.transcriptByteOffset = byteOffset;
         session.transcriptTotalSize = totalSize;
         // Fresh pagination copy so getMoreHistory doesn't consume the canonical list
-        session.paginationPrevIds = [...session.previousCliSessionIds];
+        session.paginationPrevIds = stitching ? [...session.previousCliSessionIds] : [];
         // Send last 50 to client, keep rest in buffer
         const PAGE = 50;
         const clientMessages = messages.length > PAGE ? messages.slice(-PAGE) : messages;
-        const hasMore = messages.length > PAGE || byteOffset > 0 || session.previousCliSessionIds.length > 0;
+        const hasMore = messages.length > PAGE || byteOffset > 0 || (stitching && session.previousCliSessionIds.length > 0);
         // Derive title from first user message if name is still the default
         const defaultName = node_path_1.default.basename(cwd) || cwd;
         if (session.info.name === defaultName && messages.length > 0) {
@@ -247,9 +252,10 @@ class SessionManager {
             return null;
         const chain = (0, session_prefs_1.findChainForCliSession)(cliId);
         const prevIds = chain ? chain.truncatedPrevIds : [];
-        const result = await (0, transcript_1.loadTranscript)(cliId, cwd, { tailLines: 150 });
+        const willStitch = (0, defaults_1.getDefaults)().messageStitching && prevIds.length > 0;
+        const result = await (0, transcript_1.loadTranscript)(cliId, cwd, willStitch ? undefined : { tailLines: 150 });
         let { messages, lastUsage } = result;
-        if (prevIds.length > 0) {
+        if (willStitch) {
             const currentMessages = messages;
             for (let i = prevIds.length - 1; i >= 0; i--) {
                 const prevResult = await (0, transcript_1.loadTranscript)(prevIds[i], cwd, { tailLines: 150 });
@@ -382,11 +388,16 @@ class SessionManager {
         const session = this.sessions.get(id);
         return !!session?.process;
     }
+    hasRunningProcess(id) {
+        const session = this.sessions.get(id);
+        return !!session?.process;
+    }
     fixStaleStatus(id) {
         const session = this.sessions.get(id);
         if (session && session.info.status === "running" && !session.process) {
             session.info.status = "idle";
             session.pendingRequests.clear();
+            this.notifyPendingChanged(session, id);
         }
     }
     restartSession(sessionId) {
@@ -399,6 +410,7 @@ class SessionManager {
         }
         this.killProcess(session);
         session.pendingRequests.clear();
+        this.notifyPendingChanged(session, sessionId);
         session.streamingSnapshot = null;
         session.info.status = "idle";
         session.emitter.emit("status", sessionId, "idle");
@@ -437,6 +449,16 @@ class SessionManager {
         session.emitter.on("status", handler);
         return () => session.emitter.off("status", handler);
     }
+    onPending(id, listener) {
+        const session = this.sessions.get(id);
+        if (!session)
+            return null;
+        const handler = (_sessionId, count) => {
+            listener(count);
+        };
+        session.emitter.on("pending", handler);
+        return () => session.emitter.off("pending", handler);
+    }
     onError(id, listener) {
         const session = this.sessions.get(id);
         if (!session)
@@ -484,12 +506,14 @@ class SessionManager {
         const session = this.sessions.get(sessionId);
         if (session) {
             session.pendingRequests.set(request.requestId, request);
+            this.notifyPendingChanged(session, sessionId);
         }
     }
     removePendingRequest(sessionId, requestId) {
         const session = this.sessions.get(sessionId);
         if (session) {
             session.pendingRequests.delete(requestId);
+            this.notifyPendingChanged(session, sessionId);
         }
     }
     getPendingRequests(sessionId) {
@@ -498,11 +522,15 @@ class SessionManager {
             return [];
         return Array.from(session.pendingRequests.values());
     }
+    getPendingRequest(sessionId, requestId) {
+        return this.sessions.get(sessionId)?.pendingRequests.get(requestId);
+    }
     respondToPermission(sessionId, requestId, allowed, toolInput, permissionSuggestions, denyReason) {
         const session = this.sessions.get(sessionId);
         if (!session?.stdin)
             return false;
         session.pendingRequests.delete(requestId);
+        this.notifyPendingChanged(session, sessionId);
         const response = {
             type: "control_response",
             response: {
@@ -511,7 +539,7 @@ class SessionManager {
                 response: allowed
                     ? {
                         behavior: "allow",
-                        ...(toolInput ? { updatedInput: toolInput } : {}),
+                        updatedInput: toolInput ?? {},
                         ...(permissionSuggestions?.length ? { updatedPermissions: permissionSuggestions } : {}),
                     }
                     : { behavior: "deny", message: denyReason ?? "User denied" },
@@ -540,6 +568,7 @@ class SessionManager {
         // Don't change CLI mode while in plan mode; bypass will restore on plan exit
         if (!session.planMode) {
             this.sendPermissionMode(session, sessionId, "bypassPermissions");
+            this.scheduleRespawnForPermissions(session);
         }
         this.emitSystem(session, sessionId, "__bypass_state::on");
     }
@@ -551,9 +580,25 @@ class SessionManager {
         (0, session_prefs_1.setSessionPrefs)(sessionId, { bypassAllPermissions: false });
         if (!session.planMode) {
             this.sendPermissionMode(session, sessionId, "default");
+            this.scheduleRespawnForPermissions(session);
         }
         this.emitSystem(session, sessionId, "__bypass_state::off");
     }
+    // Runtime set_permission_mode is unreliable when the CLI was spawned without
+    // the target mode. Respawning the process picks up --permission-mode from
+    // session state, guaranteeing the next message runs in the right mode.
+    // If a message is in flight, defer until message_done so we don't orphan it.
+    scheduleRespawnForPermissions(session) {
+        if (!session.process)
+            return;
+        if (session.info.status === "idle") {
+            this.killProcess(session);
+            session.hasSpawnedBefore = (0, transcript_1.transcriptExists)(session.cliSessionId, session.info.cwd);
+        }
+        else {
+            session.needsRespawnForPermissions = true;
+        }
+    }
     isBypassActive(sessionId) {
         const session = this.sessions.get(sessionId);
         return session?.bypassAllPermissions ?? false;
@@ -574,6 +619,7 @@ class SessionManager {
         }
         // Clear orphaned pending requests from the killed process
         session.pendingRequests.clear();
+        this.notifyPendingChanged(session, sessionId);
         this.emitSystem(session, sessionId, "__plan_state::on");
     }
     clearPlanMode(sessionId) {
@@ -591,6 +637,7 @@ class SessionManager {
         }
         // Clear orphaned pending requests from the killed process
         session.pendingRequests.clear();
+        this.notifyPendingChanged(session, sessionId);
         this.emitSystem(session, sessionId, "__plan_state::off");
         // Re-sync bypass state with the client so the UI reflects it correctly
         // after the plan-mode process is torn down.
@@ -968,6 +1015,13 @@ class SessionManager {
     emitSystem(session, sessionId, text) {
         session.emitter.emit("system", sessionId, text);
     }
+    notifyPendingChanged(session, sessionId) {
+        const count = session.pendingRequests.size;
+        if (session.info.pendingRequestCount === count)
+            return;
+        session.info.pendingRequestCount = count;
+        session.emitter.emit("pending", sessionId, count);
+    }
     applyProcessedResult(session, sessionId, result) {
         for (const msg of result.intermediateMessages) {
             session.emitter.emit("event", sessionId, { type: "message_done", message: msg });
@@ -1008,6 +1062,12 @@ class SessionManager {
             else if (pa.type === "auto_deny") {
                 this.respondToPermission(sessionId, pa.requestId, false, undefined, undefined, pa.denyReason);
             }
+            else if (session.bypassAllPermissions && !session.planMode) {
+                // CLI was spawned without bypass capability (e.g. after exiting plan
+                // mode) but the session has bypass enabled. Auto-approve server-side
+                // until the process respawns with the right flags.
+                this.respondToPermission(sessionId, pa.requestId, true, pa.rawToolInput);
+            }
             else {
                 const planPath = pa.toolName === "ExitPlanMode" ? (0, plans_1.findLatestPlanFile)() : undefined;
                 session.pendingRequests.set(pa.requestId, {
@@ -1016,9 +1076,11 @@ class SessionManager {
                     toolName: pa.toolName,
                     toolInput: pa.toolInput || "",
                     rawToolInput: pa.rawToolInput,
+                    permissionSuggestions: pa.permissionSuggestions,
                     planFilePath: planPath,
                     planContent: planPath ? (0, plans_1.readPlanFile)(planPath) : undefined,
                 });
+                this.notifyPendingChanged(session, sessionId);
             }
         }
         if (result.compactDone) {
@@ -1197,6 +1259,27 @@ Additional Cockpit rules beyond the CLI's defaults:
         smLog(id, `recovery succeeded: restored from ${cwd}`);
         return true;
     }
+    estimateMessageTokens(text, images, documents) {
+        let tokens = Math.ceil(text.length / 4);
+        if (images)
+            tokens += images.length * 2000;
+        if (documents)
+            tokens += documents.reduce((sum, d) => sum + Math.ceil(d.data.length / 5), 0);
+        return tokens;
+    }
+    shouldPreCompact(session, text, images, documents) {
+        if (!session.contextUsage)
+            return false;
+        if (session.compacting)
+            return false;
+        if (text.trim().toLowerCase().startsWith("/compact"))
+            return false;
+        if (text.trim().startsWith("/"))
+            return false;
+        const estimate = this.estimateMessageTokens(text, images, documents);
+        const { used, total } = session.contextUsage;
+        return used + estimate > total * 0.85;
+    }
     sendMessage(sessionId, text, images, documents) {
         const session = this.sessions.get(sessionId);
         if (!session) {
@@ -1214,6 +1297,26 @@ Additional Cockpit rules beyond the CLI's defaults:
                 this.emitSystem(session, sessionId, "__compact::start");
             }
         }
+        // If the message would likely overflow the context window, compact first
+        // and queue the message for delivery after compaction finishes.
+        if (session.info.status !== "running" && this.shouldPreCompact(session, text, images, documents)) {
+            this.log(sessionId, "pre-send compact: message would exceed 85% of context window");
+            (0, debug_logger_1.logDiag)(sessionId, "compact:pre-send");
+            session.queuedMessages.push({ id: `q-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`, text, images, documents });
+            session.emitter.emit("queued", sessionId, session.queuedMessages.length);
+            session.compacting = true;
+            this.emitSystem(session, sessionId, "__compact::start");
+            session.info.status = "running";
+            session.emitter.emit("status", sessionId, "running");
+            if (session.process && session.stdin) {
+                const compactInput = { type: "user", message: { role: "user", content: "/compact" } };
+                session.stdin.write(JSON.stringify(compactInput) + "\n");
+            }
+            else {
+                this.spawnProcess(session, sessionId, "/compact");
+            }
+            return true;
+        }
         const content = this.buildContent(session, text, images, documents);
         // If queue was paused (user interrupted then sent a new message),
         // discard the paused messages and reset the flag.

package/dist/src/server/transcript.js

@@ -4,12 +4,18 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.transcriptExists = transcriptExists;
+exports.deleteTranscript = deleteTranscript;
+exports.countTranscriptMessages = countTranscriptMessages;
 exports.readMoreLines = readMoreLines;
 exports.loadLastUsage = loadLastUsage;
 exports.loadTranscript = loadTranscript;
 exports.loadMoreMessages = loadMoreMessages;
 exports.findSessionCwd = findSessionCwd;
 exports.scanAllSessions = scanAllSessions;
+exports.scanSessionsForCwd = scanSessionsForCwd;
+exports.scanSessionsByIds = scanSessionsByIds;
+exports.listAllTranscriptFiles = listAllTranscriptFiles;
+exports.globalSearch = globalSearch;
 const node_fs_1 = require("node:fs");
 const promises_1 = require("node:fs/promises");
 const node_os_1 = require("node:os");
@@ -24,6 +30,31 @@ function getTranscriptPath(sessionId, cwd) {
 function transcriptExists(sessionId, cwd) {
     return (0, node_fs_1.existsSync)(getTranscriptPath(sessionId, cwd));
 }
+async function deleteTranscript(sessionId, cwd) {
+    const fp = getTranscriptPath(sessionId, cwd);
+    if (!(0, node_fs_1.existsSync)(fp))
+        return false;
+    await (0, promises_1.unlink)(fp);
+    return true;
+}
+function countTranscriptMessages(sessionId, cwd) {
+    const fp = getTranscriptPath(sessionId, cwd);
+    if (!(0, node_fs_1.existsSync)(fp))
+        return 0;
+    try {
+        const raw = (0, node_fs_1.readFileSync)(fp, "utf-8");
+        let count = 0;
+        for (const line of raw.split("\n")) {
+            if (line.includes('"role"') && (line.includes('"assistant"') || line.includes('"user"'))) {
+                count++;
+            }
+        }
+        return count;
+    }
+    catch {
+        return 0;
+    }
+}
 const CLI_XML_RE = /<(?:task-notification|local-command-caveat|local-command-stdout|system-reminder)[^>]*>[\s\S]*?<\/(?:task-notification|local-command-caveat|local-command-stdout|system-reminder)>[\s\S]*/g;
 const FILE_TAG_RE = /<file\s+path="([^"]+)">\n([\s\S]*?)\n<\/file>/g;
 function extractTextFiles(text) {
@@ -106,9 +137,6 @@ async function readTailLines(filePath, targetCount) {
             }
             // Not enough lines, double chunk and retry
             chunkSize *= 2;
-            if (chunkSize >= totalSize) {
-                return { lines, byteOffset: 0, totalSize };
-            }
         }
     }
     finally {
@@ -154,9 +182,6 @@ async function readMoreLines(filePath, byteOffset, targetCount) {
                 return { lines: result, newByteOffset: offset === 0 ? 0 : newByteOffset };
             }
             chunkSize *= 2;
-            if (chunkSize >= byteOffset) {
-                return { lines, newByteOffset: 0 };
-            }
         }
     }
     finally {
@@ -646,6 +671,7 @@ async function scanAllSessions() {
             cwd,
             dirName: node_path_1.default.basename(cwd) || cwd,
             sessions,
+            totalSessionCount: sessions.length,
         });
     }
     result.sort((a, b) => {
@@ -655,3 +681,242 @@ async function scanAllSessions() {
     });
     return result;
 }
+function metaToSessionInfo(meta) {
+    return {
+        id: meta.id,
+        name: meta.title,
+        cwd: meta.cwd,
+        createdAt: meta.createdAt,
+        lastActiveAt: meta.lastActiveAt,
+        status: "idle",
+    };
+}
+async function scanSessionsForCwd(targetCwd) {
+    const projectsDir = node_path_1.default.join((0, node_os_1.homedir)(), ".claude", "projects");
+    if (!(0, node_fs_1.existsSync)(projectsDir))
+        return [];
+    let projectDirs;
+    try {
+        projectDirs = await (0, promises_1.readdir)(projectsDir);
+    }
+    catch {
+        return [];
+    }
+    const results = [];
+    for (const dir of projectDirs) {
+        const dirPath = node_path_1.default.join(projectsDir, dir);
+        let files;
+        try {
+            files = await (0, promises_1.readdir)(dirPath);
+        }
+        catch {
+            continue;
+        }
+        const jsonlFiles = files.filter((f) => f.endsWith(".jsonl"));
+        const metas = await Promise.all(jsonlFiles.map((f) => extractSessionMeta(node_path_1.default.join(dirPath, f))));
+        for (const meta of metas) {
+            if (meta && meta.cwd === targetCwd) {
+                results.push(metaToSessionInfo(meta));
+            }
+        }
+    }
+    results.sort((a, b) => b.lastActiveAt - a.lastActiveAt);
+    return results;
+}
+async function scanSessionsByIds(ids) {
+    if (ids.length === 0)
+        return [];
+    const projectsDir = node_path_1.default.join((0, node_os_1.homedir)(), ".claude", "projects");
+    if (!(0, node_fs_1.existsSync)(projectsDir))
+        return [];
+    let projectDirs;
+    try {
+        projectDirs = await (0, promises_1.readdir)(projectsDir);
+    }
+    catch {
+        return [];
+    }
+    const idSet = new Set(ids);
+    const results = [];
+    for (const dir of projectDirs) {
+        if (idSet.size === 0)
+            break;
+        const dirPath = node_path_1.default.join(projectsDir, dir);
+        let files;
+        try {
+            files = await (0, promises_1.readdir)(dirPath);
+        }
+        catch {
+            continue;
+        }
+        const matching = files.filter((f) => f.endsWith(".jsonl") && idSet.has(f.slice(0, -".jsonl".length)));
+        if (matching.length === 0)
+            continue;
+        const metas = await Promise.all(matching.map((f) => extractSessionMeta(node_path_1.default.join(dirPath, f))));
+        for (const meta of metas) {
+            if (meta) {
+                results.push(metaToSessionInfo(meta));
+                idSet.delete(meta.id);
+            }
+        }
+    }
+    return results;
+}
+async function listAllTranscriptFiles() {
+    const projectsDir = node_path_1.default.join((0, node_os_1.homedir)(), ".claude", "projects");
+    if (!(0, node_fs_1.existsSync)(projectsDir))
+        return [];
+    let projectDirs;
+    try {
+        projectDirs = await (0, promises_1.readdir)(projectsDir);
+    }
+    catch {
+        return [];
+    }
+    const results = [];
+    for (const dir of projectDirs) {
+        if (dir.includes(".cockpit"))
+            continue;
+        const dirPath = node_path_1.default.join(projectsDir, dir);
+        let files;
+        try {
+            files = await (0, promises_1.readdir)(dirPath);
+        }
+        catch {
+            continue;
+        }
+        for (const f of files) {
+            if (!f.endsWith(".jsonl"))
+                continue;
+            const filePath = node_path_1.default.join(dirPath, f);
+            try {
+                const s = await (0, promises_1.stat)(filePath);
+                results.push({ filePath, sessionId: f.slice(0, -6), mtimeMs: s.mtimeMs });
+            }
+            catch { }
+        }
+    }
+    results.sort((a, b) => b.mtimeMs - a.mtimeMs);
+    return results;
+}
+async function globalSearch(query, limit, offset = 0) {
+    const MAX_FILES = 500;
+    const MAX_PARSED_BASE = 30;
+    const MAX_PER_FILE = 10;
+    const effectiveLimit = Math.min(limit, 100);
+    const lowerQuery = query.toLowerCase();
+    // When paginating, allow parsing more files to reach the offset
+    const maxParsed = MAX_PARSED_BASE + Math.ceil(offset / MAX_PER_FILE);
+    const files = await listAllTranscriptFiles();
+    const searchFiles = files.slice(0, MAX_FILES);
+    const results = [];
+    let totalFound = 0;
+    let filesParsed = 0;
+    let truncated = false;
+    for (const file of searchFiles) {
+        if (results.length >= effectiveLimit || filesParsed >= maxParsed) {
+            truncated = true;
+            break;
+        }
+        let raw;
+        try {
+            raw = await (0, promises_1.readFile)(file.filePath, "utf-8");
+        }
+        catch {
+            continue;
+        }
+        if (!raw.toLowerCase().includes(lowerQuery))
+            continue;
+        filesParsed++;
+        const lines = raw.split(/\r?\n/).filter((l) => l.trim());
+        const { messages } = parseLines(lines);
+        let cwd = "";
+        let sessionTitle = "";
+        for (let j = 0; j < Math.min(lines.length, 50); j++) {
+            try {
+                const entry = JSON.parse(lines[j]);
+                if (entry.type === "user" && entry.cwd && !cwd)
+                    cwd = entry.cwd;
+                if (entry.type === "user" && entry.message && !sessionTitle) {
+                    const content = entry.message.content;
+                    let candidate = "";
+                    if (typeof content === "string")
+                        candidate = content;
+                    else if (Array.isArray(content)) {
+                        const tb = content.find((b) => b.type === "text" && b.text);
+                        if (tb?.text)
+                            candidate = tb.text;
+                    }
+                    if (candidate && !candidate.startsWith("[") && !candidate.startsWith("<")) {
+                        sessionTitle = candidate.slice(0, 120);
+                    }
+                }
+                if (cwd && sessionTitle)
+                    break;
+            }
+            catch { }
+        }
+        if (!cwd)
+            continue;
+        if (cwd.endsWith(".cockpit/reviews") || cwd.endsWith(".cockpit/jobs"))
+            continue;
+        const dirName = node_path_1.default.basename(cwd) || cwd;
+        let fileResults = 0;
+        for (let i = 0; i < messages.length; i++) {
+            if (fileResults >= MAX_PER_FILE || results.length >= effectiveLimit)
+                break;
+            const msg = messages[i];
+            if (msg.role !== "user" && msg.role !== "assistant")
+                continue;
+            if (i > 0 && messages[i - 1].content === "__compacted__")
+                continue;
+            if (i > 1 && messages[i - 2].content === "__compacted__")
+                continue;
+            let text = "";
+            if (msg.blocks && msg.blocks.length > 0) {
+                text = msg.blocks
+                    .filter((b) => b.type === "text")
+                    .map((b) => b.text)
+                    .join("\n");
+            }
+            if (!text && typeof msg.content === "string") {
+                text = msg.content;
+            }
+            if (!text)
+                continue;
+            const matchIndex = text.toLowerCase().indexOf(lowerQuery);
+            if (matchIndex === -1)
+                continue;
+            totalFound++;
+            fileResults++;
+            if (totalFound <= offset)
+                continue;
+            const previewStart = Math.max(0, matchIndex - 100);
+            const previewEnd = Math.min(text.length, matchIndex + query.length + 100);
+            let preview = text.slice(previewStart, previewEnd);
+            let matchStart = matchIndex - previewStart;
+            if (previewStart > 0) {
+                preview = "..." + preview;
+                matchStart += 3;
+            }
+            if (previewEnd < text.length) {
+                preview = preview + "...";
+            }
+            results.push({
+                sessionId: file.sessionId,
+                sessionName: sessionTitle || "Untitled session",
+                cwd,
+                dirName,
+                messageId: msg.id,
+                role: msg.role,
+                timestamp: msg.timestamp,
+                preview,
+                matchStart,
+                matchLength: query.length,
+                fullContent: text.length > 2000 ? text.slice(0, 2000) + "..." : text,
+            });
+        }
+    }
+    results.sort((a, b) => b.timestamp - a.timestamp);
+    return { results, totalFilesSearched: searchFiles.length, truncated };
+}