@love-moon/conductor-cli 0.2.16 → 0.2.18

package/src/daemon.js

@@ -8,6 +8,7 @@ import dotenv from "dotenv";
 import yaml from "js-yaml";
 
 import { ConductorWebSocketClient, ConductorConfig, loadConfig, ConfigFileNotFound } from "@love-moon/conductor-sdk";
+import { DaemonLogCollector } from "./log-collector.js";
 
 dotenv.config();
 
@@ -212,6 +213,7 @@ export function startDaemon(config = {}, deps = {}) {
   const createWebSocketClient =
     deps.createWebSocketClient ||
     ((clientConfig, options) => new ConductorWebSocketClient(clientConfig, options));
+  const createLogCollector = deps.createLogCollector || ((backendUrl) => new DaemonLogCollector(backendUrl));
   const PROJECT_PATH_LOOKUP_TIMEOUT_MS = parsePositiveInt(
     process.env.CONDUCTOR_PROJECT_PATH_LOOKUP_TIMEOUT_MS,
     1500,
@@ -228,6 +230,30 @@ export function startDaemon(config = {}, deps = {}) {
     process.env.CONDUCTOR_SHUTDOWN_DISCONNECT_TIMEOUT_MS,
     1000,
   );
+  const DAEMON_WATCHDOG_INTERVAL_MS = parsePositiveInt(
+    process.env.CONDUCTOR_DAEMON_WATCHDOG_INTERVAL_MS,
+    30_000,
+  );
+  const DAEMON_WATCHDOG_STALE_WS_MS = parsePositiveInt(
+    process.env.CONDUCTOR_DAEMON_WATCHDOG_STALE_WS_MS,
+    75_000,
+  );
+  const DAEMON_WATCHDOG_CONNECT_GRACE_MS = parsePositiveInt(
+    process.env.CONDUCTOR_DAEMON_WATCHDOG_CONNECT_GRACE_MS,
+    35_000,
+  );
+  const DAEMON_WATCHDOG_RECONNECT_COOLDOWN_MS = parsePositiveInt(
+    process.env.CONDUCTOR_DAEMON_WATCHDOG_RECONNECT_COOLDOWN_MS,
+    45_000,
+  );
+  const DAEMON_WATCHDOG_HTTP_TIMEOUT_MS = parsePositiveInt(
+    process.env.CONDUCTOR_DAEMON_WATCHDOG_HTTP_TIMEOUT_MS,
+    5_000,
+  );
+  const DAEMON_WATCHDOG_MAX_SELF_HEALS = parsePositiveInt(
+    process.env.CONDUCTOR_DAEMON_WATCHDOG_MAX_SELF_HEALS,
+    3,
+  );
 
   try {
     mkdirSyncFn(WORKSPACE_ROOT, { recursive: true });
@@ -361,18 +387,42 @@ export function startDaemon(config = {}, deps = {}) {
 
   let disconnectedSinceLastConnectedLog = false;
   let didRecoverStaleTasks = false;
+  let daemonShuttingDown = false;
   const activeTaskProcesses = new Map();
   const suppressedExitStatusReports = new Set();
   const seenCommandRequestIds = new Set();
+  let lastConnectedAt = null;
+  let lastPongAt = null;
+  let lastInboundAt = null;
+  let lastSuccessfulHttpAt = null;
+  let lastPresenceCheckAt = null;
+  let lastPresenceConfirmedAt = null;
+  let wsConnected = false;
+  let watchdogLastHealAt = 0;
+  let watchdogHealAttempts = 0;
+  let watchdogProbeInFlight = false;
+  let watchdogLastProbeErrorAt = 0;
+  let watchdogLastPresenceMismatchAt = 0;
+  let watchdogAwaitingHealthySignalAt = null;
+  let watchdogTimer = null;
+  const logCollector = createLogCollector(BACKEND_HTTP);
   const client = createWebSocketClient(sdkConfig, {
     extraHeaders: {
       "x-conductor-host": AGENT_NAME,
       "x-conductor-backends": SUPPORTED_BACKENDS.join(","),
     },
-    onConnected: ({ isReconnect } = { isReconnect: false }) => {
+    onConnected: ({ isReconnect, connectedAt } = { isReconnect: false, connectedAt: Date.now() }) => {
+      wsConnected = true;
+      lastConnectedAt = connectedAt || Date.now();
+      lastPongAt = lastPongAt && lastPongAt > lastConnectedAt ? lastPongAt : lastConnectedAt;
       if (!isReconnect || disconnectedSinceLastConnectedLog) {
         log("Connected to backend");
       }
+      if (watchdogHealAttempts > 0) {
+        watchdogAwaitingHealthySignalAt = lastConnectedAt;
+      } else {
+        watchdogAwaitingHealthySignalAt = null;
+      }
       disconnectedSinceLastConnectedLog = false;
       sendAgentResume(isReconnect).catch((error) => {
         logError(`sendAgentResume failed: ${error?.message || error}`);
@@ -388,8 +438,24 @@ export function startDaemon(config = {}, deps = {}) {
         });
       }
     },
-    onDisconnected: () => {
+    onDisconnected: (event = {}) => {
+      wsConnected = false;
       disconnectedSinceLastConnectedLog = true;
+      if (!daemonShuttingDown) {
+        logError(
+          `[daemon-ws] Disconnected from backend: ${formatDisconnectDiagnostics(event)} (${formatDaemonHealthState({
+            connectedAt: lastConnectedAt,
+            lastPongAt,
+            lastInboundAt,
+            lastSuccessfulHttpAt,
+            lastPresenceConfirmedAt,
+          })})`,
+        );
+      }
+    },
+    onPong: ({ at }) => {
+      lastPongAt = at;
+      markWatchdogHealthy("pong", at);
     },
   });
 
@@ -401,6 +467,165 @@ export function startDaemon(config = {}, deps = {}) {
     logError(`Failed to connect: ${err}`);
   });
 
+  watchdogTimer = setInterval(() => {
+    void runDaemonWatchdog();
+  }, DAEMON_WATCHDOG_INTERVAL_MS);
+  if (typeof watchdogTimer?.unref === "function") {
+    watchdogTimer.unref();
+  }
+
+  function markBackendHttpSuccess(at = Date.now()) {
+    lastSuccessfulHttpAt = at;
+  }
+
+  async function probeAgentPresence() {
+    lastPresenceCheckAt = Date.now();
+    try {
+      const response = await withTimeout(
+        fetchFn(`${BACKEND_HTTP}/api/agents`, {
+          method: "GET",
+          headers: {
+            Authorization: `Bearer ${AGENT_TOKEN}`,
+            Accept: "application/json",
+          },
+        }),
+        DAEMON_WATCHDOG_HTTP_TIMEOUT_MS,
+        "daemon agent presence probe",
+      );
+      if (!response.ok) {
+        return {
+          ok: false,
+          status: response.status,
+          error: `HTTP ${response.status}`,
+        };
+      }
+      const at = Date.now();
+      markBackendHttpSuccess(at);
+      const payload = await response.json();
+      const agents = Array.isArray(payload) ? payload : [];
+      const selfOnline = agents.some((entry) => String(entry?.host || "").trim() === AGENT_NAME);
+      if (selfOnline) {
+        lastPresenceConfirmedAt = at;
+      }
+      return {
+        ok: true,
+        selfOnline,
+        agentCount: agents.length,
+      };
+    } catch (error) {
+      return {
+        ok: false,
+        status: null,
+        error: error?.message || String(error),
+      };
+    }
+  }
+
+  function requestWatchdogSelfHeal(reason, extra = {}) {
+    if (daemonShuttingDown || !wsConnected) {
+      return;
+    }
+    const now = Date.now();
+    if (watchdogLastHealAt && now - watchdogLastHealAt < DAEMON_WATCHDOG_RECONNECT_COOLDOWN_MS) {
+      return;
+    }
+    watchdogLastHealAt = now;
+    watchdogHealAttempts += 1;
+    logError(
+      `[watchdog] ${reason}; restarting daemon websocket (${watchdogHealAttempts}/${DAEMON_WATCHDOG_MAX_SELF_HEALS}) ${formatWatchdogExtra(extra)} (${formatDaemonHealthState({
+        connectedAt: lastConnectedAt,
+        lastPongAt,
+        lastInboundAt,
+        lastSuccessfulHttpAt,
+        lastPresenceConfirmedAt,
+      })})`,
+    );
+    if (watchdogHealAttempts > DAEMON_WATCHDOG_MAX_SELF_HEALS) {
+      daemonShuttingDown = true;
+      logError("[watchdog] Self-heal budget exceeded; exiting daemon for supervisor restart");
+      void requestShutdown("watchdog self-heal budget exceeded")
+        .catch((error) => {
+          logError(`watchdog shutdown failed: ${error?.message || error}`);
+        })
+        .finally(() => {
+          cleanupLock();
+          exitFn(1);
+        });
+      return;
+    }
+    watchdogAwaitingHealthySignalAt = null;
+    wsConnected = false;
+    disconnectedSinceLastConnectedLog = true;
+    if (typeof client.forceReconnect === "function") {
+      Promise.resolve(client.forceReconnect(`watchdog:${reason}`)).catch((error) => {
+        logError(`watchdog forceReconnect failed: ${error?.message || error}`);
+      });
+      return;
+    }
+    Promise.resolve(client.disconnect())
+      .catch((error) => {
+        logError(`watchdog disconnect failed: ${error?.message || error}`);
+      })
+      .finally(() => {
+        client.connect().catch((error) => {
+          logError(`watchdog reconnect failed: ${error?.message || error}`);
+        });
+      });
+  }
+
+  async function runDaemonWatchdog() {
+    if (daemonShuttingDown || !wsConnected || watchdogProbeInFlight) {
+      return;
+    }
+    const startedAt = Date.now();
+    if (!lastConnectedAt || startedAt - lastConnectedAt < DAEMON_WATCHDOG_CONNECT_GRACE_MS) {
+      return;
+    }
+    watchdogProbeInFlight = true;
+    try {
+      const probe = await probeAgentPresence();
+      const now = Date.now();
+      const lastWsHealthAt = Math.max(lastPongAt || 0, lastInboundAt || 0, lastConnectedAt || 0);
+      const staleWs = !lastWsHealthAt || now - lastWsHealthAt > DAEMON_WATCHDOG_STALE_WS_MS;
+
+      if (!probe.ok) {
+        if (now - watchdogLastProbeErrorAt >= DAEMON_WATCHDOG_RECONNECT_COOLDOWN_MS) {
+          watchdogLastProbeErrorAt = now;
+          logError(`[watchdog] agent presence probe failed: ${probe.error}`);
+        }
+        if (staleWs) {
+          requestWatchdogSelfHeal("stale_ws_health", {
+            probeAt: lastPresenceCheckAt,
+            probeStatus: probe.status,
+            probeError: probe.error,
+            lastWsHealthAt,
+            staleForMs: now - lastWsHealthAt,
+          });
+        }
+        return;
+      }
+
+      if (!probe.selfOnline && now - watchdogLastPresenceMismatchAt >= DAEMON_WATCHDOG_RECONNECT_COOLDOWN_MS) {
+        watchdogLastPresenceMismatchAt = now;
+        logError(`[watchdog] agent presence probe did not include current host; skipping self-heal to avoid false positives on non-sticky HTTP/WS deployments (${formatWatchdogExtra({
+          agentCount: probe.agentCount,
+          probeAt: lastPresenceCheckAt,
+        })})`);
+      }
+
+      if (staleWs) {
+        requestWatchdogSelfHeal("stale_ws_health", {
+          agentCount: probe.agentCount,
+          lastWsHealthAt,
+          staleForMs: now - lastWsHealthAt,
+          probeAt: lastPresenceCheckAt,
+        });
+      }
+    } finally {
+      watchdogProbeInFlight = false;
+    }
+  }
+
   async function recoverStaleTasks() {
     try {
       const response = await fetchFn(`${BACKEND_HTTP}/api/tasks`, {
@@ -414,6 +639,7 @@ export function startDaemon(config = {}, deps = {}) {
         logError(`Failed to recover stale tasks: HTTP ${response.status}`);
         return;
       }
+      markBackendHttpSuccess();
 
       const tasks = await response.json();
       if (!Array.isArray(tasks) || tasks.length === 0) {
@@ -445,6 +671,8 @@ export function startDaemon(config = {}, deps = {}) {
           });
           if (!patchResp.ok) {
             logError(`Failed to mark stale task ${taskId} as killed: HTTP ${patchResp.status}`);
+          } else {
+            markBackendHttpSuccess();
           }
         }),
       );
@@ -468,6 +696,7 @@ export function startDaemon(config = {}, deps = {}) {
         logError(`Failed to reconcile tasks: HTTP ${response.status}`);
         return;
       }
+      markBackendHttpSuccess();
       const tasks = await response.json();
       if (!Array.isArray(tasks)) {
         return;
@@ -497,6 +726,7 @@ export function startDaemon(config = {}, deps = {}) {
         });
         if (patchResp.ok) {
           killedCount += 1;
+          markBackendHttpSuccess();
         } else {
           logError(`Failed to reconcile stale task ${taskId}: HTTP ${patchResp.status}`);
         }
@@ -552,6 +782,9 @@ export function startDaemon(config = {}, deps = {}) {
   }
 
   function handleEvent(event) {
+    const receivedAt = Date.now();
+    lastInboundAt = receivedAt;
+    markWatchdogHealthy("inbound", receivedAt);
     if (event.type === "error") {
       const payload = event?.payload && typeof event.payload === "object" ? event.payload : {};
       const planLimitMessage = getPlanLimitMessage(payload);
@@ -574,6 +807,79 @@ export function startDaemon(config = {}, deps = {}) {
     }
     if (event.type === "stop_task") {
       handleStopTask(event.payload);
+      return;
+    }
+    if (event.type === "collect_logs") {
+      void handleCollectLogs(event.payload);
+    }
+  }
+
+  function markWatchdogHealthy(signal, at = Date.now()) {
+    if (!watchdogAwaitingHealthySignalAt || watchdogHealAttempts === 0) {
+      return;
+    }
+    if (at < watchdogAwaitingHealthySignalAt) {
+      return;
+    }
+    log(
+      `[watchdog] Backend websocket healthy again after self-heal via ${signal} (${formatDaemonHealthState({
+        connectedAt: lastConnectedAt,
+        lastPongAt,
+        lastInboundAt,
+        lastSuccessfulHttpAt,
+        lastPresenceConfirmedAt,
+      })})`,
+    );
+    watchdogAwaitingHealthySignalAt = null;
+    watchdogHealAttempts = 0;
+  }
+
+  async function handleCollectLogs(payload) {
+    const requestId = payload?.request_id ? String(payload.request_id).trim() : "";
+    const taskId = payload?.task_id ? String(payload.task_id).trim() : "";
+    const collectedAt = new Date().toISOString();
+
+    if (!requestId || !taskId) {
+      logError(`Invalid collect_logs payload: ${JSON.stringify(payload)}`);
+      return;
+    }
+
+    let result;
+    try {
+      result = await Promise.resolve(
+        logCollector.collect(taskId, {
+          tailLines: payload?.options?.tail_lines,
+          since: payload?.options?.since,
+        }),
+      );
+    } catch (error) {
+      result = {
+        projectPath: null,
+        logPath: null,
+        entries: [],
+        truncated: false,
+        error: `Failed to read log file: ${error?.message || error}`,
+        collectedAt,
+      };
+    }
+
+    try {
+      await client.sendJson({
+        type: "agent_log_collected",
+        payload: {
+          request_id: requestId,
+          task_id: taskId,
+          daemon_host: AGENT_NAME,
+          project_path: result.projectPath,
+          log_path: result.logPath,
+          logs: result.entries,
+          truncated: Boolean(result.truncated),
+          error: result.error,
+          collected_at: result.collectedAt || collectedAt,
+        },
+      });
+    } catch (error) {
+      logError(`Failed to report agent_log_collected for ${taskId}: ${error?.message || error}`);
     }
   }
 
@@ -1004,6 +1310,11 @@ export function startDaemon(config = {}, deps = {}) {
     }
 
     closePromise = (async () => {
+      daemonShuttingDown = true;
+      if (watchdogTimer) {
+        clearInterval(watchdogTimer);
+        watchdogTimer = null;
+      }
       const activeEntries = [...activeTaskProcesses.entries()];
       if (activeEntries.length > 0) {
         log(`Shutdown requested (${reason}); stopping ${activeEntries.length} active task(s)`);
@@ -1118,6 +1429,82 @@ function parsePositiveInt(value, fallback) {
   return fallback;
 }
 
+function formatDisconnectDiagnostics(event) {
+  const parts = [];
+  const reason = typeof event?.reason === "string" && event.reason.trim()
+    ? event.reason.trim()
+    : "unknown";
+  parts.push(`reason=${reason}`);
+  if (Number.isFinite(event?.closeCode)) {
+    parts.push(`close_code=${event.closeCode}`);
+  }
+  if (typeof event?.closeReason === "string" && event.closeReason.trim()) {
+    parts.push(`close_reason=${event.closeReason.trim()}`);
+  }
+  if (typeof event?.socketError === "string" && event.socketError.trim()) {
+    parts.push(`socket_error=${event.socketError.trim()}`);
+  }
+  if (Number.isFinite(event?.missedPongs) && event.missedPongs > 0) {
+    parts.push(`missed_pongs=${event.missedPongs}`);
+  }
+  if (Number.isFinite(event?.lastPingAt)) {
+    parts.push(`last_ping_at=${formatIsoTimestamp(event.lastPingAt)}`);
+  }
+  if (Number.isFinite(event?.lastPongAt)) {
+    parts.push(`last_pong_at=${formatIsoTimestamp(event.lastPongAt)}`);
+  }
+  if (Number.isFinite(event?.lastMessageAt)) {
+    parts.push(`last_message_at=${formatIsoTimestamp(event.lastMessageAt)}`);
+  }
+  return parts.join(" ");
+}
+
+function formatDaemonHealthState({
+  connectedAt,
+  lastPongAt,
+  lastInboundAt,
+  lastSuccessfulHttpAt,
+  lastPresenceConfirmedAt,
+}) {
+  return [
+    `connected_at=${formatIsoTimestamp(connectedAt)}`,
+    `last_pong_at=${formatIsoTimestamp(lastPongAt)}`,
+    `last_inbound_at=${formatIsoTimestamp(lastInboundAt)}`,
+    `last_http_ok_at=${formatIsoTimestamp(lastSuccessfulHttpAt)}`,
+    `last_presence_at=${formatIsoTimestamp(lastPresenceConfirmedAt)}`,
+  ].join(" ");
+}
+
+function formatWatchdogExtra(extra) {
+  const parts = [];
+  if (Number.isFinite(extra?.agentCount)) {
+    parts.push(`agent_count=${extra.agentCount}`);
+  }
+  if (Number.isFinite(extra?.probeStatus)) {
+    parts.push(`probe_status=${extra.probeStatus}`);
+  }
+  if (Number.isFinite(extra?.probeAt)) {
+    parts.push(`probe_at=${formatIsoTimestamp(extra.probeAt)}`);
+  }
+  if (typeof extra?.probeError === "string" && extra.probeError.trim()) {
+    parts.push(`probe_error=${extra.probeError.trim()}`);
+  }
+  if (Number.isFinite(extra?.lastWsHealthAt)) {
+    parts.push(`last_ws_health_at=${formatIsoTimestamp(extra.lastWsHealthAt)}`);
+  }
+  if (Number.isFinite(extra?.staleForMs)) {
+    parts.push(`stale_for_ms=${extra.staleForMs}`);
+  }
+  return parts.length ? parts.join(" ") : "no-extra-diagnostics";
+}
+
+function formatIsoTimestamp(value) {
+  if (!Number.isFinite(value)) {
+    return "never";
+  }
+  return new Date(value).toISOString();
+}
+
 async function withTimeout(promise, timeoutMs, label) {
   let timer = null;
   const timeoutPromise = new Promise((_, reject) => {

package/src/log-collector.js

@@ -0,0 +1,181 @@
+import fs from "node:fs";
+import path from "node:path";
+
+import { SessionDiskStore } from "@love-moon/conductor-sdk";
+
+const DEFAULT_TAIL_LINES = 200;
+const MAX_TAIL_LINES = 500;
+const DEFAULT_TAIL_BYTES = 256 * 1024;
+const MAX_TAIL_BYTES = 1024 * 1024;
+
+function clampPositiveInt(value, fallback, max) {
+  const parsed = Number.parseInt(String(value ?? ""), 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    return fallback;
+  }
+  return Math.min(parsed, max);
+}
+
+function normalizeSince(value) {
+  if (typeof value !== "string" || !value.trim()) {
+    return null;
+  }
+  const timestamp = Date.parse(value);
+  return Number.isFinite(timestamp) ? timestamp : null;
+}
+
+function inferLevel(message) {
+  const normalized = String(message || "").toLowerCase();
+  if (normalized.includes("error") || normalized.includes("failed")) {
+    return "ERROR";
+  }
+  if (normalized.includes("warn")) {
+    return "WARN";
+  }
+  return "INFO";
+}
+
+function parseLogLine(line) {
+  const content = String(line || "").trim();
+  if (!content) {
+    return null;
+  }
+
+  const rfcMatch = content.match(/^\[([^\]]+)\]\s+\[([A-Z]+)\]\s+(.*)$/);
+  if (rfcMatch) {
+    const timestamp = Date.parse(rfcMatch[1]);
+    if (Number.isFinite(timestamp)) {
+      return {
+        timestamp: new Date(timestamp).toISOString(),
+        level: rfcMatch[2],
+        message: rfcMatch[3],
+      };
+    }
+  }
+
+  const conductorMatch = content.match(/^\[([^\]]+?)\s+(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2})\]\s+(.*)$/);
+  if (conductorMatch) {
+    const timestamp = Date.parse(conductorMatch[2]);
+    if (Number.isFinite(timestamp)) {
+      return {
+        timestamp: new Date(timestamp).toISOString(),
+        level: inferLevel(conductorMatch[3]),
+        message: `[${conductorMatch[1]}] ${conductorMatch[3]}`,
+      };
+    }
+  }
+
+  return {
+    timestamp: null,
+    level: inferLevel(content),
+    message: content,
+  };
+}
+
+function readTailText(filePath, maxBytes) {
+  const stats = fs.statSync(filePath);
+  const bytesToRead = Math.min(stats.size, maxBytes);
+  const start = Math.max(0, stats.size - bytesToRead);
+  const buffer = Buffer.alloc(bytesToRead);
+  const fd = fs.openSync(filePath, "r");
+  try {
+    fs.readSync(fd, buffer, 0, bytesToRead, start);
+  } finally {
+    fs.closeSync(fd);
+  }
+
+  let text = buffer.toString("utf8");
+  if (start > 0) {
+    const firstNewline = text.indexOf("\n");
+    text = firstNewline >= 0 ? text.slice(firstNewline + 1) : "";
+  }
+  return {
+    text,
+    truncatedByBytes: start > 0,
+  };
+}
+
+export class DaemonLogCollector {
+  constructor(backendUrl, options = {}) {
+    this.sessionStore = options.sessionStore || SessionDiskStore.forBackendUrl(backendUrl);
+    this.readTailText = options.readTailText || readTailText;
+    this.existsSync = options.existsSync || fs.existsSync;
+  }
+
+  collect(taskId, options = {}) {
+    const normalizedTaskId = String(taskId || "").trim();
+    const collectedAt = new Date().toISOString();
+    if (!normalizedTaskId) {
+      return {
+        projectPath: null,
+        logPath: null,
+        entries: [],
+        truncated: false,
+        error: "task_id is required",
+        collectedAt,
+      };
+    }
+
+    const record = this.sessionStore.findByTaskId(normalizedTaskId);
+    if (!record) {
+      return {
+        projectPath: null,
+        logPath: null,
+        entries: [],
+        truncated: false,
+        error: "Task not found in session store",
+        collectedAt,
+      };
+    }
+
+    const projectPath = path.resolve(record.projectPath);
+    const logPath = path.join(projectPath, "conductor.log");
+    if (!this.existsSync(logPath)) {
+      return {
+        projectPath,
+        logPath,
+        entries: [],
+        truncated: false,
+        error: "Log file not found",
+        collectedAt,
+      };
+    }
+
+    const tailLines = clampPositiveInt(options.tailLines, DEFAULT_TAIL_LINES, MAX_TAIL_LINES);
+    const maxBytes = clampPositiveInt(options.maxBytes, DEFAULT_TAIL_BYTES, MAX_TAIL_BYTES);
+    const sinceMs = normalizeSince(options.since);
+    const { text, truncatedByBytes } = this.readTailText(logPath, maxBytes);
+    let anchorTimestampMs = null;
+    const allEntries = [];
+    for (const line of text.split(/\r?\n/)) {
+      const entry = parseLogLine(line);
+      if (!entry) {
+        continue;
+      }
+      const entryTimestampMs =
+        typeof entry.timestamp === "string" ? Date.parse(entry.timestamp) : anchorTimestampMs;
+      if (typeof entry.timestamp === "string" && Number.isFinite(entryTimestampMs)) {
+        anchorTimestampMs = entryTimestampMs;
+      }
+      if (sinceMs !== null) {
+        if (!Number.isFinite(entryTimestampMs)) {
+          continue;
+        }
+        if (entryTimestampMs < sinceMs) {
+          continue;
+        }
+      }
+      allEntries.push(entry);
+    }
+    const entries = allEntries.slice(-tailLines);
+
+    return {
+      projectPath,
+      logPath,
+      entries,
+      truncated: truncatedByBytes || allEntries.length > entries.length,
+      error: null,
+      collectedAt,
+    };
+  }
+}