agent-companion 0.1.2 → 0.1.4

package/bridge/directIngest.mjs

@@ -2,14 +2,39 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 
-const MAX_FILES_PER_PROVIDER = 24;
-const MAX_SESSION_AGE_MS = 3 * 24 * 60 * 60 * 1000;
+const MAX_FILES_PER_PROVIDER = parseBoundedPositiveInt(
+  process.env.AGENT_DIRECT_MAX_FILES_PER_PROVIDER,
+  120,
+  12,
+  400
+);
+const MAX_DIRECT_SESSIONS = parseBoundedPositiveInt(process.env.AGENT_DIRECT_MAX_SESSIONS, 240, 24, 800);
+const MAX_DIRECT_PENDING_INPUTS = parseBoundedPositiveInt(
+  process.env.AGENT_DIRECT_MAX_PENDING_INPUTS,
+  40,
+  8,
+  120
+);
+const MAX_DIRECT_EVENTS = parseBoundedPositiveInt(process.env.AGENT_DIRECT_MAX_EVENTS, 120, 20, 300);
+const MAX_SESSION_AGE_DAYS = parseBoundedPositiveInt(process.env.AGENT_DIRECT_MAX_SESSION_AGE_DAYS, 365, 3, 3660);
+const MAX_SESSION_AGE_MS = MAX_SESSION_AGE_DAYS * 24 * 60 * 60 * 1000;
 const PENDING_FRESH_WINDOW_MS = 7_500;
 const MAX_CHAT_TURNS_PER_SESSION = 24;
 const MAX_CHAT_TURNS_TOTAL = 160;
+const FILE_SCAN_CACHE_TTL_MS = 10_000;
+const MAX_JSONL_HEAD_BYTES = 32_000;
+const MAX_JSONL_HEAD_LINES = 80;
+const MAX_JSONL_TAIL_BYTES = 1_500_000;
+const MAX_JSONL_TAIL_LINES = 1200;
+const DIRECT_RUNNING_FRESH_WINDOW_SEC = 20;
+const DIRECT_RUNNING_STALE_TIMEOUT_SEC = 180;
 const PENDING_PATTERN =
   /input required|needs input|waiting for input|approval[_\s-]*required|awaiting approval|please approve|approve (?:this|the) plan|should i (?:proceed|implement|execute)|would you like me to (?:proceed|implement|execute)|ready to (?:implement|execute)|want me to (?:implement|execute)|proceed with implementation/i;
 
+const recentFilesCache = new Map();
+const recentJsonlHeadCache = new Map();
+const recentJsonlTailCache = new Map();
+
 export function collectDirectSnapshot(nowMs = Date.now()) {
   const codexSessions = collectCodexSessions(nowMs);
   const claudeSessions = collectClaudeSessions(nowMs);
@@ -25,7 +50,7 @@ export function collectDirectSnapshot(nowMs = Date.now()) {
   }
   const sessions = [...sessionsById.values()]
     .sort((a, b) => b.lastUpdated - a.lastUpdated)
-    .slice(0, 12);
+    .slice(0, MAX_DIRECT_SESSIONS);
 
   const pendingById = new Map();
   for (const pending of [...codexSessions.pendingInputs, ...claudeSessions.pendingInputs]) {
@@ -35,7 +60,7 @@ export function collectDirectSnapshot(nowMs = Date.now()) {
   }
   const pendingInputs = [...pendingById.values()]
     .sort((a, b) => b.requestedAt - a.requestedAt)
-    .slice(0, 12);
+    .slice(0, MAX_DIRECT_PENDING_INPUTS);
 
   const eventById = new Map();
   for (const event of [...codexSessions.events, ...claudeSessions.events]) {
@@ -45,7 +70,7 @@ export function collectDirectSnapshot(nowMs = Date.now()) {
   }
   const events = [...eventById.values()]
     .sort((a, b) => b.timestamp - a.timestamp)
-    .slice(0, 30);
+    .slice(0, MAX_DIRECT_EVENTS);
 
   const chatTurnById = new Map();
   for (const turn of [...codexSessions.chatTurns, ...claudeSessions.chatTurns]) {
@@ -119,21 +144,16 @@ function collectClaudeSessions(nowMs) {
 }
 
 function parseCodexFile(file, nowMs) {
-  let raw = "";
-  try {
-    raw = fs.readFileSync(file, "utf8");
-  } catch {
-    return null;
-  }
-
-  if (!raw.trim()) return null;
-
-  const lines = raw.split(/\r?\n/).filter(Boolean);
-  let sourceSessionId = "";
-  let cwd = "";
+  const codexMeta = readCodexSessionMeta(file);
+  const lines = readRecentJsonlLines(file);
+  if (!lines.length) return null;
+  let sourceSessionId = codexMeta.sessionId;
+  let cwd = codexMeta.cwd;
   let latestTs = 0;
   let firstPrompt = "";
   let latestAgentMessage = "";
+  let pendingAssistantText = "";
+  let pendingAssistantTs = 0;
   let pendingHint = "";
   let pendingHintTs = 0;
   let sawFinalAnswer = false;
@@ -145,6 +165,26 @@ function parseCodexFile(file, nowMs) {
     totalTokens: 0
   };
 
+  const flushPendingAssistant = () => {
+    const text = sanitizeDirectText(pendingAssistantText);
+    if (!text || !shouldIncludeDirectText(text)) {
+      pendingAssistantText = "";
+      pendingAssistantTs = 0;
+      return;
+    }
+
+    appendDirectTurn(chatTurns, {
+      sessionId: "",
+      role: "ASSISTANT",
+      kind: "FINAL_OUTPUT",
+      text,
+      createdAt: pendingAssistantTs || readFileMtimeMs(file, nowMs)
+    });
+    latestAgentMessage = text;
+    pendingAssistantText = "";
+    pendingAssistantTs = 0;
+  };
+
   for (const line of lines) {
     let record;
     try {
@@ -162,8 +202,23 @@ function parseCodexFile(file, nowMs) {
       continue;
     }
 
+    if (record.type === "item.started" && record.item && typeof record.item === "object") {
+      const itemType = String(record.item.type || "").trim().toLowerCase();
+      if (itemType === "command_execution") {
+        appendDirectTurn(chatTurns, {
+          sessionId: "",
+          role: "ASSISTANT",
+          kind: "MESSAGE",
+          text: formatCodexToolCall(record.item),
+          createdAt: ts || readFileMtimeMs(file, nowMs)
+        });
+        continue;
+      }
+    }
+
     if (record.type === "event_msg" && record.payload?.type === "user_message") {
       const message = String(record.payload?.message || "").trim();
+      flushPendingAssistant();
       if (message && !isNoisePrompt(message) && !firstPrompt) firstPrompt = message;
       appendDirectTurn(chatTurns, {
         sessionId: "",
@@ -180,13 +235,11 @@ function parseCodexFile(file, nowMs) {
 
     if (record.type === "event_msg" && record.payload?.type === "agent_message") {
       const message = String(record.payload?.message || "").trim();
-      if (message) latestAgentMessage = message;
-      appendDirectTurn(chatTurns, {
-        sessionId: "",
-        role: "ASSISTANT",
-        text: message,
-        createdAt: ts || readFileMtimeMs(file, nowMs)
-      });
+      if (message) {
+        latestAgentMessage = message;
+        pendingAssistantText = message;
+        pendingAssistantTs = ts || pendingAssistantTs || readFileMtimeMs(file, nowMs);
+      }
       if (PENDING_PATTERN.test(message)) {
         pendingHint = message;
         pendingHintTs = ts || pendingHintTs;
@@ -219,6 +272,7 @@ function parseCodexFile(file, nowMs) {
       const role = record.payload?.role;
       if (role === "user") {
         const text = extractCodexText(record.payload?.content);
+        flushPendingAssistant();
         if (text && !isNoisePrompt(text) && !firstPrompt) firstPrompt = text;
         appendDirectTurn(chatTurns, {
           sessionId: "",
@@ -234,12 +288,8 @@ function parseCodexFile(file, nowMs) {
         const text = extractCodexText(record.payload?.content);
         if (text) {
           latestAgentMessage = text;
-          appendDirectTurn(chatTurns, {
-            sessionId: "",
-            role: "ASSISTANT",
-            text,
-            createdAt: ts || readFileMtimeMs(file, nowMs)
-          });
+          pendingAssistantText = text;
+          pendingAssistantTs = ts || pendingAssistantTs || readFileMtimeMs(file, nowMs);
           if (PENDING_PATTERN.test(text)) {
             pendingHint = text;
             pendingHintTs = ts || pendingHintTs;
@@ -252,24 +302,31 @@ function parseCodexFile(file, nowMs) {
 
   const fallbackId = path.basename(file).replace(/\.jsonl$/i, "");
   const sessionId = `codex:${sourceSessionId || fallbackId}`;
-  const finalizedTurns = finalizeDirectTurns(chatTurns, sessionId);
   const effectiveLastUpdated = latestTs || readFileMtimeMs(file, nowMs);
   const ageSec = Math.max(0, Math.floor((nowMs - effectiveLastUpdated) / 1000));
   const pendingStillActive =
     Boolean(pendingHint) &&
     pendingHintTs > 0 &&
     pendingHintTs >= effectiveLastUpdated - PENDING_FRESH_WINDOW_MS;
+  const hasBufferedAssistant = Boolean(sanitizeDirectText(pendingAssistantText));
 
   const state = deriveState({
     ageSec,
     sawFinalAnswer,
     sawError,
-    hasPendingHint: pendingStillActive
+    hasPendingHint: pendingStillActive,
+    hasBufferedAssistant
   });
 
+  if (sawFinalAnswer) {
+    flushPendingAssistant();
+  }
+
   const title = truncate(firstPrompt || latestAgentMessage || "Codex session", 88);
   const repo = cwd ? path.basename(cwd) : "unknown-repo";
 
+  const finalizedTurns = finalizeDirectTurns(chatTurns, sessionId);
+
   if (!firstPrompt && !latestAgentMessage && finalizedTurns.length === 0) {
     return null;
   }
@@ -290,6 +347,7 @@ function parseCodexFile(file, nowMs) {
     agentType: "CODEX",
     title,
     repo,
+    workspacePath: cwd || "",
     branch: "main",
     state,
     lastUpdated: effectiveLastUpdated,
@@ -334,24 +392,19 @@ function parseCodexFile(file, nowMs) {
 }
 
 function parseClaudeFile(file, nowMs) {
-  let raw = "";
-  try {
-    raw = fs.readFileSync(file, "utf8");
-  } catch {
-    return null;
-  }
-
-  if (!raw.trim()) return null;
-
-  const lines = raw.split(/\r?\n/).filter(Boolean);
+  const lines = readRecentJsonlLines(file);
+  if (!lines.length) return null;
   let sourceSessionId = "";
   let cwd = "";
   let branch = "main";
   let latestTs = 0;
   let firstPrompt = "";
   let latestAssistantText = "";
+  let pendingAssistantText = "";
+  let pendingAssistantTs = 0;
   let pendingHint = "";
   let pendingHintTs = 0;
+  let sawFinalAnswer = false;
   let sawError = false;
   const chatTurns = [];
   let usage = {
@@ -379,6 +432,9 @@ function parseClaudeFile(file, nowMs) {
     branch = record.gitBranch && record.gitBranch !== "HEAD" ? record.gitBranch : branch;
 
     if (record.type === "user") {
+      if (isClaudeMetaUserRecord(record)) {
+        continue;
+      }
       const userText = extractClaudeUserText(record.message);
       if (userText && !firstPrompt) firstPrompt = userText;
       appendDirectTurn(chatTurns, {
@@ -396,18 +452,32 @@ function parseClaudeFile(file, nowMs) {
 
     if (record.type === "assistant") {
       const assistantText = extractClaudeAssistantText(record.message);
-      if (assistantText) latestAssistantText = assistantText;
-      appendDirectTurn(chatTurns, {
-        sessionId: "",
-        role: "ASSISTANT",
-        text: assistantText,
-        createdAt: ts || readFileMtimeMs(file, nowMs)
-      });
-      if (PENDING_PATTERN.test(assistantText)) {
+      const stopReason = normalizeClaudeStopReason(record.message?.stop_reason);
+      if (assistantText) {
+        latestAssistantText = assistantText;
+      }
+      if (assistantText && PENDING_PATTERN.test(assistantText)) {
         pendingHint = assistantText;
         pendingHintTs = ts || pendingHintTs;
       }
       if (/error|failed|exception/i.test(assistantText)) sawError = true;
+      if (stopReason === "end_turn") {
+        sawFinalAnswer = Boolean(assistantText) || sawFinalAnswer;
+        if (assistantText) {
+          appendDirectTurn(chatTurns, {
+            sessionId: "",
+            role: "ASSISTANT",
+            kind: "FINAL_OUTPUT",
+            text: assistantText,
+            createdAt: ts || readFileMtimeMs(file, nowMs)
+          });
+        }
+        pendingAssistantText = "";
+        pendingAssistantTs = 0;
+      } else if (assistantText) {
+        pendingAssistantText = assistantText;
+        pendingAssistantTs = ts || pendingAssistantTs || readFileMtimeMs(file, nowMs);
+      }
 
       const u = record.message?.usage;
       if (u) {
@@ -423,21 +493,24 @@ function parseClaudeFile(file, nowMs) {
 
   const fallbackId = path.basename(file).replace(/\.jsonl$/i, "");
   const sessionId = `claude:${sourceSessionId || fallbackId}`;
-  const finalizedTurns = finalizeDirectTurns(chatTurns, sessionId);
   const effectiveLastUpdated = latestTs || readFileMtimeMs(file, nowMs);
   const ageSec = Math.max(0, Math.floor((nowMs - effectiveLastUpdated) / 1000));
   const pendingStillActive =
     Boolean(pendingHint) &&
     pendingHintTs > 0 &&
     pendingHintTs >= effectiveLastUpdated - PENDING_FRESH_WINDOW_MS;
+  const hasBufferedAssistant = Boolean(sanitizeDirectText(pendingAssistantText));
 
   const state = deriveState({
     ageSec,
-    sawFinalAnswer: ageSec > 25,
+    sawFinalAnswer,
     sawError,
-    hasPendingHint: pendingStillActive
+    hasPendingHint: pendingStillActive,
+    hasBufferedAssistant
   });
 
+  const finalizedTurns = finalizeDirectTurns(chatTurns, sessionId);
+
   if (!firstPrompt && !latestAssistantText && finalizedTurns.length === 0) {
     return null;
   }
@@ -461,6 +534,7 @@ function parseClaudeFile(file, nowMs) {
     agentType: "CLAUDE",
     title,
     repo,
+    workspacePath: cwd || "",
     branch,
     state,
     lastUpdated: effectiveLastUpdated,
@@ -504,11 +578,13 @@ function parseClaudeFile(file, nowMs) {
   return { session, pendingInput, event, chatTurns: finalizedTurns };
 }
 
-function deriveState({ ageSec, sawFinalAnswer, sawError, hasPendingHint }) {
+function deriveState({ ageSec, sawFinalAnswer, sawError, hasPendingHint, hasBufferedAssistant }) {
   if (hasPendingHint) return "WAITING_INPUT";
-  if (sawError && ageSec > 20) return "FAILED";
-  if (ageSec < 20) return "RUNNING";
+  if (sawError && ageSec > DIRECT_RUNNING_FRESH_WINDOW_SEC) return "FAILED";
   if (sawFinalAnswer) return "COMPLETED";
+  if (hasBufferedAssistant && ageSec < DIRECT_RUNNING_STALE_TIMEOUT_SEC) return "RUNNING";
+  if (ageSec < DIRECT_RUNNING_FRESH_WINDOW_SEC) return "RUNNING";
+  if (hasBufferedAssistant) return "FAILED";
   return "COMPLETED";
 }
 
@@ -517,43 +593,73 @@ function extractCodexText(content) {
   for (const item of content) {
     if (typeof item?.text === "string" && item.text.trim()) {
       const text = sanitizeDirectText(item.text);
-      if (!isNoisePrompt(text)) return text;
+      if (shouldIncludeDirectText(text)) return text;
     }
   }
   return "";
 }
 
+function formatCodexToolCall(item) {
+  const rawCommand =
+    typeof item?.command === "string"
+      ? item.command
+      : Array.isArray(item?.command)
+        ? item.command.map((entry) => String(entry || "")).join(" ")
+        : "";
+
+  let command = String(rawCommand || "").replace(/\s+/g, " ").trim();
+  if (command) {
+    command = command.replace(/^\/bin\/(?:zsh|bash|sh)\s+-lc\s+/i, "");
+    command = command.replace(/^['"`]\s*/, "").replace(/\s*['"`]$/, "");
+  }
+  if (command.length > 140) {
+    command = `${command.slice(0, 137)}...`;
+  }
+
+  return command ? `[tool] shell ${command}` : "[tool] shell";
+}
+
 function extractClaudeUserText(message) {
   if (!message) return "";
   if (typeof message.content === "string") {
     const text = sanitizeDirectText(message.content);
-    return isNoisePrompt(text) ? "" : text;
+    return shouldIncludeDirectUserText(text) ? text : "";
   }
   if (!Array.isArray(message.content)) return "";
 
+  const collected = [];
   for (const part of message.content) {
     if (typeof part === "string") {
       const text = sanitizeDirectText(part);
-      if (text && !isNoisePrompt(text)) return text;
+      if (shouldIncludeDirectUserText(text)) {
+        collected.push(text);
+      }
+      continue;
     }
+    const partType = String(part?.type || "").trim().toLowerCase();
+    if (partType && partType !== "text" && partType !== "input_text") continue;
     if (typeof part?.text === "string") {
       const text = sanitizeDirectText(part.text);
-      if (text && !isNoisePrompt(text)) return text;
+      if (shouldIncludeDirectUserText(text)) {
+        collected.push(text);
+      }
     }
     if (typeof part?.content === "string" && part.content.trim()) {
       const text = sanitizeDirectText(part.content);
-      if (text && !isNoisePrompt(text)) return text;
+      if (shouldIncludeDirectUserText(text)) {
+        collected.push(text);
+      }
     }
   }
 
-  return "";
+  return collected.join("\n\n").trim();
 }
 
 function extractClaudeAssistantText(message) {
   if (!message) return "";
   if (typeof message.content === "string") {
     const text = sanitizeDirectText(message.content);
-    return isNoisePrompt(text) ? "" : text;
+    return shouldIncludeDirectAssistantText(text) ? text : "";
   }
   if (!Array.isArray(message.content)) return "";
 
@@ -562,12 +668,12 @@ function extractClaudeAssistantText(message) {
   for (const part of message.content) {
     if (part?.type === "text" && typeof part?.text === "string" && part.text.trim()) {
       const text = sanitizeDirectText(part.text);
-      if (!isNoisePrompt(text)) {
+      if (shouldIncludeDirectAssistantText(text)) {
         collected.push(text);
       }
     } else if (!part?.type && typeof part?.text === "string" && part.text.trim()) {
       const text = sanitizeDirectText(part.text);
-      if (!isNoisePrompt(text)) {
+      if (shouldIncludeDirectAssistantText(text)) {
         collected.push(text);
       }
     }
@@ -576,6 +682,33 @@ function extractClaudeAssistantText(message) {
   return collected.join("\n\n").trim();
 }
 
+function normalizeClaudeStopReason(value) {
+  return String(value || "")
+    .trim()
+    .toLowerCase();
+}
+
+function isClaudeMetaUserRecord(record) {
+  if (!record || typeof record !== "object") return false;
+  if (record.isMeta === true) return true;
+  if (record.sourceToolUseID) return true;
+  if (record.toolUseResult && typeof record.toolUseResult === "object") return true;
+
+  const content = record.message?.content;
+  if (!Array.isArray(content)) return false;
+
+  for (const part of content) {
+    const partType = String(part?.type || "").trim().toLowerCase();
+    const text = String(part?.text || part?.content || "").trim();
+    if (partType === "tool_result") return true;
+    if (/^launching skill:/i.test(text)) return true;
+    if (/^base directory for this skill:/i.test(text)) return true;
+    if (/<command-name>|<command-message>|<command-args>|<local-command-stdout>/i.test(text)) return true;
+  }
+
+  return false;
+}
+
 function safeDateMs(value) {
   const parsed = Date.parse(String(value || ""));
   return Number.isFinite(parsed) ? parsed : 0;
@@ -594,6 +727,33 @@ function readFileMtimeMs(file, fallback = Date.now()) {
   }
 }
 
+function readCodexSessionMeta(file) {
+  const lines = readInitialJsonlLines(file);
+  for (const line of lines) {
+    try {
+      const record = JSON.parse(line);
+      if (record?.type !== "session_meta") continue;
+      return {
+        sessionId: String(record?.payload?.id || "").trim(),
+        cwd: String(record?.payload?.cwd || "").trim()
+      };
+    } catch {
+      // keep scanning
+    }
+  }
+
+  return {
+    sessionId: "",
+    cwd: ""
+  };
+}
+
+function parseBoundedPositiveInt(value, fallback, min, max) {
+  const parsed = Number.parseInt(String(value ?? ""), 10);
+  if (!Number.isFinite(parsed) || parsed < min) return fallback;
+  return Math.min(parsed, max);
+}
+
 function truncate(value, max) {
   const text = String(value || "").trim();
   if (text.length <= max) return text;
@@ -608,21 +768,59 @@ function isNoisePrompt(text) {
   if (raw.includes("Filesystem sandboxing defines")) return true;
   if (raw.includes("AGENT_COMPANION_PERSIST_SERVER_HINT_V1")) return true;
   if (raw.includes("[Request interrupted by user for tool use]")) return true;
+  if (/^launching skill:/i.test(raw.trim())) return true;
+  if (/^base directory for this skill:/i.test(raw.trim())) return true;
+  if (/<command-name>|<command-message>|<command-args>|<local-command-stdout>/i.test(raw)) return true;
+  if (/^\[background-service\]/i.test(raw.trim())) return true;
+  if (/"service"\s*:\s*\{/.test(raw) && /"localhostUrl"\s*:/.test(raw)) return true;
   if (raw === "Answer questions?") return true;
   return false;
 }
 
+function isDirectArtifactText(text) {
+  const raw = String(text || "").trim();
+  if (!raw) return true;
+  if (/^<task-notification>/i.test(raw)) return true;
+  if (/<\/task-notification>\s*$/i.test(raw)) return true;
+  if (/<task-id>|<tool-use-id>|<output-file>|<status>|<summary>/i.test(raw)) return true;
+  if (/^read the output file to retrieve the result:/i.test(raw)) return true;
+  if (/^command running in background with id:/i.test(raw)) return true;
+  if (/^file created successfully at:/i.test(raw)) return true;
+  if (/^traceback \(most recent call last\):/i.test(raw)) return true;
+  if (/^\s*\d+→/.test(raw)) return true;
+  return false;
+}
+
+function shouldIncludeDirectText(text) {
+  return !isNoisePrompt(text) && !isDirectArtifactText(text);
+}
+
+function shouldIncludeDirectUserText(text) {
+  return shouldIncludeDirectText(text);
+}
+
+function shouldIncludeDirectAssistantText(text) {
+  return shouldIncludeDirectText(text);
+}
+
 function appendDirectTurn(turns, input) {
   const text = sanitizeDirectText(input?.text);
-  if (!text || isNoisePrompt(text)) return;
+  if (!text || !shouldIncludeDirectText(text)) return;
 
   const role = input?.role === "ASSISTANT" ? "ASSISTANT" : "USER";
+  const kind =
+    input?.kind === "FINAL_OUTPUT"
+      ? "FINAL_OUTPUT"
+      : input?.kind === "APPROVAL_ACTION"
+        ? "APPROVAL_ACTION"
+        : "MESSAGE";
   const createdAt = safeNumber(input?.createdAt, Date.now());
   const normalized = normalizeComparableText(text);
   const last = turns[turns.length - 1];
   if (
     last &&
     last.role === role &&
+    last.kind === kind &&
     normalizeComparableText(last.text) === normalized &&
     Math.abs(safeNumber(last.createdAt, 0) - createdAt) <= 3_000
   ) {
@@ -632,7 +830,7 @@ function appendDirectTurn(turns, input) {
   turns.push({
     sessionId: input?.sessionId || "",
     role,
-    kind: "MESSAGE",
+    kind,
     text,
     createdAt,
     source: "DIRECT"
@@ -672,6 +870,12 @@ function sanitizeDirectText(value) {
 }
 
 function getRecentJsonlFiles(rootDir, limit) {
+  const now = Date.now();
+  const cached = recentFilesCache.get(rootDir);
+  if (cached && cached.expiresAt > now) {
+    return cached.files.slice(0, limit);
+  }
+
   const records = [];
 
   if (!fs.existsSync(rootDir)) return records;
@@ -708,5 +912,104 @@ function getRecentJsonlFiles(rootDir, limit) {
   }
 
   records.sort((a, b) => b.mtimeMs - a.mtimeMs);
-  return records.slice(0, limit).map((item) => item.file);
+  const files = records.map((item) => item.file);
+  recentFilesCache.set(rootDir, {
+    expiresAt: now + FILE_SCAN_CACHE_TTL_MS,
+    files
+  });
+  return files.slice(0, limit);
+}
+
+function readRecentJsonlLines(file) {
+  let stat;
+  try {
+    stat = fs.statSync(file);
+  } catch {
+    return [];
+  }
+
+  const cached = recentJsonlTailCache.get(file);
+  if (cached && cached.mtimeMs === stat.mtimeMs && cached.size === stat.size) {
+    return cached.lines;
+  }
+
+  const size = safeNumber(stat.size, 0);
+  if (size <= 0) {
+    recentJsonlTailCache.set(file, { mtimeMs: stat.mtimeMs, size, lines: [] });
+    return [];
+  }
+
+  const start = Math.max(0, size - MAX_JSONL_TAIL_BYTES);
+  const length = size - start;
+  let text = "";
+
+  try {
+    const fd = fs.openSync(file, "r");
+    try {
+      const buffer = Buffer.alloc(length);
+      fs.readSync(fd, buffer, 0, length, start);
+      text = buffer.toString("utf8");
+    } finally {
+      fs.closeSync(fd);
+    }
+  } catch {
+    return [];
+  }
+
+  if (start > 0) {
+    const newlineIndex = text.indexOf("\n");
+    text = newlineIndex >= 0 ? text.slice(newlineIndex + 1) : "";
+  }
+
+  const lines = text.split(/\r?\n/).filter(Boolean).slice(-MAX_JSONL_TAIL_LINES);
+  recentJsonlTailCache.set(file, {
+    mtimeMs: stat.mtimeMs,
+    size,
+    lines
+  });
+  return lines;
+}
+
+function readInitialJsonlLines(file) {
+  let stat;
+  try {
+    stat = fs.statSync(file);
+  } catch {
+    return [];
+  }
+
+  const cached = recentJsonlHeadCache.get(file);
+  if (cached && cached.mtimeMs === stat.mtimeMs && cached.size === stat.size) {
+    return cached.lines;
+  }
+
+  const size = safeNumber(stat.size, 0);
+  if (size <= 0) {
+    recentJsonlHeadCache.set(file, { mtimeMs: stat.mtimeMs, size, lines: [] });
+    return [];
+  }
+
+  const length = Math.min(size, MAX_JSONL_HEAD_BYTES);
+  let text = "";
+
+  try {
+    const fd = fs.openSync(file, "r");
+    try {
+      const buffer = Buffer.alloc(length);
+      fs.readSync(fd, buffer, 0, length, 0);
+      text = buffer.toString("utf8");
+    } finally {
+      fs.closeSync(fd);
+    }
+  } catch {
+    return [];
+  }
+
+  const lines = text.split(/\r?\n/).filter(Boolean).slice(0, MAX_JSONL_HEAD_LINES);
+  recentJsonlHeadCache.set(file, {
+    mtimeMs: stat.mtimeMs,
+    size,
+    lines
+  });
+  return lines;
 }