@remnic/core 10.0.82 → 10.0.84

package/src/compounding/weekly-evidence.test.ts

@@ -0,0 +1,237 @@
+import assert from "node:assert/strict";
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+
+import type { MemoryFile } from "../types.js";
+import { rememberRawFrontmatter } from "../storage/memory-frontmatter-metadata.js";
+import {
+  CORRECTION_FILE_BYTE_LIMIT,
+  WEEKLY_CORRECTION_READ_LIMIT,
+  WEEKLY_CORRECTION_SCAN_LIMIT,
+  buildActionFailurePatterns,
+  capWeeklyPatternDetails,
+  isoWeekStartMs,
+  provenanceVisibleInStoreRecall,
+  readFeedbackEntriesForWeekFile,
+  readWeeklyCorrections,
+  type WeeklyActionEvent,
+  type WeeklyEvidenceStorage,
+} from "./weekly-evidence.js";
+import { isoWeekId } from "./iso-week.js";
+
+test("isoWeekStartMs returns Monday UTC for valid ids and null otherwise", () => {
+  const start = isoWeekStartMs("2026-W01");
+  assert.ok(start !== null);
+  assert.equal(new Date(start).toISOString(), "2025-12-29T00:00:00.000Z");
+  assert.equal(isoWeekId(new Date(start)), "2026-W01");
+
+  const w02 = isoWeekStartMs("2026-W02");
+  assert.ok(w02 !== null);
+  assert.equal(w02 - start!, 7 * 86_400_000);
+
+  assert.equal(isoWeekStartMs("2026-W1"), null);
+  assert.equal(isoWeekStartMs("2026-W00"), null);
+  assert.equal(isoWeekStartMs("not-a-week"), null);
+  assert.equal(isoWeekStartMs("2026-W54"), null);
+  // 2026 has 53 weeks only if the calendar emits it; W53 that does not land is null.
+  const w53 = isoWeekStartMs("2015-W53");
+  assert.ok(w53 !== null);
+  assert.equal(isoWeekId(new Date(w53)), "2015-W53");
+  assert.equal(isoWeekStartMs("2016-W53"), null);
+});
+
+test("readFeedbackEntriesForWeekFile filters by ISO week and skips bad lines", async () => {
+  const root = await mkdtemp(path.join(os.tmpdir(), "remnic-weekly-feedback-"));
+  try {
+    const inbox = path.join(root, "feedback.jsonl");
+    const inWeek = "2026-01-02T12:00:00.000Z"; // 2026-W01
+    const otherWeek = "2026-01-08T12:00:00.000Z"; // 2026-W02
+    await writeFile(
+      inbox,
+      [
+        JSON.stringify({
+          agent: "alpha",
+          decision: "approved",
+          reason: "looks good",
+          date: inWeek,
+        }),
+        "not-json",
+        JSON.stringify({ agent: "", decision: "approved", reason: "x", date: inWeek }),
+        JSON.stringify({
+          agent: "beta",
+          decision: "rejected",
+          reason: "no",
+          date: otherWeek,
+        }),
+        JSON.stringify({
+          agent: "gamma",
+          decision: "approved_with_feedback",
+          reason: "tweak",
+          date: "2025-12-30T08:00:00.000Z",
+        }),
+        "",
+      ].join("\n"),
+      "utf8",
+    );
+
+    const entries = await readFeedbackEntriesForWeekFile(inbox, "2026-W01");
+    assert.equal(entries.length, 2);
+    assert.deepEqual(
+      entries.map((row) => row.entry.agent).sort(),
+      ["alpha", "gamma"],
+    );
+    assert.equal(entries.find((row) => row.entry.agent === "alpha")?.sourceLine, 1);
+    assert.equal(entries.find((row) => row.entry.agent === "gamma")?.sourceLine, 5);
+
+    assert.deepEqual(await readFeedbackEntriesForWeekFile(path.join(root, "missing.jsonl"), "2026-W01"), []);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test("buildActionFailurePatterns keeps failures, skips, and policy decisions", () => {
+  const events: WeeklyActionEvent[] = [
+    {
+      line: 1,
+      action: "forget",
+      outcome: "failed",
+      policyDecision: null,
+      namespace: "default",
+      reason: "locked",
+      ledgerLabel: "memory-actions.jsonl",
+      actionId: "a1",
+    },
+    {
+      line: 2,
+      action: "promote",
+      outcome: "applied",
+      policyDecision: null,
+      namespace: "default",
+      reason: null,
+      ledgerLabel: "memory-actions.jsonl",
+      actionId: "a2",
+    },
+    {
+      line: 3,
+      action: "edit",
+      outcome: "applied",
+      policyDecision: "deny",
+      namespace: "ns1",
+      reason: "  blocked by policy  ",
+      ledgerLabel: "namespaces/ns1/state/memory-actions.jsonl",
+      actionId: "a3",
+    },
+    {
+      line: 4,
+      action: "merge",
+      outcome: "skipped",
+      policyDecision: null,
+      namespace: "default",
+      reason: null,
+      ledgerLabel: "memory-actions.jsonl",
+      actionId: "a4",
+    },
+  ];
+
+  const patterns = buildActionFailurePatterns(events);
+  assert.equal(patterns.length, 3);
+  assert.match(patterns[0]!.pattern, /memory-action\/default: forget failed - locked/);
+  assert.equal(patterns[0]!.provenance, "memory-actions.jsonl:*");
+  assert.match(patterns[1]!.pattern, /memory-action\/ns1: edit applied\/deny - blocked by policy/);
+  assert.match(patterns[2]!.pattern, /memory-action\/default: merge skipped$/);
+});
+
+test("readWeeklyCorrections skips files over the byte cap and keeps in-week active ones", async () => {
+  const root = await mkdtemp(path.join(os.tmpdir(), "remnic-weekly-corr-"));
+  try {
+    const correctionsDir = path.join(root, "corrections");
+    await mkdir(correctionsDir, { recursive: true });
+
+    const inWeekMs = Date.parse("2026-01-02T15:00:00.000Z");
+    const smallName = `correction-${inWeekMs}.md`;
+    const largeName = `correction-${inWeekMs + 1000}.md`;
+    const smallBody = `---
+id: corr-small
+category: correction
+status: active
+created: 2026-01-02T15:00:00.000Z
+---
+
+Fix the pricing table.
+`;
+    await writeFile(path.join(correctionsDir, smallName), smallBody, "utf8");
+    await writeFile(
+      path.join(correctionsDir, largeName),
+      `${"x".repeat(CORRECTION_FILE_BYTE_LIMIT + 1)}`,
+      "utf8",
+    );
+
+    // SAFETY: rememberRawFrontmatter reads only path, content and frontmatter; this literal sets all three.
+    const smallMemory = rememberRawFrontmatter(
+      {
+        path: path.join(correctionsDir, smallName),
+        content: "Fix the pricing table.",
+        frontmatter: {
+          id: "corr-small",
+          category: "correction",
+          status: "active",
+          created: "2026-01-02T15:00:00.000Z",
+        },
+      } as MemoryFile,
+      smallBody,
+    );
+    const byPath = new Map<string, MemoryFile>([[path.join(correctionsDir, smallName), smallMemory]]);
+
+    const storage: WeeklyEvidenceStorage = {
+      async readMemoryByPath(filePath) {
+        return byPath.get(filePath) ?? null;
+      },
+      async readMemoryActionEventRows() {
+        return [];
+      },
+    };
+
+    const evidence = await readWeeklyCorrections({
+      storage,
+      memoryDir: root,
+      weekId: "2026-W01",
+    });
+    assert.equal(evidence.length, 1);
+    assert.equal(evidence[0]!.id, "corr-small");
+    assert.equal(evidence[0]!.note, "Fix the pricing table.");
+    assert.equal(evidence[0]!.provenance, `corrections/${smallName}`);
+
+    assert.ok(CORRECTION_FILE_BYTE_LIMIT === 256 * 1024);
+    assert.ok(WEEKLY_CORRECTION_READ_LIMIT === 500);
+    assert.ok(WEEKLY_CORRECTION_SCAN_LIMIT === 2000);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test("provenanceVisibleInStoreRecall and capWeeklyPatternDetails prefer visible actions", () => {
+  assert.equal(provenanceVisibleInStoreRecall(["facts/a.md"]), true);
+  assert.equal(provenanceVisibleInStoreRecall(["namespaces/other/x.md"]), false);
+  assert.equal(provenanceVisibleInStoreRecall(["namespaces/home/x.md"], "namespaces/home/"), true);
+  assert.equal(provenanceVisibleInStoreRecall([]), true);
+
+  const details = [
+    { pattern: "foreign", provenance: ["namespaces/other/a.md"] as const },
+    { pattern: "action-a", provenance: ["memory-actions.jsonl:*"] as const },
+    { pattern: "corr", provenance: ["corrections/c.md"] as const },
+    { pattern: "action-b", provenance: ["memory-actions.jsonl:*"] as const },
+    { pattern: "overflow", provenance: ["facts/x.md"] as const },
+  ];
+  const capped = capWeeklyPatternDetails(
+    details,
+    (pattern) => (pattern.startsWith("action") ? "action" : "correction"),
+    null,
+    3,
+  );
+  assert.deepEqual(
+    capped.map((row) => row.pattern),
+    ["action-a", "action-b", "corr"],
+  );
+});

package/src/entity-mention-index-cache.ts

@@ -3,6 +3,7 @@ import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
 import { raceAbort } from "./abort-error.js";
 import { entityMentionEpoch } from "./entity-mention-epoch.js";
 import { log } from "./logger.js";
+import { compareStrings } from "./eval-trajectory-contracts.js";
 
 /**
  * In-memory entity mention index.
@@ -158,12 +159,6 @@ function throwIfMentionAborted(signal?: AbortSignal): void {
   throw reason instanceof Error ? reason : new Error("entity mention rebuild aborted");
 }
 
-function compareStrings(left: string, right: string): number {
-  if (left < right) return -1;
-  if (left > right) return 1;
-  return 0;
-}
-
 function deduped(values: readonly string[]): string[] {
   const seen = new Set<string>();
   const out: string[] = [];

package/src/fallback-llm-codex-subscription.ts

@@ -200,6 +200,10 @@ export function isUnsupportedJsonSchemaError(error: unknown): boolean {
   }
   return (
     /(?:response[_ ]?format|json[_ ]?schema|structured[_ ]?output)\b[^;,\n]{0,60}\b(?:unsupported|not supported|not implemented|not available)\b/i.test(message) ||
+    // "unavailable" counts only when it directly describes the format (DeepSeek:
+    // "This response_format type is unavailable now"). A wider window would also
+    // match an outage message that merely echoes the format.
+    /(?:response[_ ]?format|json[_ ]?schema|structured[_ ]?output)(?:\s{1,8}(?:type|mode|parameter|option|feature))?\s{1,8}(?:is\s{1,8})?unavailable\b/i.test(message) ||
     /\b(?:unsupported|unknown|unrecognized)(?:[\s:"'=]|parameter|argument|request|supplied|field|type|value){1,40}\b(?:response[_ ]?format|json[_ ]?schema|structured[_ ]?output|schema|format)\b/i.test(message) ||
     /\b(?:does not|doesn't|cannot|can't) support(?:[\s:"'=]|the|native|type){1,20}\b(?:response[_ ]?format|json[_ ]?schema|structured[_ ]?output|schema|format)\b/i.test(message) ||
     // A strict provider parser rejecting the SCHEMA CONTENT itself (2026-11-05

package/src/local-llm-json-schema-fallback.test.ts

@@ -170,6 +170,9 @@ test("a diagnostic echo of the format is not a schema capability rejection", asy
   for (const message of [
     "Context length exceeded; request included response_format json_schema",
     "Unsupported parameter temperature; request included response_format json_schema",
+    "Model temporarily unavailable; request included response_format json_schema",
+    "Request included response_format json_schema but model temporarily unavailable",
+    "json_schema request failed: upstream unavailable",
   ]) {
     const server = await startRecordingServer(() => ({ status: 400, body: { error: { message } } }));
     try {
@@ -199,6 +202,36 @@ test("an explicit unknown response_format field retries without the format", asy
   }
 });
 
+test("an unavailable response_format type retries without the format and persists the rejection", async () => {
+  const memoryDir = fs.mkdtempSync(join(os.tmpdir(), "remnic-schema-cap-"));
+  const server = await startRecordingServer((_req, count) =>
+    count === 1
+      ? { status: 400, body: { error: { message: "This response_format type is unavailable now" } } }
+      : { status: 200, body: okCompletion },
+  );
+  try {
+    const registry = new ModelRegistry(memoryDir);
+    const client = new LocalLlmClient(createConfig({ localLlmUrl: server.url }), registry);
+    primeClient(client);
+    assert.equal(
+      (await client.chatCompletion([{ role: "user", content: "hello" }], { responseFormat }))?.content,
+      "done",
+    );
+    assert.equal(server.requests.length, 2, "one schema-carrying request, then one retry without the format");
+    assert.deepEqual(server.requests[0].body.response_format, responseFormat);
+    assert.equal(server.requests[1].body.response_format, undefined);
+    // SAFETY: we wrote model-capabilities.json through ModelRegistry above; the
+    // document is an object keyed by normalized model id.
+    const persisted = JSON.parse(
+      fs.readFileSync(join(memoryDir, ".registry", "model-capabilities.json"), "utf8"),
+    ) as { models: Record<string, { structuredOutput?: string }> };
+    assert.equal(persisted.models["test-local-model"]?.structuredOutput, "none");
+  } finally {
+    await server.close();
+    fs.rmSync(memoryDir, { recursive: true, force: true });
+  }
+});
+
 test("format removal persists for later 5xx attempts", async () => {
   const server = await startRecordingServer((_req, count) =>
     count === 1

package/src/maintenance/rebuild-memory-projection-runner.test.ts

@@ -0,0 +1,90 @@
+import assert from "node:assert/strict";
+import { spawn } from "node:child_process";
+import { mkdtemp, rm } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import test from "node:test";
+
+import { PROJECTION_REBUILD_RUNNER_FLAG } from "./rebuild-memory-projection-runner.js";
+
+const RUNNER = fileURLToPath(new URL("./rebuild-memory-projection-runner.ts", import.meta.url));
+
+type RunnerMessage =
+  | { ok: true; currentRows: number; timelineRows: number; entityMentionRows: number }
+  | { ok: false; error: string };
+
+async function runRunner(args: string[]): Promise<{
+  code: number | null;
+  messages: RunnerMessage[];
+  stderr: string;
+}> {
+  const child = spawn(
+    process.execPath,
+    ["--import", "tsx", RUNNER, PROJECTION_REBUILD_RUNNER_FLAG, ...args],
+    {
+      stdio: ["ignore", "ignore", "pipe", "ipc"],
+      env: { ...process.env },
+    },
+  );
+  const messages: RunnerMessage[] = [];
+  let stderr = "";
+  child.stderr?.setEncoding("utf8");
+  child.stderr?.on("data", (chunk: string) => {
+    stderr += chunk;
+  });
+  child.on("message", (message) => {
+    // SAFETY: the runner posts only RunnerMessage values over IPC; the assertions below check each field.
+    messages.push(message as RunnerMessage);
+  });
+  const { promise: exitPromise, resolve, reject } = Promise.withResolvers<number | null>();
+  child.once("error", reject);
+  child.once("exit", (exitCode) => resolve(exitCode));
+  const code = await exitPromise;
+  return { code, messages, stderr };
+}
+
+test("PROJECTION_REBUILD_RUNNER_FLAG is the documented argv marker", () => {
+  assert.equal(PROJECTION_REBUILD_RUNNER_FLAG, "--remnic-projection-rebuild-runner");
+});
+
+test("runner rejects missing argv with an IPC failure message", async () => {
+  const result = await runRunner([]);
+  assert.equal(result.code, 1);
+  assert.equal(result.messages.length, 1);
+  assert.equal(result.messages[0]!.ok, false);
+  if (result.messages[0]!.ok === false) {
+    assert.match(result.messages[0]!.error, /requires memoryDir, defaultNamespace, and now/);
+  }
+});
+
+test("runner rejects a non-timestamp now value", async () => {
+  const root = await mkdtemp(path.join(os.tmpdir(), "remnic-proj-runner-bad-now-"));
+  try {
+    const result = await runRunner([root, "default", "not-a-date"]);
+    assert.equal(result.code, 1);
+    assert.equal(result.messages[0]!.ok, false);
+    if (result.messages[0]!.ok === false) {
+      assert.match(result.messages[0]!.error, /not a timestamp/);
+    }
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test("runner rebuilds an empty memory dir and reports zero rows", async () => {
+  const root = await mkdtemp(path.join(os.tmpdir(), "remnic-proj-runner-ok-"));
+  try {
+    const result = await runRunner([root, "default", "2026-06-01T00:00:00.000Z"]);
+    assert.equal(result.code, 0, result.stderr || JSON.stringify(result.messages));
+    assert.equal(result.messages.length, 1);
+    assert.deepEqual(result.messages[0], {
+      ok: true,
+      currentRows: 0,
+      timelineRows: 0,
+      entityMentionRows: 0,
+    });
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});

package/src/orchestration/full-corpus-heap-guard.test.ts

@@ -0,0 +1,52 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { fullCorpusHeapPressure } from "./full-corpus-heap-guard.js";
+
+test("fullCorpusHeapPressure postpones only when usage is strictly above the limit", () => {
+  assert.deepEqual(fullCorpusHeapPressure({ used_heap_size: 61, heap_size_limit: 100 }, 0.6), {
+    postpone: true,
+    ratio: 0.61,
+  });
+  assert.deepEqual(fullCorpusHeapPressure({ used_heap_size: 60, heap_size_limit: 100 }, 0.6), {
+    postpone: false,
+    ratio: 0.6,
+  });
+  assert.deepEqual(fullCorpusHeapPressure({ used_heap_size: 59, heap_size_limit: 100 }, 0.6), {
+    postpone: false,
+    ratio: 0.59,
+  });
+});
+
+test("fullCorpusHeapPressure never fires at limit ratio 1", () => {
+  const pressure = fullCorpusHeapPressure({ used_heap_size: 100, heap_size_limit: 100 }, 1);
+  assert.equal(pressure.postpone, false);
+  assert.equal(pressure.ratio, 1);
+});
+
+test("fullCorpusHeapPressure ignores unusable statistics or limits", () => {
+  assert.deepEqual(fullCorpusHeapPressure({ used_heap_size: 90, heap_size_limit: 0 }, 0.6), {
+    postpone: false,
+    ratio: 0,
+  });
+  assert.deepEqual(fullCorpusHeapPressure({ used_heap_size: 90, heap_size_limit: -1 }, 0.6), {
+    postpone: false,
+    ratio: 0,
+  });
+  assert.deepEqual(fullCorpusHeapPressure({ used_heap_size: Number.NaN, heap_size_limit: 100 }, 0.6), {
+    postpone: false,
+    ratio: 0,
+  });
+  assert.deepEqual(fullCorpusHeapPressure({ used_heap_size: -1, heap_size_limit: 100 }, 0.6), {
+    postpone: false,
+    ratio: 0,
+  });
+  assert.deepEqual(fullCorpusHeapPressure({ used_heap_size: 90, heap_size_limit: 100 }, Number.NaN), {
+    postpone: false,
+    ratio: 0,
+  });
+  assert.deepEqual(
+    fullCorpusHeapPressure({ used_heap_size: Number.POSITIVE_INFINITY, heap_size_limit: 100 }, 0.6),
+    { postpone: false, ratio: 0 },
+  );
+});

package/src/projection-rebuild-config.test.ts

@@ -0,0 +1,79 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import {
+  DEFAULT_PROJECTION_REBUILD_HEAP_USAGE_LIMIT,
+  parseProjectionRebuildHeapUsageLimit,
+  parseProjectionRebuildScheduleConfig,
+} from "./projection-rebuild-config.js";
+
+const parseIntegerAtLeast: Parameters<typeof parseProjectionRebuildScheduleConfig>[1] = (
+  value,
+  fallback,
+  min,
+  keyName,
+) => {
+  if (value === undefined || value === null) return fallback;
+  const n = Number(value);
+  if (!Number.isFinite(n) || !Number.isInteger(n) || n < min) {
+    throw new Error(`${keyName} must be an integer >= ${min}; got ${JSON.stringify(value)}`);
+  }
+  return n;
+};
+
+test("parseProjectionRebuildHeapUsageLimit defaults and accepts (0, 1]", () => {
+  assert.equal(parseProjectionRebuildHeapUsageLimit(undefined), DEFAULT_PROJECTION_REBUILD_HEAP_USAGE_LIMIT);
+  assert.equal(parseProjectionRebuildHeapUsageLimit(null), DEFAULT_PROJECTION_REBUILD_HEAP_USAGE_LIMIT);
+  assert.equal(DEFAULT_PROJECTION_REBUILD_HEAP_USAGE_LIMIT, 0.6);
+  assert.equal(parseProjectionRebuildHeapUsageLimit(0.5), 0.5);
+  assert.equal(parseProjectionRebuildHeapUsageLimit("0.75"), 0.75);
+  assert.equal(parseProjectionRebuildHeapUsageLimit(1), 1);
+});
+
+test("parseProjectionRebuildHeapUsageLimit rejects 0, negatives, and non-numbers", () => {
+  assert.throws(() => parseProjectionRebuildHeapUsageLimit(0), /projectionRebuildHeapUsageLimit/);
+  assert.throws(() => parseProjectionRebuildHeapUsageLimit(-0.1), /projectionRebuildHeapUsageLimit/);
+  assert.throws(() => parseProjectionRebuildHeapUsageLimit(1.01), /projectionRebuildHeapUsageLimit/);
+  assert.throws(() => parseProjectionRebuildHeapUsageLimit(Number.NaN), /projectionRebuildHeapUsageLimit/);
+  assert.throws(() => parseProjectionRebuildHeapUsageLimit("abc"), /projectionRebuildHeapUsageLimit/);
+  assert.throws(() => parseProjectionRebuildHeapUsageLimit({}), /projectionRebuildHeapUsageLimit/);
+});
+
+test("parseProjectionRebuildScheduleConfig defaults and coerces booleans", () => {
+  const defaults = parseProjectionRebuildScheduleConfig({}, parseIntegerAtLeast);
+  assert.equal(defaults.projectionRebuildEnabled, true);
+  assert.equal(defaults.projectionRebuildIntervalMs, 6 * 60 * 60 * 1000);
+  assert.equal(defaults.projectionRebuildHeapUsageLimit, 0.6);
+
+  const disabled = parseProjectionRebuildScheduleConfig(
+    { projectionRebuildEnabled: "false", projectionRebuildIntervalMs: 120_000, projectionRebuildHeapUsageLimit: 0.4 },
+    parseIntegerAtLeast,
+  );
+  assert.equal(disabled.projectionRebuildEnabled, false);
+  assert.equal(disabled.projectionRebuildIntervalMs, 120_000);
+  assert.equal(disabled.projectionRebuildHeapUsageLimit, 0.4);
+});
+
+test("parseProjectionRebuildScheduleConfig floors the interval via the integer parser", () => {
+  assert.throws(
+    () =>
+      parseProjectionRebuildScheduleConfig(
+        { projectionRebuildIntervalMs: 59_999 },
+        parseIntegerAtLeast,
+      ),
+    /projectionRebuildIntervalMs/,
+  );
+  assert.throws(
+    () =>
+      parseProjectionRebuildScheduleConfig(
+        { projectionRebuildIntervalMs: 90_000.5 },
+        parseIntegerAtLeast,
+      ),
+    /projectionRebuildIntervalMs/,
+  );
+  const ok = parseProjectionRebuildScheduleConfig(
+    { projectionRebuildIntervalMs: 60_000 },
+    parseIntegerAtLeast,
+  );
+  assert.equal(ok.projectionRebuildIntervalMs, 60_000);
+});

package/src/storage/entity-store-symlink.test.ts

@@ -0,0 +1,44 @@
+import assert from "node:assert/strict";
+import { mkdtemp, rm, symlink, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+
+import { StorageManager } from "../storage.js";
+
+/**
+ * COS-388c Finding C2: ordinary entity reads must not follow a symlink at
+ * `entities/<id>.md` to content outside the memory dir. List skips the
+ * same entry. A normal entity file still reads.
+ */
+test("readEntity refuses entities/evil.md symlink outside the memory dir (C2)", async () => {
+  const dir = await mkdtemp(path.join(os.tmpdir(), "remnic-entity-c2-"));
+  const outside = await mkdtemp(path.join(os.tmpdir(), "remnic-entity-c2-out-"));
+  try {
+    const storage = new StorageManager(dir);
+    await storage.ensureDirectories({ waitForEntityMigration: false });
+    const id = await storage.writeEntity("Alice", "person", ["Normal entity inside the store."]);
+
+    await writeFile(path.join(outside, "secret.md"), "OUTSIDE_SECRET_CONTENT\n");
+    await symlink(path.join(outside, "secret.md"), path.join(dir, "entities", "evil.md"));
+
+    const evil = await storage.readEntity("evil");
+    assert.equal(
+      evil.includes("OUTSIDE_SECRET_CONTENT"),
+      false,
+      "entity read must not return the outside symlink target",
+    );
+    assert.equal(evil, "", "symlinked entity id is treated as absent, not as escaped content");
+
+    const alice = await storage.readEntity(id);
+    assert.match(alice, /Normal entity inside the store/);
+
+    const names = await storage.listEntityNames();
+    assert.equal(names.includes("evil"), false, "list must skip the symlinked entity entry");
+    assert.ok(names.includes(id), "normal entity remains listable");
+  } finally {
+    StorageManager.clearAllStaticCaches();
+    await rm(dir, { recursive: true, force: true });
+    await rm(outside, { recursive: true, force: true });
+  }
+});

package/src/utils/malformed-entity-record.test.ts

@@ -0,0 +1,69 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import {
+  isMalformedEntityRecord,
+  isPopulatedUnnamedEntityRecord,
+  isShapedUnnamedEntityRecord as isEntityLikeUnnamedRecord,
+  isUnnamedEntityRecord,
+} from "./malformed-entity-record.js";
+
+const NAMED = "# Alice\n\n**Type:** person\n\nNotes about Alice.\n";
+const NAMED_NO_TYPE = "# Alice\n\nNotes about Alice.\n";
+const TYPE_ONLY = "**Type:** person\n\nNo heading name.\n";
+const TAB_HEADING = "#\tAlice\n\n**Type:** person\n";
+const BLANK_HEADING = "#  \n\n**Type:** person\n";
+const PROSE_ONLY = "just some content without structure\n";
+const EMPTY_BODY = "---\nid: x\n---\n\n   \n";
+const FRONTMATTER_NAMED = "---\nid: alice\n---\n\n# Alice\n\n**Type:** person\n";
+
+test("isUnnamedEntityRecord requires a hash-space heading with a name", () => {
+  assert.equal(isUnnamedEntityRecord(NAMED), false);
+  assert.equal(isUnnamedEntityRecord(NAMED_NO_TYPE), false);
+  assert.equal(isUnnamedEntityRecord(FRONTMATTER_NAMED), false);
+  assert.equal(isUnnamedEntityRecord(TYPE_ONLY), true);
+  assert.equal(isUnnamedEntityRecord(TAB_HEADING), true, "tab after # is not a heading");
+  assert.equal(isUnnamedEntityRecord(BLANK_HEADING), true, "blank # heading is unnamed");
+  assert.equal(isUnnamedEntityRecord(PROSE_ONLY), true);
+  assert.equal(isUnnamedEntityRecord(""), true);
+});
+
+test("isPopulatedUnnamedEntityRecord needs body text without a name", () => {
+  assert.equal(isPopulatedUnnamedEntityRecord(NAMED), false);
+  assert.equal(isPopulatedUnnamedEntityRecord(TYPE_ONLY), true);
+  assert.equal(isPopulatedUnnamedEntityRecord(TAB_HEADING), true);
+  assert.equal(isPopulatedUnnamedEntityRecord(PROSE_ONLY), true);
+  assert.equal(isPopulatedUnnamedEntityRecord(EMPTY_BODY), false, "whitespace-only body stays readable");
+  assert.equal(isPopulatedUnnamedEntityRecord(""), false);
+});
+
+test("isShapedUnnamedEntityRecord keeps entity-like unnamed files only", () => {
+  assert.equal(isEntityLikeUnnamedRecord(NAMED), false);
+  assert.equal(isEntityLikeUnnamedRecord(TYPE_ONLY), true);
+  assert.equal(isEntityLikeUnnamedRecord(TAB_HEADING), true, "any # line shapes the record");
+  assert.equal(isEntityLikeUnnamedRecord(BLANK_HEADING), true);
+  assert.equal(isEntityLikeUnnamedRecord(PROSE_ONLY), false, "unstructured placeholders stay for filename recall");
+  assert.equal(isEntityLikeUnnamedRecord(EMPTY_BODY), false);
+});
+
+test("isMalformedEntityRecord requires both name and explicit type for migration", () => {
+  assert.equal(isMalformedEntityRecord(NAMED), false);
+  assert.equal(isMalformedEntityRecord(FRONTMATTER_NAMED), false);
+  assert.equal(isMalformedEntityRecord(NAMED_NO_TYPE), true, "missing type is malformed for migration");
+  assert.equal(isMalformedEntityRecord(TYPE_ONLY), true);
+  assert.equal(isMalformedEntityRecord(TAB_HEADING), true);
+  assert.equal(isMalformedEntityRecord(PROSE_ONLY), true);
+  assert.equal(isMalformedEntityRecord("# Bob\n\n**Type:**   \n"), true, "blank type value is missing");
+  assert.equal(isMalformedEntityRecord("# Bob\n\n**Type:** org\r\n"), false, "CRLF type lines count");
+});
+
+test("entity body ignores closed frontmatter and keeps unclosed frontmatter as body", () => {
+  const unclosed = "---\nid: stuck\n# Not a real heading yet\n";
+  // Unclosed frontmatter is not stripped, so the # line is not at body start of a closed block —
+  // but it still appears in the full content scan as a named heading.
+  assert.equal(isUnnamedEntityRecord(unclosed), false);
+  assert.equal(isMalformedEntityRecord(unclosed), true, "no type line");
+
+  const namedAfterFrontmatter = "---\na: 1\n---\r\n# Carol\r\n\r\n**Type:** place\r\n";
+  assert.equal(isMalformedEntityRecord(namedAfterFrontmatter), false);
+});