hippocamp 0.2.6 → 0.2.8

package/test/dream.test.cjs

@@ -0,0 +1,190 @@
+const assert = require("node:assert/strict");
+const fs = require("node:fs/promises");
+const os = require("node:os");
+const path = require("node:path");
+const test = require("node:test");
+const dream = require("../scripts/hippocamp-dream.cjs");
+const memory = require("../scripts/hippocamp-memory.cjs");
+
+async function fixture(t) {
+  const previousRoot = process.env.HIPPOCAMP_GLOBAL_ROOT;
+  const previousFetch = global.fetch;
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), "hippocamp-dream-test-"));
+  process.env.HIPPOCAMP_GLOBAL_ROOT = root;
+  t.after(async () => {
+    if (previousRoot === undefined) delete process.env.HIPPOCAMP_GLOBAL_ROOT;
+    else process.env.HIPPOCAMP_GLOBAL_ROOT = previousRoot;
+    global.fetch = previousFetch;
+    await fs.rm(root, { recursive: true, force: true });
+  });
+  const slug = "dream-fixture";
+  const projectRoot = `/tmp/${slug}`;
+  const project = path.join(root, "projects", slug);
+  await fs.mkdir(project, { recursive: true });
+  await fs.writeFile(path.join(project, "current_state.md"), "# Current State\n\n- Keep production reads fail-closed.\n");
+  await fs.writeFile(path.join(project, "open_threads.md"), "# Open Threads\n\n- Merge PR #2928, then verify deployment.\n- Investigate the unresolved native Google blocker.\n");
+  const options = { thresholdChars: 20000, targetChars: 3000, write: true, apiKey: "test", baseUrl: "https://model.test", model: "test" };
+  async function event(title, content, offset = -60000) {
+    const timestamp = new Date(Date.now() + offset).toISOString();
+    await memory.appendEvent({ projectRoot, scope: "project", sync: false, title, content, keywords: ["dream-test"], timestamp, date: timestamp.slice(0, 10) });
+    return timestamp;
+  }
+  return { root, slug, projectRoot, project, options, event };
+}
+
+function respond(output) {
+  return { ok: true, status: 200, text: async () => JSON.stringify({ output_text: JSON.stringify(output) }) };
+}
+
+test("small projects receive new evidence and may grow; a successful batch is not reviewed twice", async (t) => {
+  const f = await fixture(t);
+  const id = await f.event("PR #2928 merged and a reusable lesson", "PR #2928 merged. Deployment has not been verified.\n\nDecision: project identity follows the canonical repository, because worktree names are temporary.");
+  const eventPath = path.join(f.project, "events", `${id.slice(0, 10)}.md`);
+  const originalEvents = await fs.readFile(eventPath, "utf8");
+  let calls = 0;
+  global.fetch = async (_url, request) => {
+    calls++;
+    const input = JSON.parse(request.body).input;
+    assert.match(input, /Recent Event Evidence/);
+    assert.ok(input.includes(id));
+    assert.match(input, /PR #2928 merged\. Deployment has not been verified/);
+    assert.match(input, /canonical repository/);
+    assert.match(input, /unresolved native Google blocker/);
+    assert.match(input, /A merged PR closes the merge action, not unverified deployment/);
+    return respond({
+      current_state_md: `# Current State\n\n- Keep production reads fail-closed.\n- Project identity follows the canonical repository because worktree names are temporary. Source: events/${id.slice(0, 10)}.md, ${id}.`,
+      open_threads_md: "# Open Threads\n\n- Verify PR #2928 deployment.\n- Investigate the unresolved native Google blocker.",
+    });
+  };
+  const scan = await dream.dreamProject(f.slug, { ...f.options, write: false });
+  assert.equal(scan.skipped, "dry_run");
+  assert.equal(calls, 0);
+  const result = await dream.dreamProject(f.slug, f.options);
+  assert.ok(result.afterBytes > result.beforeBytes);
+  assert.ok(result.afterBytes <= f.options.targetChars * 1.02);
+  assert.equal(result.recentEvidence.items.length, 1);
+  assert.equal(dream.toPublicReport(result).context.recentEvents, 1);
+  assert.ok((await fs.readFile(path.join(f.project, "current_state.md"), "utf8")).includes(`hippocamp-dream-through: ${id}`));
+  assert.equal(await fs.readFile(eventPath, "utf8"), originalEvents);
+  assert.equal((await dream.dreamProject(f.slug, f.options)).skipped, "below_threshold");
+  assert.equal(calls, 1);
+});
+
+test("bootstrap ignores old, future, and unindexed events; a recorded cursor survives downtime", async (t) => {
+  const f = await fixture(t);
+  const old = await f.event("Old event", "An older durable constraint.", -10 * 86400000);
+  await f.event("Future event", "Not yet evidence.", 86400000);
+  const today = new Date().toISOString().slice(0, 10);
+  await fs.writeFile(path.join(f.project, "events", `${today}.md`), `## ${new Date().toISOString()} — Unindexed\n\nDo not ingest.\n`);
+  assert.equal((await dream.dreamProject(f.slug, { ...f.options, write: false })).skipped, "below_threshold");
+  const marker = new Date(Date.now() - 11 * 86400000).toISOString();
+  await fs.appendFile(path.join(f.project, "current_state.md"), `\n<!-- hippocamp-dream-through: ${marker} -->\n`);
+  const resumed = await dream.dreamProject(f.slug, { ...f.options, write: false });
+  assert.equal(resumed.skipped, "dry_run");
+  assert.deepEqual(resumed.recentEvidence.items.map((e) => e.id), [old]);
+});
+
+test("Dream preserves existing curated-file permissions when replacing the snapshot", async (t) => {
+  const f = await fixture(t);
+  await f.event("Durable correction", "Keep production reads fail-closed.");
+  const currentPath = path.join(f.project, "current_state.md");
+  const threadsPath = path.join(f.project, "open_threads.md");
+  await fs.chmod(currentPath, 0o600);
+  await fs.chmod(threadsPath, 0o640);
+  global.fetch = async () => respond({ current_state_md: "# Current State\n\n- Keep production reads fail-closed.", open_threads_md: "# Open Threads\n\n- Keep unresolved work." });
+  await dream.dreamProject(f.slug, f.options);
+  assert.equal((await fs.stat(currentPath)).mode & 0o777, 0o600);
+  assert.equal((await fs.stat(threadsPath)).mode & 0o777, 0o640);
+});
+
+test("bounded batches defer remaining events without advancing past unseen evidence", async (t) => {
+  const f = await fixture(t);
+  const ids = [];
+  for (let i = 0; i < 5; i++) ids.push(await f.event(`Lesson ${i}`, `Constraint ${i}: ${"Keep the documented boundary. ".repeat(18)}`, -60000 + i * 1000));
+  global.fetch = async () => respond({ current_state_md: "# Current State\n\n- Keep the documented boundary.", open_threads_md: "# Open Threads\n\n- Investigate the unresolved native Google blocker." });
+  const first = await dream.dreamProject(f.slug, f.options);
+  assert.ok(first.recentEvidence.items.length > 0 && first.recentEvidence.items.length < ids.length);
+  assert.equal(first.recentEvidence.reviewedThrough, first.recentEvidence.items.at(-1).id);
+  const second = await dream.dreamProject(f.slug, { ...f.options, write: false });
+  assert.equal(second.recentEvidence.items[0].id, ids[first.recentEvidence.items.length]);
+  const report = dream.toPublicReport(first);
+  assert.ok(report.context.evidenceChars <= report.context.evidenceBudgetChars);
+});
+
+test("an oversized model result fails without changing files or the event cursor", async (t) => {
+  const f = await fixture(t);
+  await f.event("Durable correction", "Keep production reads fail-closed.");
+  const paths = ["current_state.md", "open_threads.md"].map((name) => path.join(f.project, name));
+  const before = await Promise.all(paths.map((name) => fs.readFile(name, "utf8")));
+  global.fetch = async () => respond({ current_state_md: `# Current State\n\n- ${"Too large. ".repeat(400)}`, open_threads_md: "# Open Threads\n\n- Keep unresolved work." });
+  await assert.rejects(dream.dreamProject(f.slug, f.options), /did not reduce the snapshot/);
+  assert.deepEqual(await Promise.all(paths.map((name) => fs.readFile(name, "utf8"))), before);
+});
+
+test("an oversized first excerpt fails before a model call without skipping evidence", async (t) => {
+  const f = await fixture(t);
+  await f.event("Durable correction", "Keep production reads fail-closed.");
+  const paths = ["current_state.md", "open_threads.md"].map((name) => path.join(f.project, name));
+  const before = await Promise.all(paths.map((name) => fs.readFile(name, "utf8")));
+  global.fetch = async () => assert.fail("Model must not be called");
+  await assert.rejects(dream.dreamProject(f.slug, { ...f.options, targetChars: 100 }), /Recent event evidence does not fit/);
+  assert.deepEqual(await Promise.all(paths.map((name) => fs.readFile(name, "utf8"))), before);
+});
+
+test("compaction retries retain source evidence while the caller owns the review marker", async (t) => {
+  const f = await fixture(t);
+  const id = await f.event("Durable correction", "Keep production reads fail-closed.");
+  const source = `events/${id.slice(0, 10)}.md, ${id}`;
+  let calls = 0;
+  global.fetch = async (_url, request) => {
+    const input = JSON.parse(request.body).input;
+    calls++;
+    if (calls === 1) return respond({ current_state_md: `# Current State\n\n- Keep production reads fail-closed. Source: ${source}.\n\n- ${"Historical detail. ".repeat(200)}`, open_threads_md: "# Open Threads\n\n- Keep unresolved work." });
+    assert.ok(input.includes(source));
+    assert.match(input, /Preserve the event path and timestamp attached to each retained/);
+    assert.doesNotMatch(input, /<!-- hippocamp-dream-through:/);
+    const retryTarget = Number(input.match(/Target combined size[^:]*: (\d+) chars/)[1]);
+    assert.ok(retryTarget > 0 && retryTarget < f.options.targetChars);
+    return respond({ current_state_md: `# Current State\n\n- Keep production reads fail-closed. Source: ${source}.`, open_threads_md: "# Open Threads\n\n- Keep unresolved work." });
+  };
+  const result = await dream.dreamProject(f.slug, f.options);
+  assert.equal(result.compactionPasses, 2);
+  const current = await fs.readFile(path.join(f.project, "current_state.md"), "utf8");
+  assert.ok(current.includes(source));
+  assert.equal((current.match(/<!-- hippocamp-dream-through:/g) || []).length, 1);
+  assert.equal((await dream.dreamProject(f.slug, f.options)).skipped, "below_threshold");
+  assert.equal(calls, 2);
+});
+
+test("recent reads ignore an index path that points outside its canonical event day", async (t) => {
+  const f = await fixture(t);
+  const id = await f.event("Safe event", "Canonical event evidence.");
+  const indexPath = path.join(f.project, "events", `${id.slice(0, 10)}.index.json`);
+  const index = JSON.parse(await fs.readFile(indexPath, "utf8"));
+  index.path = "../../outside.md";
+  await fs.writeFile(path.join(f.root, "outside.md"), `## ${id} — Other\n\nOutside scope.\n`);
+  await fs.writeFile(indexPath, JSON.stringify(index));
+  const events = await memory.readRecentEvents({ projectRoot: f.projectRoot, after: new Date(Date.now() - 86400000).toISOString() });
+  assert.equal(events.length, 1);
+  assert.match(events[0].snippet, /Canonical event evidence/);
+  assert.doesNotMatch(events[0].snippet, /Outside scope/);
+});
+
+for (const failure of ["current_state.md", "open_threads.md", "commit"]) {
+  test(`a failed ${failure} save leaves both files and the review marker unchanged`, async (t) => {
+    const f = await fixture(t);
+    await f.event("Durable correction", "Keep production reads fail-closed.");
+    const paths = ["current_state.md", "open_threads.md"].map((name) => path.join(f.project, name));
+    const before = await Promise.all(paths.map((name) => fs.readFile(name, "utf8")));
+    global.fetch = async () => respond({ current_state_md: "# Current State\n\n- Keep production reads fail-closed.", open_threads_md: "# Open Threads\n\n- Keep unresolved work." });
+    const method = failure === "commit" ? "rename" : "writeFile";
+    const original = fs[method];
+    t.mock.method(fs, method, async (file, ...args) => {
+      if (failure === "commit" ? args[0] === paths[0] : path.basename(file) === failure) throw new Error("Fixture write failure");
+      return original(file, ...args);
+    });
+    await assert.rejects(dream.dreamProject(f.slug, f.options), /Fixture write failure/);
+    assert.deepEqual(await Promise.all(paths.map((name) => fs.readFile(name, "utf8"))), before);
+    assert.equal((await fs.readdir(f.project)).some((name) => name.startsWith(".dream-")), false);
+  });
+}

package/test/mcp-params.test.cjs

@@ -41,26 +41,26 @@ test("MCP server rejects calls that would succeed but misbehave", async (t) => {
   assert.equal(eventWrite.isError, true);
   assert.match(resultText(eventWrite), /append-only/);
 
-  const noCues = await client.callTool({
+  const noKeywords = await client.callTool({
     name: "append_event",
-    arguments: { title: "Missing cues", content: "Unsearchable.", sync: false },
+    arguments: { title: "Missing keywords", content: "Unsearchable.", sync: false },
   });
-  assert.equal(noCues.isError, true);
+  assert.equal(noKeywords.isError, true);
 
-  const tooManyCues = await client.callTool({
+  const tooManyKeywords = await client.callTool({
     name: "append_event",
     arguments: {
-      title: "Too many cues",
-      cues: Array.from({ length: 9 }, (_, index) => `cue-${index}`),
+      title: "Too many keywords",
+      keywords: Array.from({ length: 9 }, (_, index) => `keyword-${index}`),
       content: "Too broad.",
       sync: false,
     },
   });
-  assert.equal(tooManyCues.isError, true);
+  assert.equal(tooManyKeywords.isError, true);
 
   const noTitle = await client.callTool({
     name: "append_event",
-    arguments: { title: " ", cues: ["untitled"], content: "No heading.", sync: false },
+    arguments: { title: " ", keywords: ["untitled"], content: "No heading.", sync: false },
   });
   assert.equal(noTitle.isError, true);
 
@@ -73,8 +73,8 @@ test("MCP server rejects calls that would succeed but misbehave", async (t) => {
 
   const valid = await client.callTool({
     name: "append_event",
-    arguments: { title: "Valid event", cues: ["valid-cue"], content: "Indexed.", projectRoot, sync: false },
+    arguments: { title: "Valid event", keywords: ["valid-keyword"], content: "Indexed.", projectRoot, sync: false },
   });
   assert.notEqual(valid.isError, true);
-  assert.deepEqual(JSON.parse(resultText(valid)).cues, ["valid-cue"]);
+  assert.deepEqual(JSON.parse(resultText(valid)).keywords, ["valid-keyword"]);
 });

package/test/memory-efficiency.test.cjs

@@ -76,7 +76,6 @@ test("search uses indexed events and returns coherent evidence", async (t) => {
   const projectRoot = path.join(tempRoot, "search-project");
 
   process.env.HIPPOCAMP_GLOBAL_ROOT = lagoonRoot;
-  await fs.mkdir(projectRoot, { recursive: true });
   t.after(async () => {
     if (originalRoot === undefined) {
       delete process.env.HIPPOCAMP_GLOBAL_ROOT;
@@ -88,7 +87,7 @@ test("search uses indexed events and returns coherent evidence", async (t) => {
 
   await memory.appendEvent({
     content: "Decision:\nUse indexed search only.",
-    cues: ["strict-index"],
+    keywords: ["strict-index"],
     date: "2026-09-21",
     projectRoot,
     scope: "project",
@@ -109,7 +108,7 @@ test("search uses indexed events and returns coherent evidence", async (t) => {
 
   await memory.appendEvent({
     content: `Decision:\n${"x".repeat(1300)}`,
-    cues: ["oversized-metadata"],
+    keywords: ["oversized-metadata"],
     date: "2026-09-21",
     projectRoot,
     scope: "project",
@@ -124,7 +123,9 @@ test("search uses indexed events and returns coherent evidence", async (t) => {
     scope: "project",
   });
 
-  assert.deepEqual(oversized.results, []);
+  // A keyword-only match still returns whole paragraphs; the oversized run is left out, never cropped.
+  assert.equal(oversized.results[0]?.heading, "Large metadata-only match");
+  assert.equal(oversized.results[0].snippet, "Decision:");
 
   const projectMemoryRoot = path.join(lagoonRoot, "projects", "search-project");
   await fs.writeFile(
@@ -145,7 +146,7 @@ test("search uses indexed events and returns coherent evidence", async (t) => {
   const eventsRoot = path.join(projectMemoryRoot, "events");
   await fs.writeFile(
     path.join(eventsRoot, "2026-09-20.md"),
-    "# Events: 2026-09-20\n\n## 09:00 — Hidden fallback\n\nCues:\n- quasar-velvet\n\nShould not be scanned.\n",
+    "# Events: 2026-09-20\n\n## 09:00 — Hidden fallback\n\nKeywords:\n- quasar-velvet\n\nShould not be scanned.\n",
     "utf8",
   );
 
@@ -174,11 +175,11 @@ test("search ranks indexed event bodies with typo tolerance", async (t) => {
     await fs.rm(tempRoot, { recursive: true, force: true });
   });
 
-  for (const [title, cues, content] of [
+  for (const [title, keywords, content] of [
     ["Deploy note", ["deploy"], "The zanzibar migration needs a rollback plan."],
     ["Unrelated note", ["billing"], "Invoices are generated monthly."],
   ]) {
-    await memory.appendEvent({ content, cues, projectRoot, scope: "project", sync: false, title });
+    await memory.appendEvent({ content, keywords, projectRoot, scope: "project", sync: false, title });
   }
 
   const search = await memory.searchMemory({ projectRoot, query: "zanzibr rollback", scope: "project" });
@@ -188,6 +189,42 @@ test("search ranks indexed event bodies with typo tolerance", async (t) => {
   assert.equal(search.results[0].match, "body");
 });
 
+test("search still matches events written with legacy Cues sections and indexes", async (t) => {
+  const originalRoot = process.env.HIPPOCAMP_GLOBAL_ROOT;
+  const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "hippocamp-legacy-cues-"));
+  const projectRoot = path.join(tempRoot, "legacy-project");
+  const eventsRoot = path.join(tempRoot, "lagoon", "projects", "legacy-project", "events");
+
+  process.env.HIPPOCAMP_GLOBAL_ROOT = path.join(tempRoot, "lagoon");
+  await fs.mkdir(eventsRoot, { recursive: true });
+  t.after(async () => {
+    if (originalRoot === undefined) {
+      delete process.env.HIPPOCAMP_GLOBAL_ROOT;
+    } else {
+      process.env.HIPPOCAMP_GLOBAL_ROOT = originalRoot;
+    }
+    await fs.rm(tempRoot, { recursive: true, force: true });
+  });
+
+  const id = "2026-09-01T09:00:00.000Z";
+  await fs.writeFile(
+    path.join(eventsRoot, "2026-09-01.md"),
+    `# Events — 2026-09-01\n\n## ${id} — Old note\n\nCues:\n- quasar-velvet\n\nOld body.\n`,
+    "utf8",
+  );
+  await fs.writeFile(
+    path.join(eventsRoot, "2026-09-01.index.json"),
+    JSON.stringify({ version: 1, path: "2026-09-01.md", events: [{ id, heading: "Old note", cues: ["quasar-velvet"] }] }),
+    "utf8",
+  );
+
+  const search = await memory.searchMemory({ projectRoot, query: "quasar velvet", scope: "project" });
+
+  assert.equal(search.results.length, 1);
+  assert.deepEqual(search.results[0].keywords, ["quasar-velvet"]);
+  assert.equal(search.results[0].match, "keywords");
+});
+
 test("search returns whole sentences from an oversized matching paragraph", async (t) => {
   const originalRoot = process.env.HIPPOCAMP_GLOBAL_ROOT;
   const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "hippocamp-long-paragraph-"));
@@ -207,7 +244,7 @@ test("search returns whole sentences from an oversized matching paragraph", asyn
   const filler = "The weekly sync covered routine updates. ".repeat(40);
   await memory.appendEvent({
     content: `${filler}The kestrel database moved to eu-west-3. ${filler}`,
-    cues: ["infra"],
+    keywords: ["infra"],
     projectRoot,
     scope: "project",
     sync: false,
@@ -246,7 +283,7 @@ test("search returns every matching paragraph that fits the excerpt budget", asy
   ];
   await memory.appendEvent({
     content: paragraphs.join("\n\n"),
-    cues: ["infra"],
+    keywords: ["infra"],
     projectRoot,
     scope: "project",
     sync: false,
@@ -282,7 +319,7 @@ test("events appended in the same millisecond keep distinct ids and bodies", asy
   const timestamp = "2026-10-01T09:00:00.000Z";
   const first = await memory.appendEvent({
     content: "The zanzibar migration needs a rollback plan.",
-    cues: ["deploy"],
+    keywords: ["deploy"],
     projectRoot,
     scope: "project",
     sync: false,
@@ -291,7 +328,7 @@ test("events appended in the same millisecond keep distinct ids and bodies", asy
   });
   const second = await memory.appendEvent({
     content: "Invoices are generated monthly.",
-    cues: ["billing"],
+    keywords: ["billing"],
     projectRoot,
     scope: "project",
     sync: false,
@@ -329,7 +366,7 @@ test("parallel appends keep every event", async (t) => {
     Array.from({ length: 20 }, (_, index) =>
       memory.appendEvent({
         content: `Parallel event ${index}.`,
-        cues: ["parallel"],
+        keywords: ["parallel"],
         date: "2026-10-01",
         projectRoot,
         scope: "project",
@@ -366,7 +403,7 @@ test("search favors events from a month named in the query", async (t) => {
   for (const timestamp of ["2026-05-02T08:00:00.000Z", "2026-08-05T10:00:00.000Z", "2026-09-01T09:00:00.000Z"]) {
     await memory.appendEvent({
       content: "Published the Android build to Google Play production.",
-      cues: ["android-release"],
+      keywords: ["android-release"],
       date: timestamp.slice(0, 10),
       projectRoot,
       scope: "project",
@@ -407,7 +444,7 @@ test("search favors events from a relative date named in the query", async (t) =
     await memory.appendEvent({
       // The old event matches the words better, so only the date words can rank the others first.
       content: key === "older" ? "Deploy key rotation: rotated the deploy key again." : "Rotated the key for staging.",
-      cues: ["deploy-key"],
+      keywords: ["deploy-key"],
       date: timestamp.slice(0, 10),
       projectRoot,
       scope: "project",
@@ -448,7 +485,7 @@ test("search returns a snippet for a long event matched only by its date", async
 
   await memory.appendEvent({
     content: Array(30).fill("The weekly sync covered routine updates.").join("\n\n"),
-    cues: ["sync"],
+    keywords: ["sync"],
     date: "2026-08-05",
     projectRoot,
     scope: "project",
@@ -485,7 +522,7 @@ test("search returns nothing when no memory is about the question", async (t) =>
     ["Deploy rollback", "A failed backend deploy rolls back to the previous revision."],
     ["Billing note", "Invoices are generated monthly."],
   ]) {
-    await memory.appendEvent({ content, cues: ["ops"], projectRoot, scope: "project", sync: false, title });
+    await memory.appendEvent({ content, keywords: ["ops"], projectRoot, scope: "project", sync: false, title });
   }
 
   const unrelated = await memory.searchMemory({ projectRoot, query: "which kubernetes namespace does the backend deploy to", scope: "project" });
@@ -498,3 +535,130 @@ test("search returns nothing when no memory is about the question", async (t) =>
   // No event is from August; the month name must not count as a missing topic word.
   assert.ok(monthOnly.results.length > 0);
 });
+
+test("search keeps an event matched only by a keyword its long body never repeats", async (t) => {
+  const originalRoot = process.env.HIPPOCAMP_GLOBAL_ROOT;
+  const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "hippocamp-keyword-only-"));
+  const projectRoot = path.join(tempRoot, "keyword-only-project");
+
+  process.env.HIPPOCAMP_GLOBAL_ROOT = path.join(tempRoot, "lagoon");
+  await fs.mkdir(projectRoot, { recursive: true });
+  t.after(async () => {
+    if (originalRoot === undefined) {
+      delete process.env.HIPPOCAMP_GLOBAL_ROOT;
+    } else {
+      process.env.HIPPOCAMP_GLOBAL_ROOT = originalRoot;
+    }
+    await fs.rm(tempRoot, { recursive: true, force: true });
+  });
+
+  const content = [
+    "Opened three hardening PRs after the security audit.",
+    "The backend PR rotates the cron secret and checks request signatures on every scheduled job. ".repeat(8),
+    "The website PR updates the content studio dependencies and removes an unused preview route. ".repeat(8),
+  ].join("\n\n");
+
+  assert.ok(content.length > 1200);
+  await memory.appendEvent({
+    content,
+    keywords: ["security-audit", "strava-oauth"],
+    projectRoot,
+    scope: "project",
+    sync: false,
+    title: "Security audit opened hardening PRs",
+  });
+
+  const search = await memory.searchMemory({ projectRoot, query: "Strava bug", scope: "project" });
+
+  assert.equal(search.results[0]?.heading, "Security audit opened hardening PRs");
+  assert.match(search.results[0].snippet, /^Opened three hardening PRs/);
+});
+
+test("search returns nothing when a rare word only resembles memory words", async (t) => {
+  const originalRoot = process.env.HIPPOCAMP_GLOBAL_ROOT;
+  const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "hippocamp-lookalike-"));
+  const projectRoot = path.join(tempRoot, "lookalike-project");
+
+  process.env.HIPPOCAMP_GLOBAL_ROOT = path.join(tempRoot, "lagoon");
+  await fs.mkdir(projectRoot, { recursive: true });
+  t.after(async () => {
+    if (originalRoot === undefined) {
+      delete process.env.HIPPOCAMP_GLOBAL_ROOT;
+    } else {
+      process.env.HIPPOCAMP_GLOBAL_ROOT = originalRoot;
+    }
+    await fs.rm(tempRoot, { recursive: true, force: true });
+  });
+
+  await memory.appendEvent({
+    content: "Each worker instance reads the instruct prompt and its content before a sync.",
+    keywords: ["health-sync"],
+    projectRoot,
+    scope: "project",
+    sync: false,
+    title: "Apple Health sync banner hardening",
+  });
+
+  // "instinct" is one typo away from "instance" and "instruct" but means something else.
+  const lookalike = await memory.searchMemory({ projectRoot, query: "Instinct", scope: "project" });
+  const shared = await memory.searchMemory({ projectRoot, query: "context", scope: "project" });
+  const plural = await memory.searchMemory({ projectRoot, query: "worker instances", scope: "project" });
+
+  assert.deepEqual(lookalike.results, []);
+  assert.deepEqual(shared.results, []);
+  assert.equal(plural.results[0]?.heading, "Apple Health sync banner hardening");
+});
+
+test("an empty folder has no project and uses global memory", async (t) => {
+  const originalRoot = process.env.HIPPOCAMP_GLOBAL_ROOT;
+  const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "hippocamp-empty-folder-"));
+  const lagoonRoot = path.join(tempRoot, "lagoon");
+  const emptyRoot = path.join(tempRoot, "billowy-glove");
+  const codeRoot = path.join(tempRoot, "job-search");
+
+  process.env.HIPPOCAMP_GLOBAL_ROOT = lagoonRoot;
+  // Only .git, like a fresh session folder some agents create.
+  await fs.mkdir(path.join(emptyRoot, ".git"), { recursive: true });
+  await fs.mkdir(codeRoot, { recursive: true });
+  await fs.writeFile(path.join(codeRoot, "notes.md"), "Job search notes.\n", "utf8");
+  t.after(async () => {
+    if (originalRoot === undefined) {
+      delete process.env.HIPPOCAMP_GLOBAL_ROOT;
+    } else {
+      process.env.HIPPOCAMP_GLOBAL_ROOT = originalRoot;
+    }
+    await fs.rm(tempRoot, { recursive: true, force: true });
+  });
+
+  const wake = await memory.wakeUp({ projectRoot: emptyRoot });
+  const event = await memory.appendEvent({
+    content: "Created the applying-to-jobs skill.",
+    keywords: ["applying-to-jobs"],
+    projectRoot: emptyRoot,
+    scope: "project",
+    sync: false,
+    title: "Job application skill created",
+  });
+  await memory.appendEvent({
+    content: "Created the applying-to-jobs tracker in Notion.",
+    keywords: ["applying-to-jobs-tracker"],
+    projectRoot: codeRoot,
+    scope: "project",
+    sync: false,
+    title: "Job tracker created",
+  });
+  const fromEmpty = await memory.searchMemory({ projectRoot: emptyRoot, query: "applying to jobs skill" });
+  const projectScope = await memory.searchMemory({ projectRoot: emptyRoot, query: "applying to jobs", scope: "project" });
+  const fromProject = await memory.searchMemory({ projectRoot: codeRoot, query: "applying to jobs skill" });
+
+  assert.equal(wake.projectSlug, null);
+  assert.equal(wake.projectMemoryRoot, lagoonRoot);
+  assert.equal(path.dirname(path.dirname(event.indexPath)), lagoonRoot);
+  // Global memory is searched once, and other projects stay out of it.
+  assert.deepEqual(fromEmpty.results.map((result) => result.heading), ["Job application skill created"]);
+  assert.deepEqual(projectScope.results.map((result) => result.heading), ["Job application skill created"]);
+  assert.equal(fromProject.results[0]?.heading, "Job application skill created");
+  assert.equal(memory.getProjectSlug(codeRoot), "job-search");
+  // A folder that does not exist keeps its name, as Dream's synthetic roots do.
+  assert.equal(memory.getProjectSlug(path.join(tempRoot, "missing")), "missing");
+});

package/test/sync-memory.test.cjs

@@ -29,7 +29,6 @@ test("sync commits when the Lagoon path goes through a symlink", async (t) => {
   });
 
   await fs.mkdir(realLagoon);
-  await fs.mkdir(projectRoot);
   await fs.symlink(realLagoon, linkedLagoon);
   git(["init", "-q", "-b", "main"]);
   git(["commit", "-q", "--allow-empty", "-m", "init"]);
@@ -45,7 +44,7 @@ test("sync commits when the Lagoon path goes through a symlink", async (t) => {
 
   const result = await memory.appendEvent({
     content: "Use advisory locks.",
-    cues: ["locks"],
+    keywords: ["locks"],
     projectRoot,
     scope: "project",
     title: "Queue decision",
@@ -56,12 +55,11 @@ test("sync commits when the Lagoon path goes through a symlink", async (t) => {
 
   // A symlink inside the Lagoon pointing at another project must not be synced as this one.
   const otherProject = path.join(tempRoot, "other-project");
-  await fs.mkdir(otherProject);
   await fs.mkdir(path.join(realLagoon, "projects", "other-project"), { recursive: true });
   await fs.symlink(path.join(realLagoon, "projects", "linked-project", "events"), path.join(realLagoon, "projects", "other-project", "events"));
 
   await assert.rejects(
-    memory.appendEvent({ content: "Cross write.", cues: ["x"], projectRoot: otherProject, scope: "project", title: "Escape" }),
+    memory.appendEvent({ content: "Cross write.", keywords: ["x"], projectRoot: otherProject, scope: "project", title: "Escape" }),
     /escapes the memory root/,
   );
 });