@remnic/core 1.1.31 → 9.3.516

package/src/lcm/engine.ts

@@ -23,15 +23,20 @@ export interface LcmEngineConfig {
   messagePartsRecallMaxResults: number;
 }
 
+function positiveInteger(value: unknown, fallback: number, min = 1): number {
+  if (typeof value !== "number" || !Number.isFinite(value)) return fallback;
+  return Math.max(min, Math.floor(value));
+}
+
 export function extractLcmConfig(cfg: PluginConfig): LcmEngineConfig {
   return {
     enabled: (cfg as any).lcmEnabled === true,
-    leafBatchSize: (cfg as any).lcmLeafBatchSize ?? 8,
-    rollupFanIn: (cfg as any).lcmRollupFanIn ?? 4,
-    freshTailTurns: (cfg as any).lcmFreshTailTurns ?? 16,
-    maxDepth: (cfg as any).lcmMaxDepth ?? 5,
-    deterministicMaxTokens: (cfg as any).lcmDeterministicMaxTokens ?? 512,
-    archiveRetentionDays: (cfg as any).lcmArchiveRetentionDays ?? 90,
+    leafBatchSize: positiveInteger((cfg as any).lcmLeafBatchSize, 8),
+    rollupFanIn: positiveInteger((cfg as any).lcmRollupFanIn, 4, 2),
+    freshTailTurns: positiveInteger((cfg as any).lcmFreshTailTurns, 16),
+    maxDepth: positiveInteger((cfg as any).lcmMaxDepth, 5),
+    deterministicMaxTokens: positiveInteger((cfg as any).lcmDeterministicMaxTokens, 512),
+    archiveRetentionDays: positiveInteger((cfg as any).lcmArchiveRetentionDays, 90, 0),
     recallBudgetShare: (cfg as any).lcmRecallBudgetShare ?? 0.15,
     observeConcurrency:
       typeof (cfg as any).lcmObserveConcurrency === "number" &&
@@ -377,6 +382,7 @@ export class LcmEngine {
     const normalizedSessionId = normalizeLcmSessionId(sessionId);
     if (!normalizedSessionId) return;
     await this.ensureInitialized();
+    await this.waitForSessionObserveIdle(normalizedSessionId);
 
     try {
       await this.summarizer!.summarizeIncremental(normalizedSessionId);
@@ -395,6 +401,7 @@ export class LcmEngine {
     const normalizedSessionId = normalizeLcmSessionId(sessionId);
     if (!normalizedSessionId) return;
     await this.ensureInitialized();
+    await this.waitForSessionObserveIdle(normalizedSessionId);
 
     const maxTurn = this.archive!.getMaxTurnIndex(normalizedSessionId);
 
@@ -425,6 +432,7 @@ export class LcmEngine {
     query: string,
     limit: number,
     sessionId?: string,
+    sessionPrefix?: string,
   ): Promise<
     Array<{
       turn_index: number;
@@ -436,8 +444,10 @@ export class LcmEngine {
     if (!this.config.enabled) return [];
     const normalizedSessionId = normalizeOptionalLcmSessionId(sessionId);
     if (sessionId !== undefined && !normalizedSessionId) return [];
+    const normalizedSessionPrefix = normalizeOptionalLcmSessionId(sessionPrefix);
+    if (sessionPrefix !== undefined && !normalizedSessionPrefix) return [];
     await this.ensureInitialized();
-    return this.archive!.search(query, limit, normalizedSessionId);
+    return this.archive!.search(query, limit, normalizedSessionId, normalizedSessionPrefix);
   }
 
   /** Search via FTS returning full message content (not snippets). */
@@ -445,6 +455,7 @@ export class LcmEngine {
     query: string,
     limit: number,
     sessionId?: string,
+    sessionPrefix?: string,
   ): Promise<
     Array<{
       id: number;
@@ -458,8 +469,16 @@ export class LcmEngine {
     if (!this.config.enabled) return [];
     const normalizedSessionId = normalizeOptionalLcmSessionId(sessionId);
     if (sessionId !== undefined && !normalizedSessionId) return [];
+    const normalizedSessionPrefix = normalizeOptionalLcmSessionId(sessionPrefix);
+    if (sessionPrefix !== undefined && !normalizedSessionPrefix) return [];
     await this.ensureInitialized();
-    return this.archive!.searchWithContent(query, limit, normalizedSessionId);
+    return this.archive!.searchWithContent(
+      query,
+      limit,
+      normalizedSessionId,
+      1000,
+      normalizedSessionPrefix,
+    );
   }
 
   /** Get a compressed summary of a turn range. */

package/src/lcm/recall.ts

@@ -75,9 +75,11 @@ function selectBestCoverage(
   fromTurn: number,
   toTurn: number,
 ): SummaryNode[] {
-  // Filter to nodes that overlap with the requested range
+  // Filter to nodes fully contained in the requested range. Straddling nodes
+  // would duplicate protected fresh-tail turns while still emitting their full
+  // summary text and range label.
   const candidates = allNodes.filter(
-    (n) => n.msg_start <= toTurn && n.msg_end >= fromTurn,
+    (n) => n.msg_start >= fromTurn && n.msg_end <= toTurn,
   );
 
   if (candidates.length === 0) return [];
@@ -89,15 +91,13 @@ function selectBestCoverage(
   });
 
   // Greedily select non-overlapping nodes, preferring deeper coverage.
-  // Clamp msg_end to toTurn to prevent deep nodes from extending
-  // past the requested range (e.g., into the fresh tail region).
   const selected: SummaryNode[] = [];
   let coveredUpTo = fromTurn - 1;
 
   for (const node of candidates) {
     if (node.msg_start > coveredUpTo) {
       selected.push(node);
-      coveredUpTo = Math.min(node.msg_end, toTurn);
+      coveredUpTo = node.msg_end;
       if (coveredUpTo >= toTurn) break;
     }
   }

package/src/lcm-engine.test.ts

@@ -4,7 +4,7 @@ import os from "node:os";
 import path from "node:path";
 import test from "node:test";
 
-import { LcmEngine } from "./lcm/engine.js";
+import { extractLcmConfig, LcmEngine } from "./lcm/engine.js";
 import { openLcmDatabase } from "./lcm/schema.js";
 import type { PluginConfig } from "./types.js";
 
@@ -132,6 +132,23 @@ function deferred<T = void>() {
   return { promise, resolve, reject };
 }
 
+test("LCM config clamps invalid batch sizes away from non-progressing values", () => {
+  const cfg = extractLcmConfig({
+    ...createPluginConfig("/tmp/remnic-lcm-config-test"),
+    lcmLeafBatchSize: 0,
+    lcmRollupFanIn: 0,
+    lcmFreshTailTurns: -2,
+    lcmMaxDepth: Number.NaN,
+    lcmDeterministicMaxTokens: -1,
+  } as unknown as PluginConfig);
+
+  assert.equal(cfg.leafBatchSize, 1);
+  assert.equal(cfg.rollupFanIn, 2);
+  assert.equal(cfg.freshTailTurns, 1);
+  assert.equal(cfg.maxDepth, 5);
+  assert.equal(cfg.deterministicMaxTokens, 1);
+});
+
 test("LCM deterministically compresses mechanical telemetry without calling the summarizer", async () => {
   const memoryDir = await mkdtemp(
     path.join(os.tmpdir(), "engram-lcm-telemetry-prefilter-"),
@@ -412,6 +429,75 @@ test("waitForSessionObserveIdle resolves once the target session drains even if
   }
 });
 
+test("pre-compaction lifecycle waits for queued observe work before summarizing and recording", async () => {
+  const memoryDir = await mkdtemp(
+    path.join(os.tmpdir(), "engram-lcm-compaction-observe-order-"),
+  );
+  const summarizeStarted = deferred<void>();
+  const releaseSummarize = deferred<void>();
+
+  try {
+    const engine = new LcmEngine(createPluginConfig(memoryDir), async () => {
+      summarizeStarted.resolve();
+      await releaseSummarize.promise;
+      return "summary";
+    });
+
+    await engine.ensureInitialized();
+    engine.enqueueObserveMessages("session-compact", [
+      { role: "user", content: "queued boundary marker" },
+    ]);
+
+    let flushResolved = false;
+    let recordResolved = false;
+    const flushPromise = engine.preCompactionFlush("session-compact").then(() => {
+      flushResolved = true;
+    });
+    const recordPromise = engine
+      .recordCompaction("session-compact", 100, 50)
+      .then(() => {
+        recordResolved = true;
+      });
+
+    await summarizeStarted.promise;
+    await Promise.resolve();
+
+    assert.equal(flushResolved, false);
+    assert.equal(recordResolved, false);
+
+    releaseSummarize.resolve();
+    await Promise.all([flushPromise, recordPromise]);
+
+    const archived = await engine.searchContextFull(
+      "queued boundary",
+      10,
+      "session-compact",
+    );
+    assert.equal(archived.length, 1);
+
+    const db = openLcmDatabase(memoryDir);
+    try {
+      const row = db
+        .prepare(
+          "SELECT msg_before, tokens_before, tokens_after FROM lcm_compaction_events WHERE session_id = ?",
+        )
+        .get("session-compact") as {
+          msg_before: number;
+          tokens_before: number;
+          tokens_after: number;
+        };
+      assert.equal(row.msg_before, 0);
+      assert.equal(row.tokens_before, 100);
+      assert.equal(row.tokens_after, 50);
+    } finally {
+      db.close();
+    }
+  } finally {
+    releaseSummarize.resolve();
+    await rm(memoryDir, { recursive: true, force: true });
+  }
+});
+
 test("LCM normalizes session IDs across observe, stats, and clear", async () => {
   const memoryDir = await mkdtemp(
     path.join(os.tmpdir(), "engram-lcm-session-normalize-"),

package/src/lcm-recall.test.ts

@@ -0,0 +1,71 @@
+import assert from "node:assert/strict";
+import { mkdtemp, rm } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+
+import { LcmArchive } from "./lcm/archive.js";
+import { LcmDag } from "./lcm/dag.js";
+import { assembleCompressedHistory } from "./lcm/recall.js";
+import { ensureLcmStateDir, openLcmDatabase } from "./lcm/schema.js";
+
+test("assembleCompressedHistory excludes old summaries that straddle the fresh tail", async () => {
+  const memoryDir = await mkdtemp(path.join(os.tmpdir(), "engram-lcm-recall-"));
+  await ensureLcmStateDir(memoryDir);
+  const db = openLcmDatabase(memoryDir);
+
+  try {
+    const archive = new LcmArchive(db);
+    const dag = new LcmDag(db);
+    const sessionId = "session-1";
+
+    for (let turn = 0; turn < 32; turn += 1) {
+      archive.appendMessage(sessionId, turn, "user", `turn ${turn}`);
+    }
+
+    for (const [start, end] of [
+      [0, 7],
+      [8, 15],
+      [16, 23],
+      [24, 31],
+    ] as const) {
+      dag.insertNode({
+        id: `leaf-${start}-${end}`,
+        session_id: sessionId,
+        depth: 0,
+        parent_id: null,
+        summary_text: `leaf summary ${start}-${end}`,
+        token_count: 1,
+        msg_start: start,
+        msg_end: end,
+        escalation: 0,
+      });
+    }
+
+    dag.insertNode({
+      id: "parent-0-31",
+      session_id: sessionId,
+      depth: 1,
+      parent_id: null,
+      summary_text: "parent summary 0-31 should not appear",
+      token_count: 1,
+      msg_start: 0,
+      msg_end: 31,
+      escalation: 0,
+    });
+
+    const section = assembleCompressedHistory(dag, archive, sessionId, {
+      freshTailTurns: 16,
+      budgetChars: 10_000,
+    });
+
+    assert.doesNotMatch(section, /parent summary 0-31/);
+    assert.match(section, /leaf summary 0-7/);
+    assert.match(section, /leaf summary 8-15/);
+    assert.match(section, /leaf summary 16-23/);
+    assert.match(section, /leaf summary 24-31/);
+  } finally {
+    db.close();
+    await rm(memoryDir, { recursive: true, force: true });
+  }
+});

package/src/live-connectors-runner.ts

@@ -15,7 +15,9 @@ import {
   GOOGLE_DRIVE_DEFAULT_POLL_INTERVAL_MS,
   NOTION_CONNECTOR_ID,
   NOTION_DEFAULT_POLL_INTERVAL_MS,
+  ConnectorStateLockLostError,
   readConnectorState,
+  withConnectorStateLock,
   writeConnectorState,
   validateGitHubConfig,
   validateGmailConfig,
@@ -210,48 +212,75 @@ export async function runLiveConnectorsOnce(options: {
     let lastStateWrittenAt: Date | undefined;
     try {
       const connector = definition.createConnector();
-      runResult = await runConnectorPollOnce({
-        connectorId: definition.id,
-        priorState: state,
-        syncFn: (cursor: ConnectorCursor | null) =>
-          connector.syncIncremental({
-            cursor,
-            config: validatedConfig,
-            abortSignal: options.abortSignal,
-          }),
-        ingestFn: options.ingestDocuments,
-        writeCursorFn: (writeState) => {
-          const writeAt = resolveNow(options.now);
-          return writeConnectorState(options.memoryDir, definition.id, {
-            id: definition.id,
-            cursor: writeState.cursor,
-            lastSyncAt: writeAt.toISOString(),
-            lastSyncStatus: writeState.lastSyncStatus,
-            ...(writeState.lastSyncError !== undefined
-              ? { lastSyncError: writeState.lastSyncError }
-              : {}),
-            totalDocsImported: writeState.totalDocsImported,
-          }).then(() => {
-            lastStateWrittenAt = writeAt;
-          });
-        },
+      runResult = await withConnectorStateLock(options.memoryDir, definition.id, async (lockSignal) => {
+        const pollAbortSignal = combineAbortSignals(options.abortSignal, lockSignal);
+        const lockedState = await readConnectorState(options.memoryDir, definition.id);
+        if (!force && !isConnectorDue(lockedState, definition.pollIntervalMs, checkAt)) {
+          return { docsImported: 0 };
+        }
+        state = lockedState;
+        return runConnectorPollOnce({
+          connectorId: definition.id,
+          priorState: lockedState,
+          syncFn: (cursor: ConnectorCursor | null) =>
+            connector.syncIncremental({
+              cursor,
+              config: validatedConfig,
+              abortSignal: pollAbortSignal,
+            }),
+          ingestFn: async (docs) => {
+            throwIfAborted(pollAbortSignal);
+            await options.ingestDocuments(docs);
+            throwIfAborted(pollAbortSignal);
+          },
+          writeCursorFn: (writeState) => {
+            throwIfAborted(pollAbortSignal);
+            const writeAt = resolveNow(options.now);
+            return writeConnectorState(options.memoryDir, definition.id, {
+              id: definition.id,
+              cursor: writeState.cursor,
+              lastSyncAt: writeAt.toISOString(),
+              lastSyncStatus: writeState.lastSyncStatus,
+              ...(writeState.lastSyncError !== undefined
+                ? { lastSyncError: writeState.lastSyncError }
+                : {}),
+              totalDocsImported: writeState.totalDocsImported,
+            }).then(() => {
+              lastStateWrittenAt = writeAt;
+            });
+          },
+        });
       });
+      if (
+        runResult.docsImported === 0 &&
+        runResult.error === undefined &&
+        runResult.stateWriteError === undefined &&
+        lastStateWrittenAt === undefined
+      ) {
+        const lockedState = await readConnectorState(options.memoryDir, definition.id);
+        if (!force && !isConnectorDue(lockedState, definition.pollIntervalMs, checkAt)) {
+          results.push(skipResult(definition, lockedState, "not_due"));
+          continue;
+        }
+      }
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
       let stateWriteError: string | undefined;
       let writtenErrorState: ConnectorState | undefined;
       const errorAt = resolveNow(options.now);
-      try {
-        writtenErrorState = await writeConnectorErrorState({
-          memoryDir: options.memoryDir,
-          connectorId: definition.id,
-          state,
-          error: message,
-          now: errorAt,
-        });
-      } catch (writeErr) {
-        stateWriteError =
-          writeErr instanceof Error ? writeErr.message : String(writeErr);
+      if (!(err instanceof ConnectorStateLockLostError)) {
+        try {
+          writtenErrorState = await writeConnectorErrorState({
+            memoryDir: options.memoryDir,
+            connectorId: definition.id,
+            state,
+            error: message,
+            now: errorAt,
+          });
+        } catch (writeErr) {
+          stateWriteError =
+            writeErr instanceof Error ? writeErr.message : String(writeErr);
+        }
       }
       const reportedState = writtenErrorState ?? state;
       results.push({
@@ -367,6 +396,41 @@ function runItemFromResult(
   };
 }
 
+function combineAbortSignals(...signals: Array<AbortSignal | undefined>): AbortSignal | undefined {
+  const activeSignals = signals.filter((signal): signal is AbortSignal => signal !== undefined);
+  if (activeSignals.length === 0) return undefined;
+  if (activeSignals.length === 1) return activeSignals[0];
+  const abortSignalAny = (AbortSignal as typeof AbortSignal & {
+    any?: (signals: AbortSignal[]) => AbortSignal;
+  }).any;
+  if (abortSignalAny !== undefined) {
+    return abortSignalAny(activeSignals);
+  }
+  const controller = new AbortController();
+  const abort = (signal: AbortSignal): void => {
+    if (!controller.signal.aborted) {
+      controller.abort(signal.reason);
+    }
+  };
+  for (const signal of activeSignals) {
+    if (signal.aborted) {
+      abort(signal);
+      break;
+    }
+    signal.addEventListener("abort", () => abort(signal), { once: true });
+  }
+  return controller.signal;
+}
+
+function throwIfAborted(signal: AbortSignal | undefined): void {
+  if (signal?.aborted !== true) return;
+  const reason = signal.reason;
+  if (reason instanceof Error) {
+    throw reason;
+  }
+  throw new Error(reason === undefined ? "operation aborted" : String(reason));
+}
+
 async function writeConnectorErrorState(options: {
   memoryDir: string;
   connectorId: string;

package/src/maintenance/archive-observations.ts

@@ -1,5 +1,5 @@
 import path from "node:path";
-import { mkdir, readdir, readFile, unlink, writeFile } from "node:fs/promises";
+import { lstat, mkdir, readdir, readFile, realpath, unlink, writeFile } from "node:fs/promises";
 
 const DATE_FILE_PATTERN = /^(\d{4})-(\d{2})-(\d{2})\.(jsonl|md)$/;
 
@@ -75,17 +75,36 @@ async function collectArchiveCandidates(
 ): Promise<CandidateFile[]> {
   const roots = ["transcripts", path.join("state", "tool-usage"), path.join("summaries", "hourly")];
   const out: CandidateFile[] = [];
+  const memoryRoot = path.resolve(memoryDir);
+  const memoryRealRoot = await realpath(memoryRoot).catch(() => memoryRoot);
 
   for (const relRoot of roots) {
-    const absRoot = path.join(memoryDir, relRoot);
+    const absRoot = path.resolve(memoryRoot, relRoot);
+    const rootInfo = await lstat(absRoot).catch(() => null);
+    if (!rootInfo?.isDirectory() || rootInfo.isSymbolicLink()) continue;
+    const absRootReal = await realpath(absRoot).catch(() => null);
+    if (absRootReal === null) continue;
+    const rootRelative = path.relative(memoryRealRoot, absRootReal);
+    if (rootRelative === ".." || rootRelative.startsWith(`..${path.sep}`) || path.isAbsolute(rootRelative)) {
+      continue;
+    }
     const files = await listFilesRecursive(absRoot);
     for (const fileRel of files) {
       const filename = path.basename(fileRel);
       const parsedDate = extractDateFromFilename(filename);
       if (!parsedDate) continue;
       if (parsedDate.getTime() >= cutoffTimeMs) continue;
+      const absolutePath = path.resolve(absRoot, fileRel);
+      const relativeToMemory = path.relative(memoryRoot, absolutePath);
+      if (
+        relativeToMemory === ".." ||
+        relativeToMemory.startsWith(`..${path.sep}`) ||
+        path.isAbsolute(relativeToMemory)
+      ) {
+        continue;
+      }
       out.push({
-        absolutePath: path.join(absRoot, fileRel),
+        absolutePath,
         relativePath: path.join(relRoot, fileRel),
       });
     }
@@ -124,6 +143,8 @@ export async function archiveObservations(
       const archivePath = path.join(archiveRoot, candidate.relativePath);
       const archiveDir = path.dirname(archivePath);
       await mkdir(archiveDir, { recursive: true });
+      const candidateInfo = await lstat(candidate.absolutePath).catch(() => null);
+      if (!candidateInfo?.isFile() || candidateInfo.isSymbolicLink()) continue;
       const raw = await readFile(candidate.absolutePath);
       await writeFile(archivePath, raw);
       await unlink(candidate.absolutePath);

package/src/maintenance/atomic-file.ts

@@ -0,0 +1,85 @@
+import path from "node:path";
+import { copyFile, mkdir, open, rename, rm, stat } from "node:fs/promises";
+
+async function syncDirectory(dir: string): Promise<void> {
+  let handle: Awaited<ReturnType<typeof open>> | undefined;
+  try {
+    handle = await open(dir, "r");
+    await handle.sync();
+  } catch {
+    // Directory fsync is best-effort across platforms and filesystems.
+  } finally {
+    await handle?.close().catch(() => undefined);
+  }
+}
+
+function tempPathFor(outputPath: string): string {
+  const suffix = `${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2)}`;
+  return path.join(path.dirname(outputPath), `.${path.basename(outputPath)}.${suffix}.tmp`);
+}
+
+export async function copyExistingFileToBackup(
+  sourcePath: string,
+  backupPath: string,
+): Promise<string | undefined> {
+  try {
+    await stat(sourcePath);
+  } catch (err) {
+    if ((err as NodeJS.ErrnoException).code === "ENOENT") return undefined;
+    throw err;
+  }
+
+  await mkdir(path.dirname(backupPath), { recursive: true });
+  await copyFile(sourcePath, backupPath);
+  return backupPath;
+}
+
+export async function writeFileAtomically(
+  outputPath: string,
+  content: string,
+  backupPath?: string,
+): Promise<string | undefined> {
+  const dir = path.dirname(outputPath);
+  await mkdir(dir, { recursive: true });
+  const tempPath = tempPathFor(outputPath);
+  let handle: Awaited<ReturnType<typeof open>> | undefined;
+  let resolvedBackupPath: string | undefined;
+  try {
+    handle = await open(tempPath, "w");
+    await handle.writeFile(content, "utf-8");
+    await handle.sync();
+    await handle.close();
+    handle = undefined;
+
+    if (backupPath) {
+      resolvedBackupPath = await copyExistingFileToBackup(outputPath, backupPath);
+    }
+    await rename(tempPath, outputPath);
+    await syncDirectory(dir);
+    return resolvedBackupPath;
+  } catch (err) {
+    await handle?.close().catch(() => undefined);
+    await rm(tempPath, { force: true }).catch(() => undefined);
+    throw err;
+  }
+}
+
+export async function commitPreparedFileAtomically(
+  tempPath: string,
+  outputPath: string,
+  backupPath?: string,
+): Promise<string | undefined> {
+  const dir = path.dirname(outputPath);
+  let resolvedBackupPath: string | undefined;
+  try {
+    if (backupPath) {
+      resolvedBackupPath = await copyExistingFileToBackup(outputPath, backupPath);
+    }
+    await rename(tempPath, outputPath);
+    await syncDirectory(dir);
+    return resolvedBackupPath;
+  } catch (err) {
+    await rm(tempPath, { force: true }).catch(() => undefined);
+    throw err;
+  }
+}

package/src/maintenance/dreams-ledger.ts

@@ -346,18 +346,25 @@ export async function runDreamsPhase(
           // No ledger yet — zero items.
         }
         const lines = raw.split("\n").filter((l) => l.trim().length > 0);
-        const cutoff = Date.now() - 24 * 60 * 60 * 1000;
+        const nowMs = Date.now();
+        const cutoff = nowMs - 24 * 60 * 60 * 1000;
         itemsProcessed = lines.filter((line) => {
           try {
-            const obj = JSON.parse(line) as { timestamp?: string; ts?: string };
-            const timestamp = typeof obj.ts === "string"
-              ? obj.ts
-              : typeof obj.timestamp === "string"
-                ? obj.timestamp
-                : null;
+            const obj = JSON.parse(line) as {
+              hour?: string;
+              timestamp?: string;
+              ts?: string;
+            };
+            const timestamp = typeof obj.hour === "string"
+              ? obj.hour
+              : typeof obj.ts === "string"
+                ? obj.ts
+                : typeof obj.timestamp === "string"
+                  ? obj.timestamp
+                  : null;
             if (!timestamp) return false;
             const ms = Date.parse(timestamp);
-            return Number.isFinite(ms) && ms >= cutoff;
+            return Number.isFinite(ms) && ms >= cutoff && ms < nowMs;
           } catch {
             return false;
           }