@remnic/core 1.1.30 → 9.3.515

package/src/conversation-index/indexer.test.ts

@@ -5,6 +5,7 @@ import path from "node:path";
 import test from "node:test";
 
 import type { ConversationChunk } from "./chunker.js";
+import { cleanupConversationChunks } from "./cleanup.js";
 import { sanitizeSessionKey, writeConversationChunks } from "./indexer.js";
 
 function sampleChunk(overrides: Partial<ConversationChunk> = {}): ConversationChunk {
@@ -27,8 +28,8 @@ function assertInsideRoot(root: string, candidate: string): void {
 }
 
 test("sanitizeSessionKey rejects dot-only path components", () => {
-  assert.equal(sanitizeSessionKey("."), "unknown-session");
-  assert.equal(sanitizeSessionKey(".."), "unknown-session");
+  assert.match(sanitizeSessionKey("."), /^unknown-session-[a-f0-9]{12}$/);
+  assert.match(sanitizeSessionKey(".."), /^unknown-session-[a-f0-9]{12}$/);
   assert.equal(sanitizeSessionKey(""), "unknown-session");
 });
 
@@ -64,7 +65,34 @@ test("writeConversationChunks accepts safe dot-prefixed path components", async
     assert.equal(written.length, 1);
     assertInsideRoot(root, written[0]!);
     assert.equal(path.basename(written[0]!), "..chunk.md");
-    assert.equal(path.basename(path.dirname(path.dirname(written[0]!))), "..abc");
+    assert.match(path.basename(path.dirname(path.dirname(written[0]!))), /^\.\.abc-[a-f0-9]{12}$/);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test("writeConversationChunks keeps distinct raw session keys from overwriting after sanitization", async () => {
+  const root = await mkdtemp(path.join(os.tmpdir(), "remnic-conversation-index-"));
+  try {
+    const written = await writeConversationChunks(root, [
+      sampleChunk({
+        sessionKey: "agent:main",
+        id: "same-id",
+        text: "colon session",
+      }),
+      sampleChunk({
+        sessionKey: "agent_main",
+        id: "same-id",
+        text: "underscore session",
+      }),
+    ]);
+
+    assert.equal(written.length, 2);
+    assert.notEqual(written[0], written[1]);
+    assert.match(path.basename(path.dirname(path.dirname(written[0]!))), /^agent_main-[a-f0-9]{12}$/);
+    assert.match(path.basename(path.dirname(path.dirname(written[1]!))), /^agent_main-[a-f0-9]{12}$/);
+    assert.match(await readFile(written[0]!, "utf-8"), /colon session/);
+    assert.match(await readFile(written[1]!, "utf-8"), /underscore session/);
   } finally {
     await rm(root, { recursive: true, force: true });
   }
@@ -81,6 +109,19 @@ test("writeConversationChunks rejects invalid chunk timestamps before deriving p
       ]),
       /invalid conversation chunk start timestamp/,
     );
+    for (const startTs of [
+      "2026-02-31T00:00:00.000Z",
+      "2026-04-31T00:00:00.000Z",
+    ]) {
+      await assert.rejects(
+        writeConversationChunks(root, [
+          sampleChunk({
+            startTs,
+          }),
+        ]),
+        /invalid conversation chunk start timestamp/,
+      );
+    }
   } finally {
     await rm(root, { recursive: true, force: true });
   }
@@ -127,12 +168,12 @@ test("writeConversationChunks rejects symlinked root ancestors before mkdir", as
 
 test("writeConversationChunks rejects symlinked intermediate directories", async () => {
   const temp = await mkdtemp(path.join(os.tmpdir(), "remnic-conversation-index-"));
-  const root = path.join(temp, "root");
-  const outside = path.join(temp, "outside");
+    const root = path.join(temp, "root");
+    const outside = path.join(temp, "outside");
   try {
     await mkdir(root);
     await mkdir(outside);
-    await symlink(outside, path.join(root, "agent_main"));
+    await symlink(outside, path.join(root, sanitizeSessionKey("agent:main")));
 
     await assert.rejects(
       writeConversationChunks(root, [sampleChunk({ sessionKey: "agent:main" })]),
@@ -145,11 +186,11 @@ test("writeConversationChunks rejects symlinked intermediate directories", async
 
 test("writeConversationChunks rejects symlinked target files", async () => {
   const temp = await mkdtemp(path.join(os.tmpdir(), "remnic-conversation-index-"));
-  const root = path.join(temp, "root");
-  const outside = path.join(temp, "outside.md");
-  const chunk = sampleChunk({ id: "chunk-1" });
+    const root = path.join(temp, "root");
+    const outside = path.join(temp, "outside.md");
+    const chunk = sampleChunk({ id: "chunk-1" });
   try {
-    const dir = path.join(root, "agent_main", "2026-05-17");
+    const dir = path.join(root, sanitizeSessionKey("agent:main"), "2026-05-17");
     await mkdir(dir, { recursive: true });
     await writeFile(outside, "outside", "utf-8");
     await symlink(outside, path.join(dir, "chunk-1.md"));
@@ -162,3 +203,23 @@ test("writeConversationChunks rejects symlinked target files", async () => {
     await rm(temp, { recursive: true, force: true });
   }
 });
+
+test("cleanupConversationChunks rejects symlinked root without deleting target", async () => {
+  const temp = await mkdtemp(path.join(os.tmpdir(), "remnic-conversation-index-"));
+  const outside = path.join(temp, "outside");
+  const root = path.join(temp, "root");
+  try {
+    await mkdir(path.join(outside, "session", "2000-01-01"), { recursive: true });
+    await writeFile(path.join(outside, "session", "2000-01-01", "chunk.md"), "keep", "utf8");
+    await symlink(outside, root);
+
+    await cleanupConversationChunks(root, 1);
+
+    assert.equal(
+      await readFile(path.join(outside, "session", "2000-01-01", "chunk.md"), "utf8"),
+      "keep",
+    );
+  } finally {
+    await rm(temp, { recursive: true, force: true });
+  }
+});

package/src/conversation-index/indexer.ts

@@ -1,5 +1,6 @@
 import { lstat, mkdir, writeFile } from "node:fs/promises";
 import type { Stats } from "node:fs";
+import { createHash } from "node:crypto";
 import path from "node:path";
 import { log } from "../logger.js";
 import type { FaissConversationIndexAdapter } from "./faiss-adapter.js";
@@ -26,7 +27,13 @@ function sanitizePathComponent(
 }
 
 export function sanitizeSessionKey(sessionKey: string): string {
-  return sanitizePathComponent(sessionKey, "unknown-session", { lowercase: true });
+  const raw = typeof sessionKey === "string" && sessionKey.trim().length > 0
+    ? sessionKey.trim()
+    : "";
+  const safe = sanitizePathComponent(raw, "unknown-session", { lowercase: true });
+  if (!raw) return safe;
+  const suffix = `-${createHash("sha256").update(raw).digest("hex").slice(0, 12)}`;
+  return `${safe.slice(0, MAX_PATH_COMPONENT_LENGTH - suffix.length)}${suffix}`;
 }
 
 function sanitizeChunkId(id: string): string {
@@ -34,13 +41,24 @@ function sanitizeChunkId(id: string): string {
 }
 
 function datePathComponent(startTs: string): string {
-  if (typeof startTs !== "string" || !/^\d{4}-\d{2}-\d{2}T/.test(startTs)) {
+  const match = typeof startTs === "string"
+    ? /^(\d{4})-(\d{2})-(\d{2})T/.exec(startTs)
+    : null;
+  if (!match) {
     throw new Error("invalid conversation chunk start timestamp");
   }
   const date = new Date(startTs);
   if (!Number.isFinite(date.getTime())) {
     throw new Error("invalid conversation chunk start timestamp");
   }
+  const [, year, month, day] = match;
+  if (
+    date.getUTCFullYear() !== Number(year) ||
+    date.getUTCMonth() + 1 !== Number(month) ||
+    date.getUTCDate() !== Number(day)
+  ) {
+    throw new Error("invalid conversation chunk start timestamp");
+  }
   return date.toISOString().slice(0, 10);
 }
 
@@ -162,12 +180,13 @@ export interface ConversationChunkRebuildResult {
 export async function upsertConversationChunksFailOpen(
   adapter: FaissConversationIndexAdapter | undefined,
   chunks: ConversationChunk[],
+  options: { retentionCutoffMs?: number } = {},
 ): Promise<ConversationChunkUpsertResult> {
   if (!adapter) {
     return { upserted: 0, skipped: true, reason: "adapter-unavailable" };
   }
   try {
-    const upserted = await adapter.upsertChunks(chunks);
+    const upserted = await adapter.upsertChunks(chunks, options);
     return { upserted, skipped: false };
   } catch (err) {
     log.debug(`conversation index FAISS upsert failed (fail-open): ${err}`);

package/src/cross-namespace-budget.test.ts

@@ -227,6 +227,65 @@ test("gc() evicts buckets whose window has fully expired", () => {
   assert.equal(limiter.bucketCount(), 0);
 });
 
+test("record() normalizes non-finite clocks before mutating limiter state", () => {
+  const limiter = new CrossNamespaceBudget({
+    enabled: true,
+    softLimit: 1,
+    hardLimit: 1,
+    windowMs: 100,
+  });
+
+  const invalidClock = limiter.record("p1", Number.NaN);
+  assert.equal(invalidClock.allowed, true);
+  assert.equal(invalidClock.reason, "allowed-under-soft");
+  assert.equal(invalidClock.count, 1);
+  assert.equal(limiter.bucketCount(), 1);
+
+  const later = limiter.record("p1", 101);
+  assert.equal(later.allowed, true);
+  assert.equal(later.reason, "allowed-under-soft");
+  assert.equal(later.count, 1);
+
+  assert.equal(limiter.gc(250), 1);
+  assert.equal(limiter.bucketCount(), 0);
+});
+
+test("peek() with a non-finite clock is read-only and does not poison state", () => {
+  const limiter = new CrossNamespaceBudget({
+    enabled: true,
+    softLimit: 0,
+    hardLimit: 1,
+    windowMs: 100,
+  });
+
+  const decision = limiter.peek({
+    principal: "p1",
+    principalNamespace: "alice",
+    queryNamespace: "bob",
+    now: Number.NaN,
+  });
+
+  assert.equal(decision.allowed, true);
+  assert.equal(decision.reason, "warn-over-soft");
+  assert.equal(decision.count, 1);
+  assert.equal(limiter.bucketCount(), 0);
+});
+
+test("gc() normalizes non-finite clocks without evicting future-valid state", () => {
+  const limiter = new CrossNamespaceBudget({
+    enabled: true,
+    softLimit: 10,
+    hardLimit: 20,
+    windowMs: 100,
+  });
+
+  limiter.record("p1", 0);
+  assert.equal(limiter.gc(Number.NaN), 0);
+  assert.equal(limiter.bucketCount(), 1);
+  assert.equal(limiter.gc(101), 1);
+  assert.equal(limiter.bucketCount(), 0);
+});
+
 test("bucket is evicted after a denial rolls the only timestamp back", () => {
   const limiter = new CrossNamespaceBudget({
     enabled: true,

package/src/cross-namespace-budget.ts

@@ -132,6 +132,12 @@ function effectiveConfig(
   return out;
 }
 
+function normalizeClock(now: number | undefined): number {
+  if (now === undefined) return Date.now();
+  if (Number.isFinite(now)) return Math.floor(now);
+  return 0;
+}
+
 /**
  * In-process cross-namespace budget limiter. Instantiate once per
  * orchestrator / access-service.
@@ -164,7 +170,8 @@ export class CrossNamespaceBudget {
    * @param now Epoch-ms clock read. Defaults to `Date.now()`; tests pass a
    *   fixed value to step time deterministically.
    */
-  record(principal: string, now: number = Date.now()): BudgetDecision {
+  record(principal: string, now?: number): BudgetDecision {
+    const normalizedNow = normalizeClock(now);
     const { enabled, windowMs, softLimit, hardLimit } = this.config;
     const limit = { softLimit, hardLimit, windowMs };
 
@@ -186,7 +193,7 @@ export class CrossNamespaceBudget {
     }
 
     const bucket = this.buckets.get(principal) ?? { timestamps: [] };
-    const cutoff = now - windowMs;
+    const cutoff = normalizedNow - windowMs;
     // Drop timestamps that slid out of the window.
     while (bucket.timestamps.length > 0 && bucket.timestamps[0]! < cutoff) {
       bucket.timestamps.shift();
@@ -196,7 +203,7 @@ export class CrossNamespaceBudget {
     // that crosses the deny threshold should itself be denied, not the
     // next one. This is what the threat model calls "fail at the Nth,
     // not the (N+1)th".
-    bucket.timestamps.push(now);
+    bucket.timestamps.push(normalizedNow);
     this.buckets.set(principal, bucket);
     const count = bucket.timestamps.length;
 
@@ -275,7 +282,7 @@ export class CrossNamespaceBudget {
     if (typeof principal !== "string" || principal.length === 0) {
       principal = "__anonymous__";
     }
-    const now = args.now ?? Date.now();
+    const now = normalizeClock(args.now);
     const bucket = this.buckets.get(principal) ?? { timestamps: [] };
     const cutoff = now - windowMs;
     let liveCount = 0;
@@ -325,7 +332,7 @@ export class CrossNamespaceBudget {
         },
       };
     }
-    return this.record(args.principal, args.now ?? Date.now());
+    return this.record(args.principal, args.now);
   }
 
   /**
@@ -343,8 +350,9 @@ export class CrossNamespaceBudget {
    * many transient principals. Safe to call at any time; returns the
    * number of buckets evicted.
    */
-  gc(now: number = Date.now()): number {
-    const cutoff = now - this.config.windowMs;
+  gc(now?: number): number {
+    const normalizedNow = normalizeClock(now);
+    const cutoff = normalizedNow - this.config.windowMs;
     let evicted = 0;
     for (const [principal, bucket] of this.buckets.entries()) {
       while (bucket.timestamps.length > 0 && bucket.timestamps[0]! < cutoff) {

package/src/curation/index.ts

@@ -134,6 +134,7 @@ export async function curate(options: CurateOptions): Promise<CurateResult> {
 
   // Determine targets
   const targets = resolveTargets(targetPath);
+  const provenanceRoot = resolveProvenanceRoot(targetPath);
 
   // Load existing memories for dedup/contradiction checks
   const existingMemories = checkDuplicates || checkContradictions
@@ -159,7 +160,7 @@ export async function curate(options: CurateOptions): Promise<CurateResult> {
     const fileStatements = extractStatements(
       content,
       filePath,
-      targetPath,
+      provenanceRoot,
       source,
       sourceFileHash,
       categoryOverride,
@@ -191,14 +192,12 @@ export async function curate(options: CurateOptions): Promise<CurateResult> {
       // Write to memory
       if (write) {
         const writtenPath = writeStatement(stmt, memoryDir);
-        if (writtenPath) {
-          written.push(writtenPath);
-          existingMemories.set(stmt.contentHash, {
-            id: stmt.id,
-            content: stmt.content,
-            category: stmt.category,
-          });
-        }
+        written.push(writtenPath);
+        existingMemories.set(stmt.contentHash, {
+          id: stmt.id,
+          content: stmt.content,
+          category: stmt.category,
+        });
       }
     }
   }
@@ -241,6 +240,12 @@ function resolveTargets(targetPath: string): string[] {
   return results;
 }
 
+function resolveProvenanceRoot(targetPath: string): string {
+  const resolvedTarget = path.resolve(targetPath);
+  const stat = fs.statSync(resolvedTarget);
+  return stat.isFile() ? path.dirname(resolvedTarget) : resolvedTarget;
+}
+
 // ── Statement extraction ─────────────────────────────────────────────────────
 
 function extractStatements(
@@ -254,7 +259,7 @@ function extractStatements(
   entityRef: string | undefined,
   tags: string[],
 ): CuratedStatement[] {
-  const relativePath = path.relative(projectRoot, filePath);
+  const relativePath = path.relative(projectRoot, path.resolve(filePath)) || path.basename(filePath);
   const statements: CuratedStatement[] = [];
   const now = new Date().toISOString();
 
@@ -434,7 +439,7 @@ function loadExistingMemories(memoryDir: string): Map<string, ExistingMemory> {
 
 // ── Writing ──────────────────────────────────────────────────────────────────
 
-function writeStatement(stmt: CuratedStatement, memoryDir: string): string | null {
+function writeStatement(stmt: CuratedStatement, memoryDir: string): string {
   const now = new Date();
   const dateDir = now.toISOString().split("T")[0];
   const categoryDir = getCategoryDir(memoryDir, stmt.category);
@@ -465,12 +470,8 @@ function writeStatement(stmt: CuratedStatement, memoryDir: string): string | nul
 
   const body = `${frontmatter}\n\n${stmt.content}\n`;
 
-  try {
-    fs.writeFileSync(filePath, body);
-    return filePath;
-  } catch {
-    return null;
-  }
+  fs.writeFileSync(filePath, body);
+  return filePath;
 }
 
 // ── Helpers ───────────────────────────────────────────────────────────────────

package/src/dashboard-runtime.test.ts

@@ -0,0 +1,98 @@
+import assert from "node:assert/strict";
+import { mkdtemp, rm } from "node:fs/promises";
+import net from "node:net";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+
+import { GraphDashboardServer } from "./dashboard-runtime.js";
+
+test("dashboard server rejects invalid constructor ports", () => {
+  for (const port of [-1, 3.7, Number.NaN, Number.POSITIVE_INFINITY, 65536]) {
+    assert.throws(
+      () =>
+        new GraphDashboardServer({
+          memoryDir: "/tmp/remnic-dashboard-test",
+          port,
+        }),
+      /dashboard port must be an integer from 0 to 65535/,
+      `port ${String(port)} should be rejected`,
+    );
+  }
+});
+
+test("dashboard server accepts documented ephemeral and max ports", () => {
+  assert.doesNotThrow(
+    () =>
+      new GraphDashboardServer({
+        memoryDir: "/tmp/remnic-dashboard-test",
+        port: 0,
+      }),
+  );
+  assert.doesNotThrow(
+    () =>
+      new GraphDashboardServer({
+        memoryDir: "/tmp/remnic-dashboard-test",
+        port: 65535,
+      }),
+  );
+});
+
+test("dashboard WebSocket upgrade requires configured auth token", async () => {
+  const memoryDir = await mkdtemp(path.join(os.tmpdir(), "remnic-dashboard-"));
+  const server = new GraphDashboardServer({
+    memoryDir,
+    host: "127.0.0.1",
+    port: 0,
+    authToken: "secret-token",
+  });
+  try {
+    const status = await server.start();
+    const unauthorized = await rawWebSocketUpgrade(status.port, "/ws");
+    assert.match(unauthorized, /^HTTP\/1\.1 401 Unauthorized/);
+
+    const authorized = await rawWebSocketUpgrade(
+      status.port,
+      "/ws?token=secret-token",
+    );
+    assert.match(authorized, /^HTTP\/1\.1 101 Switching Protocols/);
+  } finally {
+    await server.stop();
+    await rm(memoryDir, { recursive: true, force: true });
+  }
+});
+
+async function rawWebSocketUpgrade(port: number, requestPath: string): Promise<string> {
+  return await new Promise((resolve, reject) => {
+    const websocketKey = Buffer.from("remnic-test-key!").toString("base64");
+    const socket = net.createConnection({ host: "127.0.0.1", port }, () => {
+      socket.write(
+        [
+          `GET ${requestPath} HTTP/1.1`,
+          `Host: 127.0.0.1:${port}`,
+          "Upgrade: websocket",
+          "Connection: Upgrade",
+          `Sec-WebSocket-Key: ${websocketKey}`,
+          "Sec-WebSocket-Version: 13",
+          `Origin: http://127.0.0.1:${port}`,
+          "",
+          "",
+        ].join("\r\n"),
+      );
+    });
+    let data = "";
+    socket.setEncoding("utf8");
+    socket.on("data", (chunk) => {
+      data += chunk;
+      if (data.includes("\r\n\r\n")) {
+        socket.destroy();
+        resolve(data);
+      }
+    });
+    socket.on("error", reject);
+    socket.setTimeout(2000, () => {
+      socket.destroy();
+      reject(new Error("timed out waiting for websocket upgrade response"));
+    });
+  });
+}