@remnic/core 1.1.12 → 1.1.13

package/src/signal.ts

@@ -0,0 +1,84 @@
+import type { SignalLevel, SignalScanResult } from "./types.js";
+
+const BUILTIN_HIGH_PATTERNS: RegExp[] = [
+  /\bactually,?\s+(i|my|we)\b/i,
+  /\bno,?\s+(i|my|we|that'?s)\s+(not|wrong|incorrect)\b/i,
+  /\bthat'?s\s+not\s+right\b/i,
+  /\bwhy\s+did\s+you\s+say\s+that\b/i,
+  /\bi\s+(?:always|never|prefer|hate|love|want|need)\b/i,
+  /\bdon'?t\s+(?:use|do|call|say|make)\b/i,
+  /\bplease\s+(?:always|never|remember|note)\b/i,
+  /\bcorrection:?\b/i,
+  /\bimportant:?\s+/i,
+  /\bfyi:?\b/i,
+  /\bfor\s+(?:the\s+)?record\b/i,
+  /\bmy\s+(?:name|email|company|role|title|preference)\s+is\b/i,
+  /\bi\s+(?:work|live|am)\s+(?:at|in|from|a)\b/i,
+  /\bwe\s+(?:decided|agreed|chose|picked)\b/i,
+  /\bthe\s+decision\s+(?:is|was)\b/i,
+  /\bgoing\s+forward\b/i,
+  /\bfrom\s+now\s+on\b/i,
+];
+
+const MEDIUM_PATTERNS: RegExp[] = [
+  /\bi\s+(?:think|believe|feel)\b/i,
+  /\busually\b/i,
+  /\btypically\b/i,
+  /\bi\s+(?:like|dislike)\b/i,
+  /\bmy\s+(?:team|project|stack|setup)\b/i,
+];
+
+const DISAGREEMENT_PATTERNS: RegExp[] = [
+  /\bthat'?s\s+not\s+right\b/i,
+  /\bwhy\s+did\s+you\s+say\s+that\b/i,
+  /\bthat'?s\s+wrong\b/i,
+  /\bnot\s+correct\b/i,
+];
+
+export function isDisagreementPrompt(text: string): boolean {
+  for (const rx of DISAGREEMENT_PATTERNS) {
+    if (rx.test(text)) return true;
+  }
+  return false;
+}
+
+export function scanSignals(
+  text: string,
+  customPatterns: string[] = [],
+): SignalScanResult {
+  const matched: string[] = [];
+
+  const customRegexes = customPatterns.map((p) => new RegExp(p, "i"));
+
+  for (const rx of customRegexes) {
+    if (rx.test(text)) {
+      matched.push(`custom:${rx.source}`);
+    }
+  }
+
+  for (const rx of BUILTIN_HIGH_PATTERNS) {
+    if (rx.test(text)) {
+      matched.push(`high:${rx.source}`);
+    }
+  }
+
+  if (matched.length > 0) {
+    return { level: "high", patterns: matched };
+  }
+
+  const mediumMatched: string[] = [];
+  for (const rx of MEDIUM_PATTERNS) {
+    if (rx.test(text)) {
+      mediumMatched.push(`medium:${rx.source}`);
+    }
+  }
+
+  if (mediumMatched.length >= 2) {
+    return { level: "medium", patterns: mediumMatched };
+  }
+  if (mediumMatched.length === 1) {
+    return { level: "low", patterns: mediumMatched };
+  }
+
+  return { level: "none", patterns: [] };
+}

package/src/skills-registry.test.ts

@@ -0,0 +1,277 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { basename, dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+import { BUILTIN_SKILLS, isValidSkillSlug } from "./skills-registry.js";
+
+const HERE = dirname(fileURLToPath(import.meta.url));
+const CORE_PACKAGE_DIR = resolve(HERE, "..");
+
+// The two on-disk directories that hold authored SKILL.md folders.
+const CODEX_SKILLS_DIR = resolve(HERE, "..", "..", "plugin-codex", "skills");
+const CLAUDE_CODE_SKILLS_DIR = resolve(HERE, "..", "..", "plugin-claude-code", "skills");
+const CORE_PACKAGED_SKILLS_DIR = resolve(CORE_PACKAGE_DIR, "skills");
+
+const REQUIRED_SECTIONS = [
+  "When to use",
+  "Inputs",
+  "Procedure",
+  "Efficiency plan",
+  "Pitfalls and fixes",
+  "Verification checklist",
+] as const;
+
+const LEGACY_ENGRAM_STRINGS = [
+  "engram:memory",
+  "engram:recall",
+  "engram:remember",
+  "engram:search",
+  "engram:entities",
+  "engram:status",
+] as const;
+
+// ---------------------------------------------------------------------------
+// Slug validation
+// ---------------------------------------------------------------------------
+
+test("isValidSkillSlug accepts canonical remnic slugs", () => {
+  assert.equal(isValidSkillSlug("remnic-memory-workflow"), true);
+  assert.equal(isValidSkillSlug("remnic-recall"), true);
+  assert.equal(isValidSkillSlug("remnic-remember"), true);
+  assert.equal(isValidSkillSlug("remnic-search"), true);
+  assert.equal(isValidSkillSlug("remnic-entities"), true);
+  assert.equal(isValidSkillSlug("remnic-status"), true);
+});
+
+test("isValidSkillSlug rejects invalid slugs", () => {
+  assert.equal(isValidSkillSlug("Remnic-Memory"), false, "rejects capitals");
+  assert.equal(isValidSkillSlug("remnic_memory"), false, "rejects underscores");
+  assert.equal(isValidSkillSlug(""), false, "rejects empty string");
+  assert.equal(isValidSkillSlug("a".repeat(65)), false, "rejects 65-char slug");
+  assert.equal(isValidSkillSlug("a".repeat(64)), true, "accepts 64-char slug");
+  assert.equal(isValidSkillSlug("-remnic"), false, "rejects leading dash");
+  assert.equal(isValidSkillSlug("remnic memory"), false, "rejects whitespace");
+});
+
+test("isValidSkillSlug rejects trailing dashes and consecutive dashes", () => {
+  assert.equal(isValidSkillSlug("remnic-"), false, "rejects trailing dash");
+  assert.equal(isValidSkillSlug("a--b"), false, "rejects consecutive dashes");
+  assert.equal(isValidSkillSlug(""), false, "rejects empty string");
+  assert.equal(isValidSkillSlug("-foo"), false, "rejects leading dash");
+});
+
+test("isValidSkillSlug accepts well-formed slugs", () => {
+  assert.equal(isValidSkillSlug("a"), true, "accepts single char");
+  assert.equal(isValidSkillSlug("remnic-core"), true, "accepts remnic-core");
+  assert.equal(isValidSkillSlug("a-b-c"), true, "accepts a-b-c");
+});
+
+// ---------------------------------------------------------------------------
+// BUILTIN_SKILLS shape
+// ---------------------------------------------------------------------------
+
+test("BUILTIN_SKILLS has exactly six entries", () => {
+  assert.equal(BUILTIN_SKILLS.length, 6);
+});
+
+test("BUILTIN_SKILLS slugs are valid and unique", () => {
+  const slugs = BUILTIN_SKILLS.map((s) => s.slug);
+  for (const slug of slugs) {
+    assert.equal(isValidSkillSlug(slug), true, `${slug} should pass isValidSkillSlug`);
+    assert.ok(slug.startsWith("remnic-"), `${slug} should start with remnic-`);
+  }
+  const unique = new Set(slugs);
+  assert.equal(unique.size, slugs.length, "slugs must be unique");
+});
+
+test("each BUILTIN_SKILLS entry has either a staticPath or generator", () => {
+  for (const skill of BUILTIN_SKILLS) {
+    const hasStatic = typeof skill.staticPath === "string" && skill.staticPath.length > 0;
+    const hasGenerator = typeof skill.generator === "function";
+    assert.ok(
+      hasStatic || hasGenerator,
+      `${skill.slug} must provide staticPath or generator`,
+    );
+  }
+});
+
+test("each BUILTIN_SKILLS staticPath points at a real SKILL.md on disk", () => {
+  for (const skill of BUILTIN_SKILLS) {
+    if (!skill.staticPath) continue;
+    assert.ok(
+      existsSync(skill.staticPath),
+      `${skill.slug} staticPath missing: ${skill.staticPath}`,
+    );
+    const stat = statSync(skill.staticPath);
+    assert.ok(stat.isFile(), `${skill.staticPath} should be a file`);
+    assert.equal(
+      basename(skill.staticPath),
+      "SKILL.md",
+      `${skill.slug} staticPath filename should be SKILL.md`,
+    );
+  }
+});
+
+test("@remnic/core package ships the built-in skill sources referenced by BUILTIN_SKILLS", () => {
+  const packageJson = JSON.parse(readFileSync(resolve(CORE_PACKAGE_DIR, "package.json"), "utf8")) as {
+    files?: unknown;
+  };
+  assert.ok(
+    Array.isArray(packageJson.files) && packageJson.files.includes("skills"),
+    "packages/remnic-core/package.json files must include packaged skills",
+  );
+  assert.ok(
+    statSync(CORE_PACKAGED_SKILLS_DIR).isDirectory(),
+    "packaged skills path must be a directory",
+  );
+
+  for (const skill of BUILTIN_SKILLS) {
+    const packagedPath = resolve(CORE_PACKAGED_SKILLS_DIR, skill.slug, "SKILL.md");
+    const canonicalPath = resolve(CODEX_SKILLS_DIR, skill.slug, "SKILL.md");
+    assert.ok(existsSync(packagedPath), `${skill.slug} packaged SKILL.md must exist`);
+    assert.equal(
+      readFileSync(packagedPath, "utf8"),
+      readFileSync(canonicalPath, "utf8"),
+      `${skill.slug} packaged SKILL.md must match the canonical Codex skill source`,
+    );
+    assert.equal(
+      skill.staticPath,
+      packagedPath,
+      `${skill.slug} staticPath should resolve to the packaged core skill source`,
+    );
+  }
+});
+
+// ---------------------------------------------------------------------------
+// Frontmatter + required sections (applied to each authored SKILL.md)
+// ---------------------------------------------------------------------------
+
+interface ParsedSkill {
+  source: string;
+  frontmatter: Record<string, string>;
+  body: string;
+  lineCount: number;
+}
+
+function parseSkillFile(filePath: string): ParsedSkill {
+  const raw = readFileSync(filePath, "utf8");
+  const lineCount = raw.split(/\r?\n/).length;
+
+  // Extract YAML frontmatter delimited by leading `---` lines.
+  const fmMatch = raw.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/);
+  assert.ok(fmMatch, `${filePath} must start with a YAML frontmatter block`);
+  const fmBlock = fmMatch[1];
+  const body = fmMatch[2];
+
+  // Tiny frontmatter parser: only supports `key: value` pairs on top-level
+  // lines — good enough for our six-key schema.
+  const frontmatter: Record<string, string> = {};
+  for (const line of fmBlock.split(/\r?\n/)) {
+    if (!line.trim() || line.trim().startsWith("#")) continue;
+    if (line.startsWith(" ") || line.startsWith("\t")) continue; // ignore list entries
+    const idx = line.indexOf(":");
+    if (idx === -1) continue;
+    const key = line.slice(0, idx).trim();
+    const value = line.slice(idx + 1).trim();
+    frontmatter[key] = value;
+  }
+
+  return { source: filePath, frontmatter, body, lineCount };
+}
+
+function findH2Sections(body: string): string[] {
+  const headers: string[] = [];
+  for (const line of body.split(/\r?\n/)) {
+    const match = line.match(/^##\s+(.+?)\s*$/);
+    if (match) headers.push(match[1]);
+  }
+  return headers;
+}
+
+function collectSkillFiles(dir: string): string[] {
+  if (!existsSync(dir)) return [];
+  const out: string[] = [];
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    if (!entry.isDirectory()) continue;
+    const skillPath = resolve(dir, entry.name, "SKILL.md");
+    if (existsSync(skillPath)) out.push(skillPath);
+  }
+  return out;
+}
+
+const ALL_SKILL_FILES = [
+  ...collectSkillFiles(CODEX_SKILLS_DIR),
+  ...collectSkillFiles(CLAUDE_CODE_SKILLS_DIR),
+];
+
+test("every authored SKILL.md has valid frontmatter", () => {
+  assert.ok(ALL_SKILL_FILES.length >= 12, "expected at least 12 SKILL.md files across both plugins");
+  for (const file of ALL_SKILL_FILES) {
+    const parsed = parseSkillFile(file);
+    const name = parsed.frontmatter["name"];
+    assert.ok(name, `${file} must have a name in frontmatter`);
+    assert.ok(
+      name.startsWith("remnic-"),
+      `${file} name "${name}" must start with remnic-`,
+    );
+    assert.ok(!name.includes(":"), `${file} name "${name}" must not contain ':'`);
+    assert.ok(
+      isValidSkillSlug(name),
+      `${file} name "${name}" must pass isValidSkillSlug`,
+    );
+    const description = parsed.frontmatter["description"];
+    assert.ok(
+      description && description.length > 0,
+      `${file} must have a non-empty description`,
+    );
+  }
+});
+
+test("every authored SKILL.md contains the six required H2 sections in order", () => {
+  for (const file of ALL_SKILL_FILES) {
+    const parsed = parseSkillFile(file);
+    const headers = findH2Sections(parsed.body);
+    // Required sections must appear as a prefix subsequence — allow extra H2s
+    // but the six canonical ones must be present in the defined order.
+    let idx = 0;
+    for (const header of headers) {
+      if (idx < REQUIRED_SECTIONS.length && header === REQUIRED_SECTIONS[idx]) {
+        idx++;
+      }
+    }
+    assert.equal(
+      idx,
+      REQUIRED_SECTIONS.length,
+      `${file} missing or out-of-order required sections; saw: ${JSON.stringify(headers)}`,
+    );
+  }
+});
+
+test("every authored SKILL.md is at most 500 lines", () => {
+  for (const file of ALL_SKILL_FILES) {
+    const parsed = parseSkillFile(file);
+    assert.ok(
+      parsed.lineCount <= 500,
+      `${file} has ${parsed.lineCount} lines, exceeding the 500-line cap`,
+    );
+  }
+});
+
+// ---------------------------------------------------------------------------
+// Legacy engram:* naming must not appear in any authored SKILL.md
+// ---------------------------------------------------------------------------
+
+test("no authored SKILL.md mentions legacy engram:* skill names", () => {
+  for (const file of ALL_SKILL_FILES) {
+    const body = readFileSync(file, "utf8").toLowerCase();
+    for (const bad of LEGACY_ENGRAM_STRINGS) {
+      assert.equal(
+        body.includes(bad),
+        false,
+        `${file} contains forbidden legacy string "${bad}"`,
+      );
+    }
+  }
+});

package/src/skills-registry.ts

@@ -0,0 +1,120 @@
+/**
+ * skills-registry.ts
+ *
+ * Built-in Remnic procedural memory skills — the canonical SKILL.md sources
+ * shipped with the monorepo. Consumers (e.g. the Codex materializer in #378)
+ * read this registry to discover which skills to materialize into
+ * `~/.codex/memories/skills/<slug>/SKILL.md`.
+ *
+ * This module is intentionally free of Codex/Claude Code host coupling —
+ * it only exposes the static metadata each host needs.
+ */
+
+import { fileURLToPath } from "node:url";
+import { statSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+
+/**
+ * A single procedural-memory skill source that Remnic ships.
+ *
+ * - `slug` is the canonical folder name under `skills/` and the file on disk
+ *   must live at `<pluginRoot>/skills/<slug>/SKILL.md`.
+ * - `staticPath`, when set, points at a pre-authored SKILL.md on disk.
+ * - `generator`, when set, produces a SKILL.md body at materialization time.
+ *   Exactly one of `staticPath` or `generator` should be provided.
+ * - `disableModelInvocation` mirrors the `disable-model-invocation` frontmatter
+ *   key and indicates a skill that writes or mutates state and therefore
+ *   should not be auto-invoked by a model without explicit opt-in.
+ */
+export interface RemnicSkillSource {
+  slug: string;
+  staticPath?: string;
+  generator?: () => Promise<string>;
+  disableModelInvocation: boolean;
+}
+
+/**
+ * Validate a Remnic skill slug. Rules:
+ *
+ * - lowercase letters, digits, and `-` only
+ * - must start with a letter or digit
+ * - 1–64 characters
+ *
+ * This is the same shape the Codex skills directory expects.
+ */
+export function isValidSkillSlug(slug: string): boolean {
+  // Must start with alphanumeric; each dash must be followed by alphanumeric
+  // (no trailing dashes, no consecutive dashes); 1–64 characters total.
+  return /^[a-z0-9](?:[a-z0-9]|-(?=[a-z0-9])){0,63}$/.test(slug);
+}
+
+// ---------------------------------------------------------------------------
+// Built-in skill paths — resolved relative to this module.
+// ---------------------------------------------------------------------------
+//
+// This file lives at `packages/remnic-core/src/skills-registry.ts`.
+// After tsup build it lives at `packages/remnic-core/dist/skills-registry.js`.
+// Packaged @remnic/core artifacts ship skill sources under
+// `packages/remnic-core/skills/<slug>/SKILL.md`; source checkouts can fall back
+// to the canonical monorepo copies in `packages/plugin-codex/skills`.
+//
+// We compute the absolute path from the current module so that callers in any
+// cwd can resolve the files.
+
+const HERE = dirname(fileURLToPath(import.meta.url));
+const PACKAGED_SKILLS_DIR = resolve(HERE, "..", "skills");
+const PLUGIN_CODEX_SKILLS_DIR = resolve(HERE, "..", "..", "plugin-codex", "skills");
+
+function isDirectory(pathname: string): boolean {
+  try {
+    return statSync(pathname).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+function builtinSkillsDir(): string {
+  return isDirectory(PACKAGED_SKILLS_DIR) ? PACKAGED_SKILLS_DIR : PLUGIN_CODEX_SKILLS_DIR;
+}
+
+function codexSkillPath(slug: string): string {
+  return resolve(builtinSkillsDir(), slug, "SKILL.md");
+}
+
+/**
+ * The canonical list of Remnic procedural memory skills shipped with the
+ * monorepo. The Codex materializer (#378) copies these into
+ * `~/.codex/memories/skills/<slug>/SKILL.md`.
+ */
+export const BUILTIN_SKILLS: RemnicSkillSource[] = [
+  {
+    slug: "remnic-memory-workflow",
+    staticPath: codexSkillPath("remnic-memory-workflow"),
+    disableModelInvocation: true,
+  },
+  {
+    slug: "remnic-recall",
+    staticPath: codexSkillPath("remnic-recall"),
+    disableModelInvocation: false,
+  },
+  {
+    slug: "remnic-remember",
+    staticPath: codexSkillPath("remnic-remember"),
+    disableModelInvocation: true,
+  },
+  {
+    slug: "remnic-search",
+    staticPath: codexSkillPath("remnic-search"),
+    disableModelInvocation: false,
+  },
+  {
+    slug: "remnic-entities",
+    staticPath: codexSkillPath("remnic-entities"),
+    disableModelInvocation: false,
+  },
+  {
+    slug: "remnic-status",
+    staticPath: codexSkillPath("remnic-status"),
+    disableModelInvocation: false,
+  },
+];

package/src/source-attribution-roundtrip.test.ts

@@ -0,0 +1,215 @@
+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 { StorageManager } from "./storage.js";
+import {
+  attachCitation,
+  hasCitation,
+  parseCitation,
+  stripCitation,
+  stripCitationForTemplate,
+  DEFAULT_CITATION_FORMAT,
+} from "./source-attribution.js";
+
+/**
+ * Issue #369 — Inline source attribution round-trip.
+ *
+ * These tests verify that once a citation marker is embedded in the fact
+ * body, it survives writing to disk and reading back via StorageManager —
+ * which is the same path recall takes when it injects memories into a
+ * prompt. The orchestrator-level `persistExtraction` is covered indirectly
+ * through this round-trip: all three write sites (`writeMemory`,
+ * `writeChunk`, `writeArtifact`) go through the same on-disk markdown file
+ * and frontmatter parser.
+ */
+
+test("round-trip: citation-enriched fact content survives writeMemory → readAllMemories", async () => {
+  const dir = await mkdtemp(path.join(os.tmpdir(), "remnic-source-attr-"));
+  try {
+    const storage = new StorageManager(dir);
+    await storage.ensureDirectories();
+
+    const factBody = "The foo service uses Redis for rate limiting.";
+    const enriched = attachCitation(factBody, {
+      agent: "planner",
+      session: "agent:planner:main",
+      ts: "2026-04-10T14:25:07Z",
+    });
+
+    assert.ok(hasCitation(enriched), "attachCitation must emit a marker");
+
+    const id = await storage.writeMemory("fact", enriched, {
+      confidence: 0.8,
+      tags: ["test"],
+    });
+    assert.ok(id.length > 0);
+
+    const memories = await storage.readAllMemories();
+    const written = memories.find((m) => m.frontmatter.id === id);
+    assert.ok(written, "writeMemory output must be readable");
+    assert.ok(
+      hasCitation(written!.content),
+      "citation marker must survive the on-disk round-trip",
+    );
+
+    const parsed = parseCitation(written!.content);
+    assert.ok(parsed);
+    assert.equal(parsed!.agent, "planner");
+    assert.equal(parsed!.session, "main");
+    assert.equal(parsed!.ts, "2026-04-10T14:25:07Z");
+
+    // stripCitation must recover the original fact body verbatim so
+    // downstream consumers that want raw text have a clean escape hatch.
+    assert.equal(stripCitation(written!.content), factBody);
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});
+
+test("legacy fact memories without a citation marker still read cleanly", async () => {
+  const dir = await mkdtemp(path.join(os.tmpdir(), "remnic-source-attr-legacy-"));
+  try {
+    const storage = new StorageManager(dir);
+    await storage.ensureDirectories();
+
+    const legacyBody = "Legacy fact without inline provenance.";
+    const id = await storage.writeMemory("fact", legacyBody, {
+      confidence: 0.8,
+      tags: ["legacy"],
+    });
+
+    const memories = await storage.readAllMemories();
+    const written = memories.find((m) => m.frontmatter.id === id);
+    assert.ok(written);
+    assert.equal(hasCitation(written!.content), false);
+    // Plain content is unchanged by strip, so recall sees the exact body.
+    assert.equal(stripCitation(written!.content), legacyBody);
+    assert.equal(parseCitation(written!.content), null);
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});
+
+// ---------------------------------------------------------------------------
+// Fix #1 regression: Codex P2 — Canonicalize pre-tagged facts before hashing
+// ---------------------------------------------------------------------------
+
+test("stripCitationForTemplate: default template — strips citation and returns canonical body", () => {
+  const body = "The auth service rotates tokens every 24 hours.";
+  const cited = attachCitation(body, { agent: "planner", session: "agent:planner:main", ts: "2026-04-10T00:00:00Z" });
+  assert.ok(hasCitation(cited), "setup: citation must be present");
+  const result = stripCitationForTemplate(cited, DEFAULT_CITATION_FORMAT);
+  assert.equal(result, body, "should recover canonical body");
+});
+
+test("stripCitationForTemplate: uncited text returned unchanged", () => {
+  const body = "No citation here.";
+  const result = stripCitationForTemplate(body, DEFAULT_CITATION_FORMAT);
+  assert.equal(result, body);
+});
+
+test("stripCitationForTemplate: custom template — strips custom citation", () => {
+  const body = "Cache TTL is 30 seconds.";
+  const template = "[src:{agent}@{date}]";
+  const cited = `${body} [src:scout@2026-04-11]`;
+  const result = stripCitationForTemplate(cited, template);
+  assert.equal(result, body);
+});
+
+test("stripCitationForTemplate: all-placeholder template (no literal anchors) — text returned unchanged", () => {
+  // A template with no literal prefix, suffix, or separator between
+  // placeholders cannot produce a reliable matcher. hasCitationForTemplate
+  // returns false for such templates, so stripCitationForTemplate passes the
+  // text through unchanged — it cannot detect a citation to strip.
+  const body = "Some fact plannermain";
+  const template = "{agent}{sessionId}";
+  const result = stripCitationForTemplate(body, template);
+  assert.equal(result, body, "all-placeholder template: text should be returned unchanged");
+});
+
+// ---------------------------------------------------------------------------
+// Fix #2 regression: Cursor Medium — legacy hash rebuild on ensureFactHashIndexAuthoritative
+// ---------------------------------------------------------------------------
+
+/**
+ * Write a legacy-format fact file directly to disk — without a `contentHash`
+ * frontmatter field, simulating a memory written before issue #369 introduced
+ * that field. This lets tests exercise the rebuild recovery path in
+ * `ensureFactHashIndexAuthoritative`.
+ */
+async function writeLegacyFactFile(
+  storage: StorageManager,
+  rawContent: string,
+): Promise<void> {
+  const { writeFile: wf, mkdir: mkd } = await import("node:fs/promises");
+  const today = new Date().toISOString().slice(0, 10);
+  const id = `legacy-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+  const frontmatter = [
+    "---",
+    `id: ${id}`,
+    "category: fact",
+    `created: ${new Date().toISOString()}`,
+    `updated: ${new Date().toISOString()}`,
+    "source: extraction",
+    "confidence: 0.8",
+    "confidenceTier: high",
+    'tags: []',
+    "---",
+  ].join("\n");
+  // Deliberately omit contentHash to simulate a pre-#369 legacy fact.
+  const factsDir = path.join((storage as any).baseDir, "facts", today);
+  await mkd(factsDir, { recursive: true });
+  await wf(path.join(factsDir, `${id}.md`), `${frontmatter}\n\n${rawContent}\n`, "utf-8");
+}
+
+test("legacy fact rebuild: ensureFactHashIndexAuthoritative indexes legacy facts via content stripping (default citation)", async () => {
+  const dir = await mkdtemp(path.join(os.tmpdir(), "remnic-legacy-rebuild-"));
+  try {
+    const storage = new StorageManager(dir);
+    await storage.ensureDirectories();
+
+    // Write a legacy fact WITH a default-format citation but WITHOUT a
+    // contentHash frontmatter field, simulating a pre-#369 memory.
+    const rawBody = "The production database uses connection pooling.";
+    const citedBody = attachCitation(rawBody, {
+      agent: "planner",
+      session: "agent:planner:main",
+      ts: "2026-01-01T00:00:00Z",
+    });
+    await writeLegacyFactFile(storage, citedBody);
+
+    // Trigger rebuild: ensureFactHashIndexAuthoritative runs when the ready
+    // marker is absent. There is no ready marker in a freshly created dir.
+    const found = await storage.hasFactContentHash(rawBody);
+    assert.equal(
+      found,
+      true,
+      "hasFactContentHash should find the legacy fact after rebuild (citation stripped to canonical form)",
+    );
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});
+
+test("legacy fact rebuild: facts without any citation are indexed by raw content", async () => {
+  const dir = await mkdtemp(path.join(os.tmpdir(), "remnic-legacy-rebuild-raw-"));
+  try {
+    const storage = new StorageManager(dir);
+    await storage.ensureDirectories();
+
+    const rawBody = "No citation on this legacy fact.";
+    await writeLegacyFactFile(storage, rawBody);
+
+    const found = await storage.hasFactContentHash(rawBody);
+    assert.equal(
+      found,
+      true,
+      "hasFactContentHash should find a legacy fact without any citation",
+    );
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});