@remnic/core 9.3.705 → 9.3.707

package/src/extraction-eventtime-wiring.test.ts

@@ -0,0 +1,269 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import os from "node:os";
+import path from "node:path";
+import { mkdtemp, rm } from "node:fs/promises";
+
+import { resolveFactEventTime } from "./event-time.js";
+import { ExtractionEngine } from "./extraction.js";
+import { ExtractedFactSchema } from "./schemas.js";
+import { StorageManager } from "./storage.js";
+
+/**
+ * Issue #1578 PR 2 — extraction event-time wiring.
+ *
+ * Proves three contracts:
+ *  1. resolveFactEventTime anchors to the SOURCE TURN timestamp, never
+ *     wall-clock — replay/import of an old transcript yields old-era event
+ *     times (the core bi-temporal invariant from the #1578 design).
+ *  2. Extraction normalization passes the per-fact `eventTime` expression
+ *     through from raw LLM JSON (camelCase and snake_case payloads) so the
+ *     persist path can resolve it at write time.
+ *  3. Storage round-trips `invalid_at` so the bi-temporal interval survives
+ *     write → read (complementing PR 1's observedAt/eventTimeSource test).
+ */
+
+// ── 1. Replay anchoring ──────────────────────────────────────────────────
+
+test("resolveFactEventTime: replay of a 2025 transcript anchors 'last March' to 2025-03, not today", () => {
+  // The anchor is the source turn timestamp from an old (2025) transcript.
+  const anchor2025 = "2025-04-10T12:00:00.000Z";
+  const result = resolveFactEventTime("last March", anchor2025);
+  assert.equal(result.eventTimeSource, "extracted");
+  assert.ok(result.validFrom, "validFrom must be set for a resolvable expression");
+  // "last March" relative to April 2025 → March 2025.
+  assert.ok(result.validFrom!.startsWith("2025-03"), `expected 2025-03, got ${result.validFrom}`);
+  // Critical bi-temporal invariant: NOT anchored to today's wall-clock.
+  assert.ok(!result.validFrom!.startsWith("2026"), "must not anchor to wall-clock");
+  assert.equal(result.observedAt, anchor2025);
+});
+
+test("resolveFactEventTime: same expression, different anchors → different validFrom", () => {
+  // The identical phrase resolves differently depending on the anchor —
+  // proving the resolver is anchor-driven, not Date.now()-driven.
+  const old = resolveFactEventTime("yesterday", "2025-01-15T10:00:00.000Z");
+  const recent = resolveFactEventTime("yesterday", "2026-07-05T10:00:00.000Z");
+  assert.ok(old.validFrom!.startsWith("2025-01-14"), `got ${old.validFrom}`);
+  assert.ok(recent.validFrom!.startsWith("2026-07-04"), `got ${recent.validFrom}`);
+  assert.notEqual(old.validFrom, recent.validFrom);
+});
+
+test("resolveFactEventTime: absent expression → 'assumed' with validFrom = anchor", () => {
+  const anchor = "2025-06-01T00:00:00.000Z";
+  const result = resolveFactEventTime(undefined, anchor);
+  assert.equal(result.eventTimeSource, "assumed");
+  assert.equal(result.validFrom, anchor);
+  assert.equal(result.observedAt, anchor);
+  assert.equal(result.validUntil, undefined);
+});
+
+test("resolveFactEventTime: 'since 2024' → validFrom only (open-ended start)", () => {
+  const result = resolveFactEventTime("since 2024", "2025-06-01T00:00:00.000Z");
+  assert.equal(result.eventTimeSource, "extracted");
+  assert.ok(result.validFrom!.startsWith("2024-01-01"));
+  assert.equal(result.validUntil, undefined);
+});
+
+test("resolveFactEventTime: unresolvable garbage → 'assumed' fallback", () => {
+  const anchor = "2025-06-01T00:00:00.000Z";
+  const result = resolveFactEventTime("sometime maybe???", anchor);
+  assert.equal(result.eventTimeSource, "assumed");
+  assert.equal(result.validFrom, anchor);
+});
+
+// ── 2. Extraction normalization passes eventTime through ─────────────────
+
+function makeEngine(): ExtractionEngine {
+  // Minimal construction: the facts normalizer is a pure data transform
+  // (no LLM / I/O). Stub the optional deps so the constructor doesn't
+  // spin up real clients.
+  return new ExtractionEngine(
+    { memoryDir: "/tmp" } as any,
+    undefined, // profiler → safe default
+    {} as any, // localLlm stub
+    undefined, // gatewayConfig
+    {} as any, // modelRegistry stub
+  );
+}
+
+test("extraction normalization: camelCase 'eventTime' passes through to ExtractedFact", () => {
+  const engine = makeEngine();
+  const result = (engine as any).normalizeExtractionResultPayload({
+    facts: [
+      { content: "We moved offices in March.", category: "fact", eventTime: "last March" },
+    ],
+    entities: [],
+  });
+  assert.equal(result.facts.length, 1);
+  assert.equal(result.facts[0].eventTime, "last March");
+});
+
+test("extraction normalization: snake_case 'event_time' also captured", () => {
+  const engine = makeEngine();
+  const result = (engine as any).normalizeExtractionResultPayload({
+    facts: [
+      { content: "Switched to PostgreSQL.", category: "fact", event_time: "2025-01-15" },
+    ],
+    entities: [],
+  });
+  assert.equal(result.facts[0].eventTime, "2025-01-15");
+});
+
+test("extraction normalization: absent eventTime → undefined (assumed deferred to write time)", () => {
+  const engine = makeEngine();
+  const result = (engine as any).normalizeExtractionResultPayload({
+    facts: [{ content: "The sky is blue.", category: "fact" }],
+    entities: [],
+  });
+  assert.equal(result.facts[0].eventTime, undefined);
+});
+
+// ── 2b. Schema preserves snake_case event_time (gateway fix, chatgpt-codex) ─
+
+test("ExtractedFactSchema: snake_case event_time survives schema parse (gateway strip-unknown fix)", () => {
+  // Zod .object() strips unknown keys by default. Before the event_time alias
+  // was added, the gateway fallback path (parseWithSchemaDetailed → schema.parse)
+  // silently dropped event_time, losing the temporal bound (#1578).
+  const parsed = ExtractedFactSchema.parse({
+    content: "Switched to PostgreSQL.",
+    category: "fact",
+    confidence: 0.9,
+    tags: [],
+    event_time: "2025-01-15",
+  });
+  assert.equal(parsed.event_time, "2025-01-15");
+});
+
+test("ExtractedFactSchema: camelCase eventTime also survives schema parse (no regression)", () => {
+  const parsed = ExtractedFactSchema.parse({
+    content: "We moved offices in March.",
+    category: "fact",
+    confidence: 0.8,
+    tags: [],
+    eventTime: "2025-03",
+  });
+  assert.equal(parsed.eventTime, "2025-03");
+});
+
+// ── 3. Storage round-trips invalid_at ────────────────────────────────────
+
+test("storage: invalid_at round-trips through writeMemoryFrontmatter → readAllMemories", async () => {
+  const dir = await mkdtemp(path.join(os.tmpdir(), "remnic-et-invalidAt-"));
+  try {
+    const storage = new StorageManager(dir);
+    await storage.ensureDirectories();
+
+    const id = await storage.writeMemory("fact", "Old stack was Node 18.", {
+      validAt: "2025-01-01T00:00:00.000Z",
+      observedAt: "2025-06-01T00:00:00.000Z",
+      eventTimeSource: "extracted",
+    });
+
+    const before = await storage.readAllMemories();
+    const mem = before.find((m) => m.frontmatter.id === id);
+    assert.ok(mem);
+
+    const ok = await storage.writeMemoryFrontmatter(mem!, {
+      invalid_at: "2025-06-15T00:00:00.000Z",
+    });
+    assert.equal(ok, true);
+
+    const after = await storage.readAllMemories();
+    const patched = after.find((m) => m.frontmatter.id === id);
+    assert.ok(patched, "patched fact must be readable");
+    assert.equal(patched!.frontmatter.invalid_at, "2025-06-15T00:00:00.000Z");
+    // Bi-temporal provenance preserved through the frontmatter patch.
+    assert.equal(patched!.frontmatter.observedAt, "2025-06-01T00:00:00.000Z");
+    assert.equal(patched!.frontmatter.eventTimeSource, "extracted");
+    assert.equal(patched!.frontmatter.valid_at, "2025-01-01T00:00:00.000Z");
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});
+
+test("storage: writeMemory accepts invalidAt directly (end-bound at extraction write time)", async () => {
+  // Proves Fix C: writeMemory now accepts invalidAt so "until X" expressions
+  // persist invalid_at at write time without a separate updateMemoryFrontmatter call.
+  const dir = await mkdtemp(path.join(os.tmpdir(), "remnic-et-writeMem-invalid-"));
+  try {
+    const storage = new StorageManager(dir);
+    await storage.ensureDirectories();
+    const id = await storage.writeMemory("fact", "We used MongoDB until June 2025.", {
+      validAt: "2024-01-01T00:00:00.000Z",
+      invalidAt: "2025-06-01T00:00:00.000Z",
+      observedAt: "2025-06-20T00:00:00.000Z",
+      eventTimeSource: "extracted",
+    });
+    const mems = await storage.readAllMemories();
+    const mem = mems.find((m) => m.frontmatter.id === id);
+    assert.ok(mem);
+    assert.equal(mem!.frontmatter.valid_at, "2024-01-01T00:00:00.000Z");
+    assert.equal(mem!.frontmatter.invalid_at, "2025-06-01T00:00:00.000Z");
+    assert.equal(mem!.frontmatter.observedAt, "2025-06-20T00:00:00.000Z");
+    assert.equal(mem!.frontmatter.eventTimeSource, "extracted");
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});
+
+test("resolveFactEventTime: 'through 2026' → validUntil only (open-ended end bound)", () => {
+  const result = resolveFactEventTime("through 2026", "2025-06-20T00:00:00.000Z");
+  assert.equal(result.eventTimeSource, "extracted");
+  assert.equal(result.validFrom, undefined);
+  assert.ok(result.validUntil, "validUntil must be set for an end-bound expression");
+  // "through 2026" → exclusive end = start of 2027.
+  assert.equal(result.validUntil, "2027-01-01T00:00:00.000Z");
+});
+test("storage: writeChunk propagates invalidAt/observedAt/eventTimeSource from the parent fact (#1578 PR2)", async () => {
+  // Proves the cursor-bugbot fix: an independently-surfaced chunk expires at the
+  // same invalid_at window as its parent so recall's isValidityExpiredNow check
+  // fires on chunks too, not just the chunked parent write.
+  const dir = await mkdtemp(path.join(os.tmpdir(), "remnic-et-chunk-invalid-"));
+  try {
+    const storage = new StorageManager(dir);
+    await storage.ensureDirectories();
+    const parentId = await storage.writeMemory("fact", "We used MongoDB until June 2025.", {
+      validAt: "2024-01-01T00:00:00.000Z",
+      invalidAt: "2025-06-01T00:00:00.000Z",
+      observedAt: "2025-06-20T00:00:00.000Z",
+      eventTimeSource: "extracted",
+    });
+    const chunkId = await storage.writeChunk(
+      parentId,
+      0,
+      1,
+      "fact",
+      "We used MongoDB until June 2025.",
+      {
+        validAt: "2024-01-01T00:00:00.000Z",
+        invalidAt: "2025-06-01T00:00:00.000Z",
+        observedAt: "2025-06-20T00:00:00.000Z",
+        eventTimeSource: "extracted",
+      },
+    );
+    const mems = await storage.readAllMemories();
+    const chunk = mems.find((m) => m.frontmatter.id === chunkId);
+    assert.ok(chunk, "chunk must be readable");
+    assert.equal(chunk!.frontmatter.valid_at, "2024-01-01T00:00:00.000Z");
+    assert.equal(chunk!.frontmatter.invalid_at, "2025-06-01T00:00:00.000Z",
+      "chunk must carry the parent's end bound so it expires independently");
+    assert.equal(chunk!.frontmatter.observedAt, "2025-06-20T00:00:00.000Z");
+    assert.equal(chunk!.frontmatter.eventTimeSource, "extracted");
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});
+test("resolveFactEventTime: 'until 2025-06' (YYYY-MM) → invalidAt = start of following month (#1578 r3)", () => {
+  const result = resolveFactEventTime("until 2025-06", "2025-06-20T00:00:00.000Z");
+  assert.equal(result.eventTimeSource, "extracted");
+  assert.equal(result.validFrom, undefined);
+  assert.equal(result.validUntil, "2025-07-01T00:00:00.000Z",
+    "YYYY-MM end bound must span the whole month, not fall back to assumed");
+});
+
+test("resolveFactEventTime: bare '2025-03' (YYYY-MM) → validFrom = first of month (#1578 r3)", () => {
+  const result = resolveFactEventTime("2025-03", "2025-06-20T00:00:00.000Z");
+  assert.equal(result.eventTimeSource, "extracted");
+  assert.equal(result.validFrom, "2025-03-01T00:00:00.000Z");
+  assert.equal(result.validUntil, undefined);
+});

package/src/extraction.ts

@@ -279,6 +279,12 @@ export class ExtractionEngine {
               typeof f?.quote === "string" && f.quote.trim().length > 0
                 ? f.quote
                 : undefined,
+            eventTime:
+              typeof f?.eventTime === "string" && f.eventTime.trim().length > 0
+                ? f.eventTime.trim()
+                : typeof f?.event_time === "string" && f.event_time.trim().length > 0
+                  ? f.event_time.trim()
+                  : undefined,
           }))
           .filter((f: any) => f.content.length > 0)
       : [];
@@ -750,6 +756,11 @@ export class ExtractionEngine {
       this.config.provenance?.enabled
         ? '- Source quotes: For each fact, include a "quote" field with the EXACT verbatim words from the conversation that support the fact (a contiguous span from a single turn, not a paraphrase). Cap at ~300 chars.'
         : "",
+      // #1578: emit the same event-time guidance as the primary extraction
+      // paths so proactive-recovered facts also carry an optional eventTime
+      // (chatgpt-codex thread on extraction.ts:1607). Returns "" when the
+      // bi-temporal gate is off, keeping the prompt unchanged by default.
+      this.eventTimePromptInstruction(),
       "",
       "Base extracted facts (do not repeat):",
       factsPreview || "(none)",
@@ -1250,10 +1261,23 @@ export class ExtractionEngine {
         // reasoningTrace through normalizeReasoningTrace before passing it on so
         // gateway output matches the shape local/direct-client paths produce.
         const normalizedFacts = result.facts.map((f: any) => {
-          if (!f?.reasoningTrace) return f;
+          if (!f) return f;
+          // Gateway tolerance: collapse snake_case event_time → camelCase
+          // eventTime so the gateway path matches the local/direct/proactive
+          // normalization (#1578 r3 — cursor bugbot).
+          const eventTime =
+            typeof f.eventTime === "string" && f.eventTime.trim().length > 0
+              ? f.eventTime.trim()
+              : typeof f.event_time === "string" && f.event_time.trim().length > 0
+                ? f.event_time.trim()
+                : undefined;
+          if (!f.reasoningTrace && eventTime === undefined) return f;
           return {
             ...f,
-            reasoningTrace: normalizeReasoningTrace(f.reasoningTrace) ?? undefined,
+            ...(f.reasoningTrace
+              ? { reasoningTrace: normalizeReasoningTrace(f.reasoningTrace) ?? undefined }
+              : {}),
+            ...(eventTime !== undefined ? { eventTime } : {}),
           };
         });
         const sanitized = this.sanitizeExtractionResult({
@@ -1394,7 +1418,7 @@ Examples of when to add structuredAttributes:
 - Decisions: {"chosen": "PostgreSQL", "rejected": "MongoDB", "reason": "ACID compliance"}
 - Quantities/measurements: {"budget": "50000", "team_size": "5", "deadline": "2024-06-01"}
 Only add structuredAttributes when there are concrete values. Skip for abstract or narrative facts.
-
+${this.eventTimePromptInstruction()}
 Also generate:
 1. 1-3 genuine questions you're curious about from this conversation
 2. Profile updates about user patterns/behaviors (if any)
@@ -1595,6 +1619,28 @@ ${truncatedConversation}`;
     return { facts, entities, profileUpdates: [], questions: [] };
   }
 
+  /**
+   * Bi-temporal event-time extraction instruction (#1578 PR2). Emitted on
+   * every extraction entry path when `temporal.biTemporal` is on so the LLM
+   * emits an optional per-fact `eventTime` expression. The expression is
+   * resolved against the source turn timestamp at write time — never
+   * wall-clock — so replay/import of old transcripts anchors correctly.
+   * Returns an empty string when the gate is off (byte-identical prompt).
+   */
+  private eventTimePromptInstruction(): string {
+    if (!this.config.temporalBiTemporal) return "";
+    return `
+=== Event Time (bi-temporal) ===
+When a fact has an explicit temporal anchor — a date, month, season, or relative time expression stating WHEN the fact became (or stopped being) true — capture it verbatim in an "eventTime" field on that fact. Examples:
+- "We moved offices in March" → "eventTime": "last March"
+- "The API has been rate-limited since 2024" → "eventTime": "since 2024"
+- "I switched to PostgreSQL on 2025-01-15" → "eventTime": "2025-01-15"
+- "We used MongoDB until June 2025" → "eventTime": "until 2025-06"
+Accepted forms: ISO dates ("2025-03-01"), year-month ("2025-03"), month/season + year ("March 2025", "summer 2024"), relative ("yesterday", "last week", "this month", "next year", "last December"), and open-ended ("since 2024", "until 2025-06").
+Omit "eventTime" when the fact has no explicit temporal anchor — do NOT guess or infer dates. The system resolves the expression against the conversation's own timestamp, not today's date.
+`;
+  }
+
   /**
    * Build extraction instructions shared between local and cloud LLM.
    */
@@ -1663,6 +1709,7 @@ ${existingEntities.join(", ")}
 
 When you see something that matches a known entity, use THAT name exactly. Only create a NEW entity if nothing in this list represents it.
 ` : ""}
+${this.eventTimePromptInstruction()}
 Also extract relationships between entities mentioned in the conversation.
 - Format: {source: "entity-name", target: "entity-name", label: "relationship description"}
 - Max 5 relationships per extraction

package/src/issue-1492-coding-mode-consistency.test.ts

@@ -0,0 +1,315 @@
+/**
+ * Issue #1492 — Remnic Coding mode inconsistencies.
+ *
+ * Cross-subsystem characterization of the three coding-mode drifts an external
+ * reporter found when wiring per-repo/project namespace isolation for a shared
+ * multi-user Remnic deployment. Each reported symptom was fixed by a dedicated
+ * child issue; this file is the single #1492-named anchor that ties them
+ * together so a regression in ANY of the three subsystems is caught and
+ * attributed here.
+ *
+ *   Symptom A (observe handler ignored coding context)
+ *     → fixed by #1495: observe resolves ONE effective scope plan
+ *       (`resolveMemoryScopePlan`) whose `writeNamespace` is byte-identical to
+ *       what `memory_store`/`suggestion_submit` resolve via
+ *       `resolveCodingScopedWriteNamespace`, so observed turns and explicit
+ *       writes on the same project-scoped session land in the SAME store a
+ *       same-session recall reads. Deep plan-level parity is guarded by
+ *       `access-service-observe-scope.test.ts` (#1495). Here we pin the
+ *       coding-namespace derivation invariant the drift violated: the scoped
+ *       namespace is built by exactly ONE `combineNamespaces(principal, overlay)`
+ *       and is stable/idempotent — never a second ad-hoc combination that could
+ *       drift between the write and read paths.
+ *
+ *   Symptom B (transcript/summarizer session-key parser conflated sessions)
+ *     → fixed by #1496: arbitrary session keys (`pi-geek:abc123`, `pi:abc123`,
+ *       `myuser:abc123`) are first-class `session/<hash>` identities — never the
+ *       legacy `other/default` bucket — for BOTH transcript.ts and summarizer.ts.
+ *
+ *   Symptom C (collectActiveMemoryPaths scanned only 4 of 12+ category dirs)
+ *     → fixed by #1497: the QMD-unavailable filesystem fallback recall scans
+ *       `RECALL_FALLBACK_DIRS` (every recall category dir), so a memory written
+ *       to e.g. `preferences/` is found when QMD is disabled/missing/unhealthy.
+ *
+ * The architectural gaps the reporter also called out — the maintenance
+ * pipeline being blind to dynamic project-scoped namespaces (#1500), and the
+ * admin/webui not surfacing coding context (#1502) — were tracked by their own
+ * issues and are both CLOSED.
+ */
+
+import assert from "node:assert/strict";
+import { mkdir, mkdtemp, readdir, rm, writeFile } from "node:fs/promises";
+import type { Dirent } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+
+import {
+  combineNamespaces,
+  projectNamespaceName,
+  projectTagProjectId,
+  resolveCodingNamespaceOverlay,
+} from "./coding/coding-namespace.js";
+import {
+  SESSION_CHANNEL_TYPE,
+  parseSessionIdentity,
+  sessionStoragePaths,
+} from "./session-identity.js";
+import { HourlySummarizer } from "./summarizer.js";
+import type { HourlySummary, PluginConfig } from "./types.js";
+import { StorageManager } from "./storage.js";
+import { RECALL_FALLBACK_DIRS } from "./utils/category-dir.js";
+
+/** Recursively collect the immediate child directory names under `root` that
+ *  contain at least one file, into `out`. Used to verify the summarizer wrote
+ *  each session's summary into its OWN dir (no conflation). */
+async function walkCollectDirs(root: string, out: Set<string>): Promise<void> {
+  let entries: Dirent[];
+  try {
+    entries = await readdir(root, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const child = path.join(root, entry.name);
+    let childEntries: Dirent[];
+    try {
+      childEntries = await readdir(child, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    if (childEntries.some((e) => e.isFile())) {
+      out.add(entry.name);
+    } else {
+      await walkCollectDirs(child, out);
+    }
+  }
+}
+
+// ─── Symptom A: coding-namespace derivation is stable across write/read ────
+
+test("#1492 Symptom A: a project-scoped session derives ONE stable overlay namespace — the write/read convergence point", () => {
+  // The reporter's scenario: user "pi-geek" in project "Blend/Supply". Both the
+  // observe write path and the recall read path must resolve the SAME scoped
+  // namespace. They do so by combining the principal base with the project
+  // overlay through exactly ONE helper (combineNamespaces); a second ad-hoc
+  // combination is what caused the original drift.
+  const principal = "pi-geek";
+  const projectId = projectTagProjectId("Blend/Supply");
+  const codingContext = {
+    projectId,
+    branch: null,
+    rootPath: projectId,
+    defaultBranch: null,
+  };
+  const overlay = resolveCodingNamespaceOverlay(
+    codingContext,
+    { projectScope: true, branchScope: false, globalFallback: false },
+    "default",
+  );
+  assert.ok(overlay, "projectScope=true must yield a coding overlay");
+
+  const scopedWrite = combineNamespaces(principal, overlay.namespace);
+  const scopedRead = combineNamespaces(principal, overlay.namespace);
+
+  // Write and read converge on the identical scoped namespace.
+  assert.equal(scopedRead, scopedWrite);
+  // It is well-formed: principal base + project overlay, not the flat default.
+  assert.equal(scopedWrite, combineNamespaces(principal, projectNamespaceName(projectId)));
+  assert.ok(
+    scopedWrite.startsWith(`${principal}-`),
+    "scoped namespace must be principal-prefixed, preserving per-user isolation",
+  );
+  assert.notEqual(scopedWrite, principal, "must layer the project overlay onto the principal base");
+  assert.notEqual(scopedWrite, "default", "must not collapse to the flat default namespace");
+  // Two principals in the same repo get distinct scoped namespaces.
+  const other = combineNamespaces("pi-friend", overlay.namespace);
+  assert.notEqual(scopedWrite, other, "per-user isolation: distinct principals stay distinct");
+});
+
+test("#1492 Symptom A: combineNamespaces is idempotent under re-derivation (no double-combination drift)", () => {
+  // A read path that (incorrectly) re-combined an already-scoped namespace with
+  // the overlay would produce `pi-friend-project-x-project-x` and miss the data.
+  // Guard the single-combination contract: combineNamespaces joins base+overlay
+  // with `-`, so re-combining must change the result (drift detector).
+  const principal = "pi-friend";
+  const overlayNs = projectNamespaceName(projectTagProjectId("Remnic"));
+  const once = combineNamespaces(principal, overlayNs);
+  const twice = combineNamespaces(once, overlayNs);
+  assert.notEqual(once, twice, "re-combining a scoped namespace must change it (drift detector)");
+  assert.ok(once.startsWith(`${principal}-`), "scoped namespace is principal-prefixed");
+  assert.ok(!once.includes(`${overlayNs}-${overlayNs}`), "no duplicated overlay fragment");
+});
+
+// ─── Symptom B: arbitrary session keys never conflate ──────────────────────
+
+test("#1492 Symptom B: arbitrary session keys get distinct transcript AND summarizer paths, never other/default", async () => {
+  // Exact keys from the issue body. Pre-fix these all collapsed into
+  // transcripts/other/default/*.jsonl AND summaries/other/default/*.md,
+  // conflating every non-agent-prefixed session in BOTH subsystems.
+  const keys = ["pi-geek:abc123", "pi:abc123", "myuser:abc123", "pi-friend:def456"];
+
+  // ── Transcript path (sessionStoragePaths, consumed by transcript.ts) ──
+  const transcriptDirs = new Set<string>();
+  for (const key of keys) {
+    const id = parseSessionIdentity(key);
+    assert.equal(id.legacy, false, `${key} must not be treated as a legacy agent: key`);
+    assert.equal(id.channelType, SESSION_CHANNEL_TYPE, `${key} channelType must be "session"`);
+    assert.notEqual(id.channelType, "other", `${key} must not fall back to "other"`);
+    assert.notEqual(id.channelId, "default", `${key} must not fall back to "default"`);
+    const paths = sessionStoragePaths(key);
+    assert.match(paths.dir, /^session\/[0-9a-f]{16}$/, `${key} transcript dir must be session/<hash>`);
+    transcriptDirs.add(paths.dir);
+  }
+  assert.equal(transcriptDirs.size, keys.length, "each session key must map to a distinct transcript dir");
+
+  // ── Summarizer path: exercise the REAL HourlySummarizer.saveSummary() so a
+  //    regression in summarizer.ts itself (reverting to the old parsed-session
+  //    bucket) is caught here, not just a regression in session-identity.ts.
+  //    Pre-fix the summarizer derived its dir from the same brittle split(':')
+  //    parser; this round-trip proves the written summary files land in
+  //    distinct per-session dirs (no other/default conflation). ──
+  const memoryDir = await mkdtemp(path.join(os.tmpdir(), "engram-1492-sum-"));
+  try {
+    const config = {
+      memoryDir,
+      localLlmEnabled: false,
+      localLlmFallback: false,
+      localLlmUrl: "http://localhost:1234/v1",
+      localLlmModel: "local-model",
+    } as PluginConfig;
+    const summarizer = new HourlySummarizer(config);
+
+    const summary: HourlySummary = {
+      hour: "2026-06-28T14:00:00.000Z",
+      sessionKey: "", // set per key below
+      bullets: ["worked on shared memory pool"],
+      turnCount: 2,
+      generatedAt: "2026-06-28T14:05:00.000Z",
+    };
+
+    for (const key of keys) {
+      await summarizer.saveSummary({ ...summary, sessionKey: key });
+    }
+
+    // Walk summaries/hourly/ and collect the distinct per-session dirs that
+    // actually received a file. Each must be the encoded session key, never
+    // "other" or "default".
+    const hourlyRoot = path.join(memoryDir, "summaries", "hourly");
+    const sessionDirs = new Set<string>();
+    await walkCollectDirs(hourlyRoot, sessionDirs);
+    assert.ok(sessionDirs.size >= keys.length, "each session key must produce a distinct summary dir");
+    for (const dir of sessionDirs) {
+      assert.notEqual(dir, "other", `summary dir "${dir}" must not be the legacy "other" bucket`);
+      assert.notEqual(dir, "default", `summary dir "${dir}" must not be the legacy "default" bucket`);
+    }
+  } finally {
+    await rm(memoryDir, { recursive: true, force: true });
+  }
+});
+
+test("#1492 Symptom B: legacy agent: keys keep their readable identity (no regression from the fix)", () => {
+  // The fix must not break the legacy 5-part agent:<id>:discord:channel:<chan> shape.
+  const id = parseSessionIdentity("agent:generalist:discord:channel:998877");
+  assert.equal(id.legacy, true);
+  assert.equal(id.channelType, "discord");
+  assert.equal(id.channelId, "998877");
+});
+
+// ─── Symptom C: fallback recall reads EVERY category dir ───────────────────
+
+function memoryFile(id: string, category: string, content: string): string {
+  const now = new Date().toISOString();
+  return [
+    "---",
+    `id: ${id}`,
+    `category: ${category}`,
+    `created: ${now}`,
+    `updated: ${now}`,
+    "confidence: 0.9",
+    "importance: 5",
+    "tags: []",
+    "---",
+    "",
+    content,
+    "",
+  ].join("\n");
+}
+
+async function makeStorage(prefix = "engram-1492-"): Promise<{
+  storage: StorageManager;
+  baseDir: string;
+  cleanup: () => Promise<void>;
+}> {
+  const baseDir = await mkdtemp(path.join(os.tmpdir(), prefix));
+  const storage = new StorageManager(baseDir);
+  await storage.ensureDirectories();
+  StorageManager.clearAllStaticCaches();
+  storage.invalidateAllMemoriesCacheForDir();
+  return {
+    storage,
+    baseDir,
+    cleanup: async () => {
+      StorageManager.clearAllStaticCaches();
+      await rm(baseDir, { recursive: true, force: true });
+    },
+  };
+}
+
+test("#1492 Symptom C: a memory in a non-legacy-4 category (preferences/) is found by fallback disk recall", async () => {
+  // The reporter found collectActiveMemoryPaths scanned only
+  // facts/procedures/reasoning-traces/corrections. A memory written to
+  // preferences/ was invisible to the QMD-unavailable fallback, so recall
+  // returned empty even though the file was on disk.
+  const { storage, baseDir, cleanup } = await makeStorage();
+  try {
+    const preferencesDir = path.join(baseDir, "preferences");
+    await mkdir(preferencesDir, { recursive: true });
+    await writeFile(
+      path.join(preferencesDir, "pref-1.md"),
+      memoryFile("pref-1", "preference", "Prefer tabs over spaces in this repo."),
+      "utf-8",
+    );
+    storage.invalidateAllMemoriesCacheForDir();
+
+    const memories = await storage.readAllMemories();
+    const ids = memories.map((m) => m.frontmatter?.id ?? "");
+    assert.ok(
+      ids.includes("pref-1"),
+      "fallback disk recall must read preferences/ — the 4-dir scan bug is fixed",
+    );
+  } finally {
+    await cleanup();
+  }
+});
+
+test("#1492 Symptom C: RECALL_FALLBACK_DIRS covers the categories the issue named as missed", () => {
+  // The issue enumerated questions/, entities/, decisions/, preferences/,
+  // commitments/, principles/, skills/, relationships/, moments/, rules/,
+  // artifacts/ as directories the system writes to but the old 4-dir scan
+  // missed. Assert the recall-memory categories among them are now covered.
+  // (questions/ is intentionally a non-memory queue dir; artifacts/ and
+  // entities/ are non-category content dirs — see category-dir.ts. The recall
+  // *memory* categories must all be present.)
+  const requiredRecallCategories = [
+    "decisions",
+    "preferences",
+    "commitments",
+    "principles",
+    "skills",
+    "relationships",
+    "moments",
+    "rules",
+  ];
+  for (const dir of requiredRecallCategories) {
+    assert.ok(
+      RECALL_FALLBACK_DIRS.includes(dir),
+      `RECALL_FALLBACK_DIRS must include ${dir}/ (missed by the pre-fix 4-dir scan)`,
+    );
+  }
+  // The legacy four are still present.
+  for (const dir of ["facts", "procedures", "reasoning-traces", "corrections"]) {
+    assert.ok(RECALL_FALLBACK_DIRS.includes(dir), `legacy recall dir ${dir}/ must remain covered`);
+  }
+});