hippocamp 0.2.11 → 0.2.13

package/test/dream-runner.test.cjs

@@ -1,86 +0,0 @@
-const assert = require("node:assert/strict");
-const { execFile } = require("node:child_process");
-const fs = require("node:fs/promises");
-const os = require("node:os");
-const path = require("node:path");
-const { promisify } = require("node:util");
-const test = require("node:test");
-const memory = require("../scripts/hippocamp-memory.cjs");
-
-const exec = promisify(execFile);
-
-test("Dream runner publishes first summaries and skips an unchanged repeat", async (t) => {
-  const root = await fs.mkdtemp(path.join(os.tmpdir(), "hippocamp-runner-test-"));
-  const seed = path.join(root, "seed");
-  const remote = path.join(root, "remote.git");
-  const bin = path.join(root, "bin");
-  const calls = path.join(root, "prs");
-  const preload = path.join(root, "model.cjs");
-  const previousRoot = process.env.HIPPOCAMP_GLOBAL_ROOT;
-  t.after(async () => {
-    if (previousRoot === undefined) delete process.env.HIPPOCAMP_GLOBAL_ROOT;
-    else process.env.HIPPOCAMP_GLOBAL_ROOT = previousRoot;
-    await fs.rm(root, { recursive: true, force: true });
-  });
-  await fs.mkdir(seed);
-  await fs.mkdir(bin);
-  process.env.HIPPOCAMP_GLOBAL_ROOT = seed;
-  await memory.appendEvent({ projectRoot: "/tmp/new-project", scope: "project", sync: false, title: "Confirmed decision", keywords: ["constraint"], content: "Keep production access read-only." });
-  const env = {
-    ...process.env,
-    PATH: `${bin}${path.delimiter}${process.env.PATH}`,
-    GIT_CONFIG_GLOBAL: path.join(root, "gitconfig"),
-    GIT_CONFIG_NOSYSTEM: "1",
-    GITHUB_TOKEN: "fixture",
-    LAGOON_REPOSITORY: "fixture/lagoon",
-    MANIFEST_API_KEY: "fixture",
-    MANIFEST_BASE_URL: "https://model.invalid",
-    HIPPOCAMP_DREAM_AUTO_MERGE: "false",
-    NODE_OPTIONS: `--require=${preload}`,
-    FIXTURE_REMOTE: remote,
-    FIXTURE_CALLS: calls,
-  };
-  await fs.writeFile(env.GIT_CONFIG_GLOBAL, "[user]\nname = Fixture\nemail = fixture@localhost\n");
-  await fs.writeFile(preload, `
-    global.fetch = async () => {
-      const fs = require("node:fs");
-      const path = require("node:path");
-      fs.writeFileSync(path.join(process.env.HIPPOCAMP_GLOBAL_ROOT, "unrelated.md"), "Do not publish this file");
-      return { ok: true, status: 200, text: async () => JSON.stringify({ output_text: JSON.stringify({
-        current_state_md: "# Current State\\n\\n- Keep production access read-only.",
-        open_threads_md: "# Open Threads\\n\\n- Verify deployment."
-      }) }) };
-    };
-  `);
-  await fs.writeFile(path.join(bin, "gh"), `#!${process.execPath}
-    const fs = require("node:fs");
-    const { execFileSync } = require("node:child_process");
-    const args = process.argv.slice(2);
-    if (args[0] === "auth") process.exit(0);
-    if (args[0] === "repo" && args[1] === "clone") {
-      execFileSync("git", ["clone", process.env.FIXTURE_REMOTE, args[3]], { stdio: "inherit" });
-    } else if (args[0] === "pr" && args[1] === "list") {
-      if (fs.existsSync(process.env.FIXTURE_CALLS)) console.log("1");
-    } else if (args[0] === "pr" && args[1] === "create") {
-      fs.appendFileSync(process.env.FIXTURE_CALLS, "created\\n");
-    } else {
-      throw new Error("Unexpected gh operation: " + args.join(" "));
-    }
-  `, { mode: 0o755 });
-  const git = (args, cwd = seed) => exec("git", args, { cwd, env });
-  await git(["init", "-b", "main"]);
-  await git(["add", "."]);
-  await git(["commit", "-m", "Seed indexed evidence without curated files"]);
-  const before = (await git(["rev-parse", "HEAD"])).stdout.trim();
-  await git(["clone", "--bare", seed, remote]);
-  const runner = path.resolve(__dirname, "../assets/railway/run-dream.sh");
-  await exec("bash", [runner], { env });
-  const changed = (await git(["diff", "--name-only", before, "refs/heads/dream/new-project"], remote)).stdout.trim().split("\n");
-  assert.deepEqual(changed, ["projects/new-project/current_state.md", "projects/new-project/open_threads.md"]);
-  assert.match((await git(["show", "dream/new-project:projects/new-project/current_state.md"], remote)).stdout, /hippocamp-dream-through:/);
-  assert.equal(await fs.readFile(calls, "utf8"), "created\n");
-  // Simulate accepting the reviewed PR, then repeat against the same evidence.
-  await git(["update-ref", "refs/heads/main", "refs/heads/dream/new-project"], remote);
-  await exec("bash", [runner], { env });
-  assert.equal(await fs.readFile(calls, "utf8"), "created\n");
-});

package/test/dream.test.cjs

@@ -1,190 +0,0 @@
-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/install-common.test.cjs

@@ -1,129 +0,0 @@
-const test = require("node:test");
-const assert = require("node:assert/strict");
-const { execFileSync } = require("node:child_process");
-const fsSync = require("node:fs");
-const fs = require("node:fs/promises");
-const os = require("node:os");
-const path = require("node:path");
-const { mcpServerCommand, prepareLagoon } = require("../scripts/install-common.cjs");
-
-// CI runners have no Git identity; commits in these tests need one.
-const gitEnv = {
-  GIT_AUTHOR_NAME: "Test",
-  GIT_AUTHOR_EMAIL: "test@example.com",
-  GIT_COMMITTER_NAME: "Test",
-  GIT_COMMITTER_EMAIL: "test@example.com",
-};
-
-// Scoped to each test that needs a Git identity, then restored.
-function useGitIdentity(t) {
-  const saved = Object.fromEntries(Object.keys(gitEnv).map((key) => [key, process.env[key]]));
-  Object.assign(process.env, gitEnv);
-  t.after(() => {
-    for (const [key, value] of Object.entries(saved)) {
-      if (value === undefined) {
-        delete process.env[key];
-      } else {
-        process.env[key] = value;
-      }
-    }
-  });
-}
-
-async function tempDir(t, name) {
-  const root = await fs.mkdtemp(path.join(os.tmpdir(), `hippocamp-${name}-`));
-  t.after(() => fs.rm(root, { recursive: true, force: true, maxRetries: 5 }));
-  return root;
-}
-
-test("mcpServerCommand copies npx installs to a stable folder and keeps source checkouts direct", async (t) => {
-  const root = await tempDir(t, "npx");
-  const modules = path.join(root, "_npx", "abc", "node_modules");
-  const npxRoot = path.join(modules, "hippocamp");
-  const home = path.join(root, "home");
-  await fs.mkdir(path.join(npxRoot, "scripts"), { recursive: true });
-  await fs.mkdir(path.join(modules, "minisearch"), { recursive: true });
-  await fs.writeFile(path.join(npxRoot, "package.json"), '{ "version": "9.9.9" }');
-  await fs.writeFile(path.join(npxRoot, "scripts", "hippocamp-mcp.cjs"), "// server\n");
-  await fs.writeFile(path.join(modules, "minisearch", "index.js"), "// dependency\n");
-
-  const command = mcpServerCommand(npxRoot, home);
-  const stable = path.join(home, ".hippocamp", "9.9.9", "node_modules");
-
-  assert.deepEqual(command, [process.execPath, path.join(stable, "hippocamp", "scripts", "hippocamp-mcp.cjs")]);
-  await fs.stat(command[1]);
-  await fs.stat(path.join(stable, "minisearch", "index.js"));
-
-  // A reinstall of the same version replaces the copy: no stale files, no staging left behind.
-  await fs.writeFile(path.join(stable, "stale.js"), "// old\n");
-  mcpServerCommand(npxRoot, home);
-  await assert.rejects(fs.stat(path.join(stable, "stale.js")));
-  assert.deepEqual(await fs.readdir(path.join(home, ".hippocamp", "9.9.9")), ["node_modules"]);
-
-  const source = path.join(root, "src", "hippocamp");
-  assert.deepEqual(mcpServerCommand(source), [process.execPath, path.join(source, "scripts", "hippocamp-mcp.cjs")]);
-});
-
-test("prepareLagoon creates a missing Lagoon repo and says it is local only", async (t) => {
-  useGitIdentity(t);
-  const lagoon = path.join(await tempDir(t, "lagoon"), "lagoon");
-  const result = await prepareLagoon(lagoon);
-
-  assert.equal(result.created, true);
-  assert.equal(result.push, "no_remote");
-  assert.match(result.hints.join("\n"), /gh repo create lagoon --private/);
-  assert.equal(execFileSync("git", ["rev-parse", "--is-inside-work-tree"], { cwd: lagoon }).toString().trim(), "true");
-});
-
-test("prepareLagoon leaves a non-empty folder that is not a repo alone", async (t) => {
-  const folder = await tempDir(t, "notes");
-  await fs.writeFile(path.join(folder, "notes.md"), "mine\n");
-  const result = await prepareLagoon(folder);
-
-  assert.equal(result.push, "not_git");
-  await assert.rejects(fs.stat(path.join(folder, ".git")));
-});
-
-test("prepareLagoon checks push to an existing remote", async (t) => {
-  useGitIdentity(t);
-  const root = await tempDir(t, "remote");
-  const remote = path.join(root, "remote.git");
-  const lagoon = path.join(root, "lagoon");
-  execFileSync("git", ["init", "--bare", "-b", "main", remote]);
-  execFileSync("git", ["init", "-b", "main", lagoon]);
-  execFileSync("git", ["commit", "--allow-empty", "-m", "init"], { cwd: lagoon });
-  execFileSync("git", ["remote", "add", "origin", remote], { cwd: lagoon });
-  execFileSync("git", ["push", "-u", "origin", "main"], { cwd: lagoon, stdio: "ignore" });
-
-  const result = await prepareLagoon(lagoon);
-
-  assert.equal(result.created, false);
-  assert.equal(result.remote, remote);
-  assert.equal(result.push, "ok");
-});
-
-test("prepareLagoon refuses a folder inside another repo", async (t) => {
-  useGitIdentity(t);
-  const parent = await tempDir(t, "parent");
-  execFileSync("git", ["init", "-b", "main", parent]);
-  const nested = path.join(parent, "notes");
-  await fs.mkdir(nested);
-  await fs.writeFile(path.join(nested, "a.md"), "x\n");
-
-  const result = await prepareLagoon(nested);
-
-  assert.equal(result.push, "not_git");
-  await assert.rejects(fs.stat(path.join(nested, ".git")));
-});
-
-test("prepareLagoon gives an empty folder inside another repo its own repo", async (t) => {
-  useGitIdentity(t);
-  const parent = await tempDir(t, "parent-empty");
-  execFileSync("git", ["init", "-b", "main", parent]);
-  const nested = path.join(parent, "lagoon");
-
-  const result = await prepareLagoon(nested);
-
-  assert.equal(result.created, true);
-  assert.equal(fsSync.realpathSync(execFileSync("git", ["rev-parse", "--show-toplevel"], { cwd: nested }).toString().trim()), fsSync.realpathSync(nested));
-});

package/test/mcp-params.test.cjs

@@ -1,80 +0,0 @@
-const assert = require("node:assert/strict");
-const { execFileSync } = require("node:child_process");
-const fs = require("node:fs/promises");
-const os = require("node:os");
-const path = require("node:path");
-const test = require("node:test");
-
-const { Client } = require("@modelcontextprotocol/sdk/client/index.js");
-const { StdioClientTransport } = require("@modelcontextprotocol/sdk/client/stdio.js");
-
-function resultText(result) {
-  return result.content.map((item) => item.text).join("\n");
-}
-
-test("MCP server rejects calls that would succeed but misbehave", async (t) => {
-  const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "hippocamp-mcp-params-"));
-  const lagoonRoot = path.join(tempRoot, "lagoon");
-  const projectRoot = path.join(tempRoot, "params-project");
-
-  await fs.mkdir(projectRoot, { recursive: true });
-  execFileSync("git", ["init", "-q", projectRoot]);
-
-  const client = new Client({ name: "hippocamp-test", version: "0.0.0" });
-  await client.connect(
-    new StdioClientTransport({
-      command: process.execPath,
-      args: [path.join(__dirname, "..", "scripts", "hippocamp-mcp.cjs")],
-      cwd: projectRoot,
-      env: { ...process.env, HIPPOCAMP_GLOBAL_ROOT: lagoonRoot, HIPPOCAMP_PROJECT_ROOT: projectRoot },
-    }),
-  );
-  t.after(async () => {
-    await client.close();
-    await fs.rm(tempRoot, { recursive: true, force: true });
-  });
-
-  const eventWrite = await client.callTool({
-    name: "write_memory_file",
-    arguments: { scope: "project", path: "events/2026-09-29.md", content: "## Bypass\n\nNo index.", sync: false },
-  });
-  assert.equal(eventWrite.isError, true);
-  assert.match(resultText(eventWrite), /append-only/);
-
-  const noKeywords = await client.callTool({
-    name: "append_event",
-    arguments: { title: "Missing keywords", content: "Unsearchable.", sync: false },
-  });
-  assert.equal(noKeywords.isError, true);
-
-  const tooManyKeywords = await client.callTool({
-    name: "append_event",
-    arguments: {
-      title: "Too many keywords",
-      keywords: Array.from({ length: 9 }, (_, index) => `keyword-${index}`),
-      content: "Too broad.",
-      sync: false,
-    },
-  });
-  assert.equal(tooManyKeywords.isError, true);
-
-  const noTitle = await client.callTool({
-    name: "append_event",
-    arguments: { title: " ", keywords: ["untitled"], content: "No heading.", sync: false },
-  });
-  assert.equal(noTitle.isError, true);
-
-  const wrongProject = await client.callTool({
-    name: "wake_up",
-    arguments: { projectRoot: path.join(tempRoot, "missing-project") },
-  });
-  assert.equal(wrongProject.isError, true);
-  assert.match(resultText(wrongProject), /Git repository/);
-
-  const valid = await client.callTool({
-    name: "append_event",
-    arguments: { title: "Valid event", keywords: ["valid-keyword"], content: "Indexed.", projectRoot, sync: false },
-  });
-  assert.notEqual(valid.isError, true);
-  assert.deepEqual(JSON.parse(resultText(valid)).keywords, ["valid-keyword"]);
-});