@ghilteras/opencode-agent-memory 2.0.0 → 2.0.1

package/README.md

@@ -32,7 +32,7 @@ Add to your OpenCode config (`~/.config/opencode/opencode.json`):
 
 ```json
 {
-  "plugins": ["@ghilteras/opencode-agent-memory@2.0.0"]
+  "plugins": ["@ghilteras/opencode-agent-memory@2.0.1"]
 }
 ```
 
@@ -74,7 +74,7 @@ Entries are markdown files with YAML frontmatter in `~/.config/opencode/journal/
 ---
 title: "Reasoning-pruner wiring"
 created: 2026-09-21T18:16:11.300Z
-project: /home/angelo/homelab-config
+project: /path/to/project
 model: deepseek-v4.1-flash
 provider: opencode-go
 agent: executor
@@ -113,7 +113,7 @@ By default the transformers.js model cache lives in the default location (`~/.ca
 
 ```json
 {
-  "cacheDir": "/home/angelo/.cache/opencode/memory-model",
+  "cacheDir": "~/.cache/opencode/memory-model",
   "journal": {
     "enabled": true
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ghilteras/opencode-agent-memory",
-  "version": "2.0.0",
+  "version": "2.0.1",
   "description": "Journal-only memory plugin for OpenCode: tagged, searchable, append-only journal with semantic search.",
   "author": "Angelo Pantano <ghilteras@protonmail.com>",
   "license": "MIT",
@@ -13,9 +13,7 @@
   },
   "main": "src/plugin.ts",
   "type": "module",
-  "files": [
-    "src"
-  ],
+  "files": ["src", "!src/**/*.test.ts", "!src/test-suite.test.ts"],
   "scripts": {
     "test": "bun run test:core && bun run test:plugin",
     "test:core": "bun test src/test-suite.test.ts src/doctor.test.ts src/embeddings.test.ts src/tools.test.ts src/journal.test.ts",

package/src/doctor.test.ts

@@ -1,183 +0,0 @@
-import { afterEach, expect, test } from "bun:test";
-import * as fs from "node:fs/promises";
-import * as os from "node:os";
-import * as path from "node:path";
-import { diagnoseJournal } from "./doctor";
-
-const roots: string[] = [];
-async function fixture() {
-  const root = await fs.mkdtemp(path.join(os.tmpdir(), "journal-doctor-"));
-  roots.push(root);
-  await fs.mkdir(path.join(root, "journal"));
-  return path.join(root, "journal");
-}
-async function entry(dir: string, name: string, yamlText?: string, sidecar?: string) {
-  await fs.writeFile(path.join(dir, `${name}.md`), yamlText === undefined ? "plain text" : `---\n${yamlText}\n---\nbody\n`);
-  if (sidecar !== undefined) await fs.writeFile(path.join(dir, `${name}.embedding`), sidecar);
-}
-afterEach(async () => { await Promise.all(roots.splice(0).map((root) => fs.rm(root, { recursive: true, force: true }))); });
-
-test("classifies frontmatter, created values, sidecars and multiple findings deterministically", async () => {
-  const dir = await fixture();
-  const valid = 'title: Good\ncreated: "2025-01-01T00:00:00Z"';
-  await entry(dir, "00-valid", valid, JSON.stringify({ v: 2, model: "wrong-model", dimension: 2, vector: [0.1, 0.2] }));
-  await entry(dir, "01-missing-title", "created: \"2025-01-01\"");
-  await entry(dir, "02-empty-title", 'title: ""');
-  await entry(dir, "03-wrong-title", "title: 42");
-  await entry(dir, "04-missing-created", "title: Present", "[1,2]");
-  await entry(dir, "05-date-only", "title: Present\ndate: \"2025-01-01\"");
-  await entry(dir, "06-invalid-created", 'title: Present\ncreated: "not a date"');
-  await entry(dir, "07-wrong-created", "title: Present\ncreated: 42");
-  await entry(dir, "08-yaml-timestamp", "title: Present\ncreated: 2025-01-01T00:00:00Z");
-  await entry(dir, "09-bad-yaml", "title: [broken");
-  await entry(dir, "10-no-frontmatter");
-  await entry(dir, "11-malformed-json", valid, "{");
-  await entry(dir, "12-vector-type", valid, '{"v":2,"model":"m","dimension":1,"vector":["x"]}');
-  await entry(dir, "13-empty-vector", valid, '{"v":2,"model":"m","dimension":0,"vector":[]}');
-  await entry(dir, "14-vector-dimension", valid, '{"v":2,"model":"m","dimension":3,"vector":[1,2]}');
-  await entry(dir, "15-legacy", valid, "[1,2]");
-  await entry(dir, "16-legacy-invalid", valid, '[1,"x"]');
-  await entry(dir, "17-missing-sidecar", valid);
-
-  const inventory = async () => Promise.all((await fs.readdir(dir)).sort().map(async (f) => [f, await fs.readFile(path.join(dir, f)), (await fs.stat(path.join(dir, f))).mtimeMs] as const));
-  const before = await inventory();
-  const report = await diagnoseJournal(path.dirname(dir));
-  expect(await diagnoseJournal(path.dirname(dir))).toEqual(report);
-  expect(report.counts.files).toBe(18);
-  const codes = (name: string) => report.findings.filter((f) => f.path.startsWith(name)).map((f) => f.code);
-  expect(codes("01-missing-title")).toContain("frontmatter_title_invalid");
-  expect(codes("02-empty-title")).toContain("frontmatter_title_invalid");
-  expect(codes("03-wrong-title")).toContain("frontmatter_title_invalid");
-  expect(codes("04-missing-created")).toContain("created_missing");
-  expect(codes("05-date-only")).toContain("created_missing");
-  expect(codes("06-invalid-created")).toContain("created_invalid");
-  expect(codes("07-wrong-created")).toContain("frontmatter_created_invalid");
-  expect(codes("08-yaml-timestamp")).toContain("frontmatter_created_invalid");
-  expect(codes("09-bad-yaml")).toContain("yaml_malformed");
-  expect(codes("10-no-frontmatter")).toContain("frontmatter_missing_or_malformed");
-  expect(codes("11-malformed-json")).toContain("embedding_json_malformed");
-  for (const name of ["12-vector-type", "13-empty-vector", "14-vector-dimension", "16-legacy-invalid"]) expect(codes(name)).toContain("embedding_invalid");
-  expect(codes("00-valid")).toContain("embedding_incompatible");
-  expect(codes("15-legacy")).toContain("embedding_model_unknown");
-  expect(codes("17-missing-sidecar")).toContain("embedding_missing");
-  expect(codes("04-missing-created")).toEqual(expect.arrayContaining(["created_missing", "embedding_model_unknown"]));
-  expect(report.findings).toEqual([...report.findings].sort((a, b) => a.path.localeCompare(b.path) || a.code.localeCompare(b.code) || a.severity.localeCompare(b.severity)));
-  expect(report.findings.some((f) => /broken|Good|Present|not a date/.test(JSON.stringify(f)))).toBe(false);
-  expect(await inventory()).toEqual(before);
-});
-
-test("empty, missing, and injected unreadable roots/files have explicit incomplete semantics", async () => {
-  const missing = await diagnoseJournal("/path/that/does/not/exist");
-  expect(missing.complete).toBe(false);
-  expect(missing.findings[0]?.code).toBe("root_unreadable");
-  const dir = await fixture();
-  expect((await diagnoseJournal(path.dirname(dir))).complete).toBe(true);
-  await entry(dir, "a", "title: A"); await entry(dir, "b", "title: B");
-  const failingRead = { ...fs, readFile: async (p: Parameters<typeof fs.readFile>[0], ...args: any[]) => {
-    if (String(p).endsWith("a.md")) throw new Error("injected");
-    return fs.readFile(p, ...(args as [any]));
-  } } as unknown as typeof fs;
-  const report = await diagnoseJournal(path.dirname(dir), failingRead);
-  expect(report.complete).toBe(false);
-  expect(report.findings.some((f) => f.path === "a.md" && f.code === "file_unreadable")).toBe(true);
-  expect(report.findings.some((f) => f.path === "b.md" && f.code === "created_missing")).toBe(true);
-});
-
-test("CLI emits exact bytes and exit codes for clean, warning, error, incomplete and bad invocation", async () => {
-  const dir = await fixture();
-  const cli = path.resolve(import.meta.dir, "journal-doctor.ts");
-  const invoke = (...args: string[]) => Bun.spawnSync([process.execPath, "run", cli, ...args], { stdout: "pipe", stderr: "pipe" });
-  const assertCli = (result: ReturnType<typeof invoke>, stdout: string, stderr: string, exitCode: number) =>
-    expect({ stdout: result.stdout.toString(), stderr: result.stderr.toString(), exitCode: result.exitCode }).toEqual({ stdout, stderr, exitCode });
-  assertCli(invoke(path.dirname(dir)), '{"complete":true,"counts":{"files":0,"errors":0,"warnings":0},"findings":[]}\n', "", 0);
-
-  await entry(dir, "warning", 'title: Warn\ncreated: "2025-01-01"');
-  assertCli(invoke(path.dirname(dir)), '{"complete":true,"counts":{"files":1,"errors":0,"warnings":1},"findings":[{"path":"warning.embedding","code":"embedding_missing","severity":"warning"}]}\n', "", 0);
-
-  await entry(dir, "invalid", "title: 12");
-  assertCli(invoke(path.dirname(dir)), '{"complete":true,"counts":{"files":2,"errors":1,"warnings":2},"findings":[{"path":"invalid.embedding","code":"embedding_missing","severity":"warning"},{"path":"invalid.md","code":"frontmatter_title_invalid","severity":"error"},{"path":"warning.embedding","code":"embedding_missing","severity":"warning"}]}\n', "", 1);
-
-  assertCli(invoke("/path/that/does/not/exist"), '{"complete":false,"counts":{"files":0,"errors":1,"warnings":0},"findings":[{"path":".","code":"root_unreadable","severity":"error"}]}\n', "", 2);
-  assertCli(invoke(path.dirname(dir), "extra"), "", "usage: bun run journal:doctor [config-dir]\n", 2);
-});
-
-test("inventories orphan and associated sidecars independently and emits stable full report", async () => {
-  const dir = await fixture();
-  const valid = 'title: Good\ncreated: "2025-01-01T00:00:00Z"';
-  await entry(dir, "A", valid);
-  await entry(dir, "a", valid, "{");
-  await fs.writeFile(path.join(dir, "_.embedding"), "{");
-  const expected = { complete: true, counts: { files: 2, errors: 2, warnings: 2 }, findings: [
-    { path: "A.embedding", code: "embedding_missing", severity: "warning" },
-    { path: "_.embedding", code: "embedding_json_malformed", severity: "error" },
-    { path: "_.embedding", code: "embedding_orphan", severity: "warning" },
-    { path: "a.embedding", code: "embedding_json_malformed", severity: "error" },
-  ] };
-  const report = await diagnoseJournal(path.dirname(dir));
-  expect(JSON.stringify(report)).toBe(JSON.stringify(expected));
-  const cli = path.resolve(import.meta.dir, "journal-doctor.ts");
-  const result = Bun.spawnSync([process.execPath, "run", cli, path.dirname(dir)], { stdout: "pipe", stderr: "pipe" });
-  expect({ stdout: result.stdout.toString(), stderr: result.stderr.toString(), exitCode: result.exitCode }).toEqual({ stdout: `${JSON.stringify(expected)}\n`, stderr: "", exitCode: 1 });
-});
-
-test("sidecar validation survives markdown read failure; listed sidecar disappearance is incomplete", async () => {
-  const dir = await fixture();
-  await entry(dir, "a", 'title: Good\ncreated: "2025-01-01T00:00:00Z"', "{");
-  const failingRead = { ...fs, readFile: async (p: Parameters<typeof fs.readFile>[0], ...args: any[]) => {
-    if (String(p).endsWith("a.md")) throw Object.assign(new Error("denied"), { code: "EACCES" });
-    return fs.readFile(p, ...(args as [any]));
-  } } as unknown as typeof fs;
-  const failed = await diagnoseJournal(path.dirname(dir), failingRead);
-  expect(failed.complete).toBe(false);
-  expect(failed.findings.map((f) => f.code)).toEqual(expect.arrayContaining(["file_unreadable", "embedding_json_malformed"]));
-
-  let removed = false;
-  const disappearing = { ...fs, readFile: async (p: Parameters<typeof fs.readFile>[0], ...args: any[]) => {
-    if (String(p).endsWith("a.embedding") && !removed) { removed = true; throw Object.assign(new Error("gone"), { code: "ENOENT" }); }
-    return fs.readFile(p, ...(args as [any]));
-  } } as unknown as typeof fs;
-  const gone = await diagnoseJournal(path.dirname(dir), disappearing);
-  expect(gone.complete).toBe(false);
-  expect(gone.findings.some((f) => f.path === "a.embedding" && f.code === "embedding_unreadable")).toBe(true);
-});
-
-test("diagnosis never initializes model pipeline or fetches, while warmup activates trap in child", async () => {
-  const dir = await fixture();
-  await entry(dir, "a", 'title: Good\ncreated: "2025-01-01T00:00:00Z"');
-  const childCode = `
-    import { mock } from "bun:test";
-    let pipelines = 0, fetches = 0;
-    const originalFetch = globalThis.fetch;
-    globalThis.fetch = async (...args) => { fetches++; throw new Error("FETCH_SENTINEL"); };
-    mock.module("@huggingface/transformers", () => ({ pipeline: async () => { pipelines++; throw new Error("PIPELINE_SENTINEL"); } }));
-    const { diagnoseJournal } = await import(${JSON.stringify(path.resolve(import.meta.dir, "doctor.ts"))});
-    const { warmupEmbedder } = await import(${JSON.stringify(path.resolve(import.meta.dir, "embeddings.ts"))});
-    await diagnoseJournal(${JSON.stringify(path.dirname(dir))});
-    if (pipelines !== 0 || fetches !== 0) throw new Error("diagnosis activated model/fetch trap");
-    try { await warmupEmbedder(); throw new Error("pipeline sentinel was not caught"); } catch (error) { if (!String(error).includes("PIPELINE_SENTINEL")) throw error; }
-    if (pipelines !== 1 || fetches !== 0) throw new Error("pipeline trap count mismatch");
-    globalThis.fetch = originalFetch;
-    console.log(JSON.stringify({ pipelines, fetches }));
-  `;
-  const result = Bun.spawnSync([process.execPath, "-e", childCode], { stdout: "pipe", stderr: "pipe" });
-  expect({ stdout: result.stdout.toString(), stderr: result.stderr.toString(), exitCode: result.exitCode }).toEqual({ stdout: '{"pipelines":1,"fetches":0}\n', stderr: "", exitCode: 0 });
-});
-
-test("only flat regular inventory files are read and each sidecar is read once", async () => {
-  const dir = await fixture();
-  await entry(dir, "a", 'title: Good\ncreated: "2025-01-01T00:00:00Z"', "[1]");
-  await fs.mkdir(path.join(dir, "nested"));
-  await fs.writeFile(path.join(dir, "nested", "hidden.md"), "bad");
-  await fs.writeFile(path.join(dir, "nested", "hidden.embedding"), "{");
-  await fs.writeFile(path.join(dir, "ignored.txt"), "bad");
-  await fs.symlink(path.join(dir, "a.md"), path.join(dir, "linked.md"));
-  const reads = new Map<string, number>();
-  const counting = { ...fs, readFile: async (p: Parameters<typeof fs.readFile>[0], ...args: any[]) => {
-    const name = path.basename(String(p)); reads.set(name, (reads.get(name) ?? 0) + 1);
-    return fs.readFile(p, ...(args as [any]));
-  } } as unknown as typeof fs;
-  const report = await diagnoseJournal(path.dirname(dir), counting);
-  expect(report.counts.files).toBe(1);
-  expect([...reads.entries()].sort()).toEqual([["a.embedding", 1], ["a.md", 1]]);
-  expect(report.findings.map((f) => f.path)).toEqual(["a.embedding", "a.embedding"]);
-});

package/src/embeddings.test.ts

@@ -1,47 +0,0 @@
-import { describe, expect, test } from "bun:test";
-
-import {
-  EMBEDDING_DIMENSION,
-  cosineSimilarity,
-  embeddingModelName,
-  getEmbeddingDimension,
-} from "./embeddings";
-
-describe("embeddings", () => {
-  test("getEmbeddingDimension returns 384", () => {
-    expect(getEmbeddingDimension()).toBe(384);
-    expect(EMBEDDING_DIMENSION).toBe(384);
-  });
-
-  test("embeddingModelName returns the multilingual model", () => {
-    expect(embeddingModelName()).toBe(
-      "Xenova/paraphrase-multilingual-MiniLM-L12-v2",
-    );
-  });
-
-  test("cosineSimilarity throws on dimension mismatch", () => {
-    expect(() => cosineSimilarity([1, 2, 3], [1, 2, 3, 4])).toThrow(
-      /dimension mismatch/i,
-    );
-  });
-
-  test("versioned embedding round-trip serializes and parses back", () => {
-    const vector = Array.from(
-      { length: EMBEDDING_DIMENSION },
-      (_, i) => Math.sin(i),
-    );
-    const serialized = JSON.stringify({
-      v: 2,
-      model: embeddingModelName(),
-      dimension: EMBEDDING_DIMENSION,
-      vector,
-    });
-
-    const parsed = JSON.parse(serialized);
-    expect(parsed.v).toBe(2);
-    expect(parsed.model).toBe(embeddingModelName());
-    expect(parsed.dimension).toBe(EMBEDDING_DIMENSION);
-    expect(parsed.vector).toEqual(vector);
-    expect(parsed.vector.length).toBe(EMBEDDING_DIMENSION);
-  });
-});

package/src/journal.test.ts

@@ -1,638 +0,0 @@
-import { afterEach, beforeAll, describe, expect, mock, test } from "bun:test";
-import * as fs from "node:fs/promises";
-import * as path from "node:path";
-import * as realEmbeddings from "./embeddings";
-import NativeMiniSearch from "minisearch";
-
-let embeddingGenerationCalls = 0;
-let lexicalIndexConstructions = 0;
-
-class CountingMiniSearch extends (NativeMiniSearch as any) {
-  constructor(...args: any[]) {
-    super(...args);
-    lexicalIndexConstructions++;
-  }
-}
-
-mock.module("minisearch", () => ({ default: CountingMiniSearch }));
-
-// Mock the embeddings module to avoid downloading a real model in tests.
-// Spread the real module so every export not overridden here keeps its real
-// value regardless of test-file discovery order.
-mock.module("./embeddings", () => ({
-  ...realEmbeddings,
-  generateEmbedding: async () => {
-    embeddingGenerationCalls++;
-    return Array.from({ length: 8 }, (_, i) => i / 8);
-  },
-  EMBEDDING_DIMENSION: 8,
-  embeddingModelName: () => "test-model",
-}));
-
-async function mkTmpDir(): Promise<string> {
-  return fs.mkdtemp(path.join("/tmp/", "opencode-journal-"));
-}
-
-// Bind the journal module AFTER the embeddings mock registration (above) via
-// dynamic import, so the store uses the fake embeddings regardless of bun's
-// module-mock rewiring semantics; a static import would be hoisted above it.
-let createJournalStore!: (typeof import("./journal"))["createJournalStore"];
-let loadConfig!: (typeof import("./journal"))["loadConfig"];
-
-beforeAll(async () => {
-  ({ createJournalStore, loadConfig } = await import("./journal"));
-});
-
-describe("loadConfig", () => {
-  test("classifies a missing file and returns an empty config", async () => {
-    const dir = await mkTmpDir();
-    const loaded = await loadConfig(dir);
-    expect(loaded.status).toBe("missing");
-    expect(loaded.config).toEqual({});
-  });
-
-  test("classifies an unreadable file and returns an empty config", async () => {
-    const dir = await mkTmpDir();
-    await fs.mkdir(path.join(dir, "agent-memory.json"));
-    const loaded = await loadConfig(dir);
-    expect(loaded.status).toBe("unreadable");
-    expect(loaded.config).toEqual({});
-  });
-
-  test("classifies malformed JSON and returns an empty config", async () => {
-    const dir = await mkTmpDir();
-    await fs.writeFile(path.join(dir, "agent-memory.json"), "not json{{{");
-    const loaded = await loadConfig(dir);
-    expect(loaded.status).toBe("malformed");
-    expect(loaded.config).toEqual({});
-  });
-
-  test("classifies schema-invalid JSON and returns an empty config", async () => {
-    const dir = await mkTmpDir();
-    await fs.writeFile(
-      path.join(dir, "agent-memory.json"),
-      JSON.stringify({ journal: { enabled: "yes" } }),
-    );
-    const loaded = await loadConfig(dir);
-    expect(loaded.status).toBe("invalid");
-    expect(loaded.config).toEqual({});
-  });
-
-  test("rejects an unrecognized journal key instead of silently enabling", async () => {
-    const dir = await mkTmpDir();
-    await fs.writeFile(path.join(dir, "agent-memory.json"), JSON.stringify({ journal: { enabled_: false } }));
-    const loaded = await loadConfig(dir);
-    expect(loaded.status).toBe("invalid");
-    expect(loaded.config).toEqual({});
-  });
-
-  test("classifies valid disabled config without changing it", async () => {
-    const dir = await mkTmpDir();
-    await fs.writeFile(
-      path.join(dir, "agent-memory.json"),
-      JSON.stringify({ journal: { enabled: false } }),
-    );
-    const loaded = await loadConfig(dir);
-    expect(loaded.status).toBe("ok");
-    expect(loaded.config).toEqual({ journal: { enabled: false } });
-  });
-
-  test("classifies valid enabled config without changing it", async () => {
-    const dir = await mkTmpDir();
-    await fs.writeFile(
-      path.join(dir, "agent-memory.json"),
-      JSON.stringify({ journal: { enabled: true } }),
-    );
-    const loaded = await loadConfig(dir);
-    expect(loaded.status).toBe("ok");
-    expect(loaded.config).toEqual({ journal: { enabled: true } });
-  });
-
-  test("returns custom tags from config", async () => {
-    const dir = await mkTmpDir();
-    await fs.writeFile(
-      path.join(dir, "agent-memory.json"),
-      JSON.stringify({
-        journal: {
-          enabled: true,
-          tags: [
-            { name: "perf", description: "Performance optimization work" },
-            { name: "debug", description: "Debugging sessions" },
-          ],
-        },
-      }),
-    );
-    const loaded = await loadConfig(dir);
-    expect(loaded.config.journal?.tags).toEqual([
-      { name: "perf", description: "Performance optimization work" },
-      { name: "debug", description: "Debugging sessions" },
-    ]);
-  });
-});
-
-describe("journal store", () => {
-  let tmpDir: string;
-
-  afterEach(async () => {
-    embeddingGenerationCalls = 0;
-    lexicalIndexConstructions = 0;
-    if (tmpDir) {
-      await fs.rm(tmpDir, { recursive: true, force: true });
-    }
-  });
-
-  test("write creates entry file with correct metadata", async () => {
-    tmpDir = await mkTmpDir();
-    const store = createJournalStore(tmpDir);
-
-    const entry = await store.write({
-      title: "Test insight",
-      body: "Discovered an interesting pattern.",
-      project: "/home/user/project",
-      model: "claude-opus-4-6",
-      provider: "anthropic",
-      tags: ["testing"],
-    });
-
-    expect(entry.title).toBe("Test insight");
-    expect(entry.project).toBe("/home/user/project");
-    expect(entry.model).toBe("claude-opus-4-6");
-    expect(entry.provider).toBe("anthropic");
-    expect(entry.tags).toEqual(["testing"]);
-    expect(entry.body).toBe("Discovered an interesting pattern.");
-    expect(entry.id).toMatch(/^\d{8}-\d{6}-\d{3}$/);
-
-    // Verify file exists
-    const raw = await fs.readFile(entry.filePath, "utf-8");
-    expect(raw).toContain("title: Test insight");
-  });
-
-  test("write generates chronological filenames", async () => {
-    tmpDir = await mkTmpDir();
-    const store = createJournalStore(tmpDir);
-
-    const e1 = await store.write({ title: "First", body: "First entry" });
-    // Small delay to ensure different timestamp
-    await new Promise((r) => setTimeout(r, 5));
-    const e2 = await store.write({ title: "Second", body: "Second entry" });
-
-    expect(e2.id > e1.id).toBe(true);
-  });
-
-  test("write saves embedding file alongside entry", async () => {
-    tmpDir = await mkTmpDir();
-    const store = createJournalStore(tmpDir);
-
-    const entry = await store.write({
-      title: "Embedding test",
-      body: "This should get an embedding.",
-    });
-
-    const embeddingFile = entry.filePath.replace(/\.md$/, ".embedding");
-    const raw = await fs.readFile(embeddingFile, "utf-8");
-    const embedding = JSON.parse(raw);
-    // v0.4.0: versioned embedding object, not a bare array
-    expect(embedding.v).toBe(2);
-    expect(embedding.model).toBe("test-model");
-    expect(embedding.dimension).toBe(8);
-    expect(Array.isArray(embedding.vector)).toBe(true);
-    expect(embedding.vector.length).toBeGreaterThan(0);
-  });
-
-  test("read returns full entry by id", async () => {
-    tmpDir = await mkTmpDir();
-    const store = createJournalStore(tmpDir);
-
-    const written = await store.write({
-      title: "Read test",
-      body: "Read me back.",
-      tags: ["test", "read"],
-    });
-
-    const read = await store.read(written.id);
-    expect(read.title).toBe("Read test");
-    expect(read.body).toBe("Read me back.");
-    expect(read.tags).toEqual(["test", "read"]);
-  });
-
-  test("read throws for nonexistent id", async () => {
-    tmpDir = await mkTmpDir();
-    const store = createJournalStore(tmpDir);
-
-    expect(store.read("99990101-000000-000")).rejects.toThrow(
-      "Journal entry not found",
-    );
-  });
-
-  test("read rejects path traversal", async () => {
-    tmpDir = await mkTmpDir();
-    const store = createJournalStore(tmpDir);
-
-    expect(store.read("../../../etc/passwd")).rejects.toThrow(
-      "Invalid journal entry ID",
-    );
-  });
-
-  test("search with no filters returns recent entries", async () => {
-    tmpDir = await mkTmpDir();
-    const store = createJournalStore(tmpDir);
-
-    await store.write({ title: "Entry 1", body: "First" });
-    await new Promise((r) => setTimeout(r, 5));
-    await store.write({ title: "Entry 2", body: "Second" });
-    await new Promise((r) => setTimeout(r, 5));
-    await store.write({ title: "Entry 3", body: "Third" });
-
-    const result = await store.search({});
-    expect(result.total).toBe(3);
-    expect(result.entries.length).toBe(3);
-    // Newest first (by recency score)
-    expect(result.entries[0]!.title).toBe("Entry 3");
-    expect(result.entries[2]!.title).toBe("Entry 1");
-  });
-
-  test("search filters by tags", async () => {
-    tmpDir = await mkTmpDir();
-    const store = createJournalStore(tmpDir);
-
-    await store.write({
-      title: "Tagged",
-      body: "...",
-      tags: ["rust", "perf"],
-    });
-    await new Promise((r) => setTimeout(r, 5));
-    await store.write({
-      title: "Other",
-      body: "...",
-      tags: ["python"],
-    });
-
-    const result = await store.search({ tags: ["rust"] });
-    expect(result.total).toBe(1);
-    expect(result.entries[0]!.title).toBe("Tagged");
-  });
-
-  test("search filters by project", async () => {
-    tmpDir = await mkTmpDir();
-    const store = createJournalStore(tmpDir);
-
-    await store.write({ title: "Project A", body: "...", project: "/proj/a" });
-    await new Promise((r) => setTimeout(r, 5));
-    await store.write({ title: "Project B", body: "...", project: "/proj/b" });
-
-    const result = await store.search({ project: "/proj/a" });
-    expect(result.total).toBe(1);
-    expect(result.entries[0]!.title).toBe("Project A");
-  });
-
-  test("search combines filters with AND logic", async () => {
-    tmpDir = await mkTmpDir();
-    const store = createJournalStore(tmpDir);
-
-    await store.write({
-      title: "Match",
-      body: "...",
-      tags: ["rust"],
-      project: "/proj/a",
-    });
-    await new Promise((r) => setTimeout(r, 5));
-    await store.write({
-      title: "Wrong tags",
-      body: "...",
-      tags: ["python"],
-      project: "/proj/a",
-    });
-    await new Promise((r) => setTimeout(r, 5));
-    await store.write({
-      title: "Wrong project",
-      body: "...",
-      tags: ["rust"],
-      project: "/proj/b",
-    });
-
-    const result = await store.search({
-      tags: ["rust"],
-      project: "/proj/a",
-    });
-    expect(result.total).toBe(1);
-    expect(result.entries[0]!.title).toBe("Match");
-  });
-
-  test("search respects limit", async () => {
-    tmpDir = await mkTmpDir();
-    const store = createJournalStore(tmpDir);
-
-    for (let i = 0; i < 5; i++) {
-      await store.write({ title: `Entry ${i}`, body: `Body ${i}` });
-      await new Promise((r) => setTimeout(r, 5));
-    }
-
-    const result = await store.search({ limit: 2 });
-    expect(result.entries.length).toBe(2);
-    expect(result.total).toBe(5);
-  });
-
-  test("search supports offset pagination", async () => {
-    tmpDir = await mkTmpDir();
-    const store = createJournalStore(tmpDir);
-
-    for (let i = 0; i < 5; i++) {
-      await store.write({ title: `Entry ${i}`, body: `Body ${i}` });
-      await new Promise((r) => setTimeout(r, 5));
-    }
-
-    const page1 = await store.search({ limit: 2, offset: 0 });
-    expect(page1.entries.length).toBe(2);
-    expect(page1.total).toBe(5);
-    // Newest first
-    expect(page1.entries[0]!.title).toBe("Entry 4");
-    expect(page1.entries[1]!.title).toBe("Entry 3");
-
-    const page2 = await store.search({ limit: 2, offset: 2 });
-    expect(page2.entries.length).toBe(2);
-    expect(page2.total).toBe(5);
-    expect(page2.entries[0]!.title).toBe("Entry 2");
-    expect(page2.entries[1]!.title).toBe("Entry 1");
-
-    const page3 = await store.search({ limit: 2, offset: 4 });
-    expect(page3.entries.length).toBe(1);
-    expect(page3.entries[0]!.title).toBe("Entry 0");
-
-    // Past the end
-    const page4 = await store.search({ limit: 2, offset: 10 });
-    expect(page4.entries.length).toBe(0);
-    expect(page4.total).toBe(5);
-  });
-
-  test("search handles empty journal directory", async () => {
-    tmpDir = await mkTmpDir();
-    const store = createJournalStore(tmpDir);
-
-    const result = await store.search({});
-    expect(result.entries.length).toBe(0);
-    expect(result.total).toBe(0);
-    expect(result.allTags).toEqual([]);
-  });
-
-  test("search returns allTags from all entries regardless of filters", async () => {
-    tmpDir = await mkTmpDir();
-    const store = createJournalStore(tmpDir);
-
-    await store.write({
-      title: "Rust work",
-      body: "...",
-      tags: ["rust", "perf"],
-    });
-    await new Promise((r) => setTimeout(r, 5));
-    await store.write({
-      title: "Python work",
-      body: "...",
-      tags: ["python", "testing"],
-    });
-
-    // Filter to only rust tag — allTags should still include all tags
-    const result = await store.search({ tags: ["rust"] });
-    expect(result.total).toBe(1);
-    expect(result.allTags).toEqual(["perf", "python", "rust", "testing"]);
-  });
-
-  test("search allTags deduplicates across entries", async () => {
-    tmpDir = await mkTmpDir();
-    const store = createJournalStore(tmpDir);
-
-    await store.write({ title: "A", body: "...", tags: ["rust", "perf"] });
-    await new Promise((r) => setTimeout(r, 5));
-    await store.write({ title: "B", body: "...", tags: ["rust", "debugging"] });
-
-    const result = await store.search({});
-    expect(result.allTags).toEqual(["debugging", "perf", "rust"]);
-  });
-
-  test("search by text uses lexical OR matching", async () => {
-    tmpDir = await mkTmpDir();
-    const store = createJournalStore(tmpDir);
-
-    await store.write({
-      title: "Rust performance",
-      body: "Optimized the hot loop using SIMD instructions.",
-    });
-    await new Promise((r) => setTimeout(r, 5));
-    await store.write({
-      title: "Python testing",
-      body: "Set up pytest with coverage reporting.",
-    });
-
-    const result = await store.search({ text: "Rust absentterm" });
-    expect(result.entries.map((entry) => entry.title)).toEqual(["Rust performance"]);
-  });
-
-  test("title query matches terms from the title", async () => {
-    tmpDir = await mkTmpDir();
-    const store = createJournalStore(tmpDir);
-    const entry = await store.write({
-      title: "Agent-memory release delivery channel",
-      body: "Unrelated topics include coastal erosion, orbital mechanics, ceramic glazing, " +
-        "database indexing, ancient trade routes, orchard irrigation, keyboard switches, " +
-        "bird migration, public transit planning, and archival paper chemistry. These notes " +
-        "continue across varied subjects in this deliberately long journal entry. " +
-        "Further unrelated details cover weather instruments, typography, fermentation, " +
-        "geology, woodworking, astronomy, logistics, and museum conservation. The entry is " +
-        "deliberately verbose and does not repeat the title terms in its body, while " +
-        "its title remains the searchable anchor for this regression case.",
-    });
-
-    const result = await store.search({ text: "Agent-memory release delivery channel" });
-    expect(result.entries.some((candidate) => candidate.id === entry.id)).toBe(true);
-  });
-
-  test("lexical matching finds a rare exact token", async () => {
-    tmpDir = await mkTmpDir();
-    const store = createJournalStore(tmpDir);
-    const entry = await store.write({ title: "Unrelated note", body: "The rarelexicaltoken appears here." });
-    const query = "rarelexicaltoken";
-
-    const result = await store.search({ text: query });
-    expect(result.total).toBe(1);
-    expect(result.entries.map((e) => e.id)).toEqual([entry.id]);
-  });
-
-  test("OR matching returns unique matches and stable pagination across identical calls", async () => {
-    tmpDir = await mkTmpDir();
-    const store = createJournalStore(tmpDir);
-    for (let i = 0; i < 4; i++) {
-      await store.write({ title: `Stable ${i}`, body: "sharedtoken searchable" });
-      await new Promise((r) => setTimeout(r, 5));
-    }
-
-    const first = await store.search({ text: "sharedtoken", limit: 2 });
-    const second = await store.search({ text: "sharedtoken", limit: 2 });
-    expect(first.total).toBe(4);
-    expect(second.total).toBe(4);
-    expect(first.entries.map((e) => e.id)).toEqual(second.entries.map((e) => e.id));
-    const next = await store.search({ text: "sharedtoken", limit: 2, offset: 2 });
-    expect([...first.entries, ...next.entries].map((e) => e.id)).toHaveLength(4);
-    expect(new Set([...first.entries, ...next.entries].map((e) => e.id)).size).toBe(4);
-  });
-
-  test("identical text searches reuse the lexical index snapshot", async () => {
-    tmpDir = await mkTmpDir();
-    const store = createJournalStore(tmpDir);
-    await store.write({ title: "Cache token", body: "repeated searchable material" });
-    const before = lexicalIndexConstructions;
-    await store.search({ text: "cache" });
-    expect(lexicalIndexConstructions).toBe(before + 1);
-    await store.search({ text: "cache" });
-    expect(lexicalIndexConstructions).toBe(before + 1);
-  });
-
-  test("adding an entry rebuilds the index and makes it searchable", async () => {
-    tmpDir = await mkTmpDir();
-    const store = createJournalStore(tmpDir);
-    await store.write({ title: "Before", body: "ordinary content" });
-    const before = lexicalIndexConstructions;
-    await store.search({ text: "newlyaddedtoken" });
-    await store.write({ title: "New entry", body: "newlyaddedtoken appears here" });
-    const result = await store.search({ text: "newlyaddedtoken" });
-    expect(lexicalIndexConstructions).toBe(before + 2);
-    expect(result.entries.map((entry) => entry.title)).toEqual(["New entry"]);
-  });
-
-  test("editing entry bytes invalidates the index through the entry stat cache", async () => {
-    tmpDir = await mkTmpDir();
-    const store = createJournalStore(tmpDir);
-    const entry = await store.write({ title: "Editable", body: "old unique phrase" });
-    await store.search({ text: "old" });
-    const before = lexicalIndexConstructions;
-    const original = await fs.readFile(entry.filePath, "utf-8");
-    await new Promise((resolve) => setTimeout(resolve, 5));
-    await fs.writeFile(entry.filePath, original.replace("old unique phrase", "replacementtoken with more bytes"));
-    const oldResult = await store.search({ text: "old" });
-    const newResult = await store.search({ text: "replacementtoken" });
-    expect(lexicalIndexConstructions).toBe(before + 1);
-    expect(oldResult.total).toBe(0);
-    expect(newResult.entries.map((candidate) => candidate.id)).toEqual([entry.id]);
-  });
-
-  test("a metadata filter changing membership rebuilds the lexical index", async () => {
-    tmpDir = await mkTmpDir();
-    const store = createJournalStore(tmpDir);
-    await store.write({ title: "Alpha", body: "sharedfiltertoken", project: "/proj/a" });
-    await new Promise((resolve) => setTimeout(resolve, 5));
-    await store.write({ title: "Beta", body: "sharedfiltertoken", project: "/proj/b" });
-    const before = lexicalIndexConstructions;
-    const a = await store.search({ text: "sharedfiltertoken", project: "/proj/a" });
-    const b = await store.search({ text: "sharedfiltertoken", project: "/proj/b" });
-    expect(lexicalIndexConstructions).toBe(before + 2);
-    expect(a.entries.map((entry) => entry.title)).toEqual(["Alpha"]);
-    expect(b.entries.map((entry) => entry.title)).toEqual(["Beta"]);
-  });
-
-  test("interleaved searches with different filters retain their own index", async () => {
-    tmpDir = await mkTmpDir();
-    const store = createJournalStore(tmpDir);
-    const a = await store.write({ title: "Filtered A", body: "shared interleaved token", project: "/proj/a" });
-    await new Promise((resolve) => setTimeout(resolve, 5));
-    const b = await store.write({ title: "Filtered B", body: "shared interleaved token", project: "/proj/b" });
-    const [resultA, resultB] = await Promise.all([
-      store.search({ text: "interleaved", project: "/proj/a" }),
-      store.search({ text: "interleaved", project: "/proj/b" }),
-    ]);
-    expect(resultA.entries.map((entry) => entry.id)).toEqual([a.id]);
-    expect(resultB.entries.map((entry) => entry.id)).toEqual([b.id]);
-    expect(resultA.total).toBe(1);
-    expect(resultB.total).toBe(1);
-  });
-
-  test("OR rankings and totals match an uncached MiniSearch fixture", async () => {
-    tmpDir = await mkTmpDir();
-    const store = createJournalStore(tmpDir);
-    const docs = [
-      ["Alpha systems", "blue green systems reliability"],
-      ["Green garden", "green plants bloom in spring"],
-      ["Blue ocean", "blue water and marine life"],
-      ["Reliable storage", "systems store durable records"],
-      ["Spring systems", "green systems launch in spring"],
-      ["Marine records", "ocean blue records and data"],
-      ["Durable garden", "plants grow with reliable soil"],
-      ["Data storage", "durable systems for data"],
-      ["Blooming ocean", "spring marine bloom"],
-      ["Record reliability", "reliable records stay durable"],
-    ];
-    const entries = [] as Awaited<ReturnType<typeof store.write>>[];
-    for (const [title, body] of docs) {
-      entries.push(await store.write({ title: title!, body: body! }));
-      await new Promise((resolve) => setTimeout(resolve, 2));
-    }
-    const queries = ["green systems", "blue records", "durable reliable", "spring ocean", "plants data"];
-    for (const text of queries) {
-      const uncached = new NativeMiniSearch({ fields: ["title", "body"], storeFields: ["id"] });
-      uncached.addAll(entries.map((entry) => ({ id: entry.id, title: entry.title, body: entry.body })));
-      const expected = uncached.search(text, { combineWith: "OR" })
-        .map((match) => ({ entry: entries.find((entry) => entry.id === String(match.id))!, score: match.score }))
-        .sort((a, b) => b.score - a.score || b.entry.created.getTime() - a.entry.created.getTime() || (a.entry.id < b.entry.id ? 1 : a.entry.id > b.entry.id ? -1 : 0));
-      const actual = await store.search({ text });
-      expect({ ids: actual.entries.map((entry) => entry.id), total: actual.total }).toEqual({
-        ids: expected.map(({ entry }) => entry.id),
-        total: expected.length,
-      });
-    }
-  });
-
-  test("punctuation-only query falls back to case-insensitive title/body substring matches", async () => {
-    tmpDir = await mkTmpDir();
-    const store = createJournalStore(tmpDir);
-    const titleMatch = await store.write({ title: "!!!", body: "older" });
-    await new Promise((r) => setTimeout(r, 5));
-    const bodyMatch = await store.write({ title: "Other", body: "A marker !!! appears here." });
-    await new Promise((r) => setTimeout(r, 5));
-    await store.write({ title: "No match", body: "ordinary text" });
-    const result = await store.search({ text: "!!!" });
-    expect(result.total).toBe(2);
-    expect(result.entries.map((entry) => entry.id)).toEqual([bodyMatch.id, titleMatch.id]);
-  });
-
-  test("text search does not generate embeddings", async () => {
-    tmpDir = await mkTmpDir();
-    const store = createJournalStore(tmpDir);
-    const entry = await store.write({ title: "Keyword note", body: "the lexicalneedle is here" });
-    const callsBeforeSearch = embeddingGenerationCalls;
-
-    const result = await store.search({ text: "lexicalneedle" });
-    expect(result.entries.map((candidate) => candidate.id)).toEqual([entry.id]);
-    expect(embeddingGenerationCalls - callsBeforeSearch).toBe(0);
-  });
-
-  test("text search matches query terms with OR and orders score, creation time, then id descending", async () => {
-    tmpDir = await mkTmpDir();
-    const store = createJournalStore(tmpDir);
-    const low = await store.write({ title: "Tie", body: "alpha" });
-    await new Promise((resolve) => setTimeout(resolve, 5));
-    const highId = await store.write({ title: "Tie", body: "alpha" });
-    await new Promise((resolve) => setTimeout(resolve, 5));
-    const newest = await store.write({ title: "Tie", body: "beta alpha" });
-    const tiedCreated = "2026-01-01T00:00:00.000Z";
-    for (const entry of [low, highId]) {
-      const original = await fs.readFile(entry.filePath, "utf-8");
-      await fs.writeFile(entry.filePath, original.replace(/^created: .+$/m, `created: '${tiedCreated}'`));
-    }
-
-    const result = await store.search({ text: "alpha beta" });
-    expect(result.entries.map((entry) => entry.id)).toEqual([newest.id, highId.id, low.id]);
-    expect(result.total).toBe(3);
-  });
-
-  test("search without text remains chronological and does not generate embeddings", async () => {
-    tmpDir = await mkTmpDir();
-    const store = createJournalStore(tmpDir);
-    await store.write({ title: "Older", body: "first" });
-    await new Promise((r) => setTimeout(r, 5));
-    await store.write({ title: "Newer", body: "second" });
-    const callsBeforeSearch = embeddingGenerationCalls;
-    const indexesBeforeSearch = lexicalIndexConstructions;
-
-    const result = await store.search({});
-    expect(result.entries.map((entry) => entry.title)).toEqual(["Newer", "Older"]);
-    expect(embeddingGenerationCalls).toBe(callsBeforeSearch);
-    expect(lexicalIndexConstructions).toBe(indexesBeforeSearch);
-  });
-});

package/src/plugin-disabled.test.ts

@@ -1,39 +0,0 @@
-import { expect, mock, test } from "bun:test";
-import * as fs from "node:fs/promises";
-import * as path from "node:path";
-import * as realEmbeddings from "./embeddings";
-
-if (process.env.HOME === undefined || !process.env.HOME.startsWith("/tmp/")) {
-  throw new Error("plugin tests require HOME pointed at a /tmp fixture directory; run via `bun run test:plugin`");
-}
-
-const configDir = path.join(process.env.HOME, ".config", "opencode");
-
-mock.module("./embeddings", () => ({
-  ...realEmbeddings,
-  generateEmbedding: async () => Array.from({ length: 384 }, (_, i) => Math.sin(i) * 0.5),
-  warmupEmbedder: async () => {},
-}));
-
-import plugin from "./plugin";
-
-test("explicit opt-out registers no tools and emits no warning", async () => {
-  await fs.mkdir(configDir, { recursive: true });
-  await fs.writeFile(path.join(configDir, "agent-memory.json"), JSON.stringify({ journal: { enabled: false } }), "utf-8");
-  const definitions: unknown[] = [];
-  const warn = console.warn;
-  let warnings = 0;
-  console.warn = () => { warnings++; };
-  try {
-    await plugin.setup({
-      location: { directory: "/tmp" },
-      session: { hook: async () => {} },
-      tool: { transform: async (callback: (editor: { add: (tool: unknown) => void; list: () => unknown[] }) => void) => callback({ add: (tool) => definitions.push(tool), list: () => [] }) },
-    } as any);
-    expect(definitions).toEqual([]);
-    expect(warnings).toBe(0);
-  } finally {
-    console.warn = warn;
-    await fs.rm(configDir, { recursive: true, force: true });
-  }
-});

package/src/plugin.test.ts

@@ -1,220 +0,0 @@
-import { afterEach, describe, expect, mock, test } from "bun:test";
-import * as fs from "node:fs/promises";
-import * as os from "node:os";
-import * as path from "node:path";
-import * as realEmbeddings from "./embeddings";
-
-// These tests run in their own bun process (package.json "test:plugin") with
-// HOME pointed at a throwaway fixture directory, so the real loadConfig and
-// createJournalStore exercise real fixture files. Refuse to run against the
-// real home directory. Only the model-loading surface of ./embeddings is
-// stubbed, spreading the real module so other exports keep real values.
-if (process.env.HOME === undefined || !process.env.HOME.startsWith("/tmp/")) {
-  throw new Error("plugin tests require HOME pointed at a /tmp fixture directory; run via `bun run test:plugin`");
-}
-
-const fixtureHome = process.env.HOME;
-const configDir = path.join(fixtureHome, ".config", "opencode");
-const configPath = path.join(configDir, "agent-memory.json");
-const journalDir = path.join(configDir, "journal");
-
-mock.module("./embeddings", () => ({
-  ...realEmbeddings,
-  generateEmbedding: async () => Array.from({ length: 384 }, (_, i) => Math.sin(i) * 0.5),
-  warmupEmbedder: async () => {},
-}));
-
-import plugin from "./plugin";
-
-// value === undefined creates a DIRECTORY at the config path (unreadable);
-// a string is written raw (malformed JSON); an object is JSON-encoded.
-async function writeConfig(value: unknown): Promise<void> {
-  await fs.mkdir(configDir, { recursive: true });
-  if (value === undefined) {
-    await fs.mkdir(configPath, { recursive: true });
-  } else if (typeof value === "string") {
-    await fs.writeFile(configPath, value, "utf-8");
-  } else {
-    await fs.writeFile(configPath, JSON.stringify(value), "utf-8");
-  }
-}
-
-function harness(directory = "/tmp/project") {
-  const definitions = new Map<string, any>();
-  let contextHook: ((event: any) => void) | undefined;
-  let transform: ((editor: { add: (definition: any) => void; list: () => any[] }) => void) | undefined;
-  const context = {
-    location: { directory },
-    session: { hook: async (name: string, callback: (event: any) => void) => { expect(name).toBe("context"); contextHook = callback; } },
-    tool: { transform: async (callback: typeof transform) => { transform = callback; callback!({ add: (definition) => definitions.set(definition.name, definition), list: () => [...definitions.values()] }); } },
-  } as any;
-  return { definitions, contextHook: () => contextHook, replay: () => transform!({ add: (definition) => definitions.set(definition.name, definition), list: () => [...definitions.values()] }), start: () => plugin.setup(context) };
-}
-
-afterEach(async () => {
-  await fs.rm(configDir, { recursive: true, force: true });
-});
-
-describe("v2 plugin registration", () => {
-  test("has a stable id and default-registers exactly the three journal tools", async () => {
-    expect(plugin.id).toBe("opencode-agent-memory");
-    await fs.rm(configDir, { recursive: true, force: true }); // absent config: default-on journal tools
-    const h = harness();
-    await h.start();
-    expect([...h.definitions.keys()].sort()).toEqual(["journal_read", "journal_search", "journal_write"]);
-  });
-
-  test("registered write description suggests configured tag names without their descriptions", async () => {
-    await writeConfig({ journal: { tags: [
-      { name: "owner_approved", description: "Use for a choice made and its rationale." },
-      { name: "incident_followup", description: "Use for investigation notes and findings." },
-    ] } });
-    const h = harness();
-    await h.start();
-    const description = h.definitions.get("journal_write").description as string;
-    expect(description).toContain("Suggested tags: owner_approved, incident_followup.");
-    expect(description).not.toContain("Use for a choice made and its rationale.");
-    expect(description).not.toContain("Use for investigation notes and findings.");
-  });
-
-  test("transform replay does not duplicate tool registration", async () => {
-    const h = harness(); await h.start();
-    h.replay();
-    expect([...h.definitions.keys()].sort()).toEqual(["journal_read", "journal_search", "journal_write"]);
-  });
-
-  test("explicit false opts out without tools", async () => {
-    await writeConfig({ journal: { enabled: false } });
-    const h = harness(); await h.start();
-    expect([...h.definitions.keys()]).toEqual([]);
-  });
-
-  test("invalid journal typo fails closed and warns", async () => {
-    await writeConfig({ journal: { enabled_: false } });
-    const warnings: unknown[][] = [];
-    const originalWarn = console.warn;
-    console.warn = (...args) => warnings.push(args);
-    try {
-      const h = harness(); await h.start();
-      expect([...h.definitions.keys()]).toEqual([]);
-      expect(warnings).toEqual([[`[agent-memory] journal config ${configPath}: schema validation failed; journal tools will NOT be registered`]]);
-    } finally { console.warn = originalWarn; }
-  });
-
-  test("fails closed on unreadable config", async () => {
-    await writeConfig(undefined);
-    const warnings: unknown[][] = [];
-    const originalWarn = console.warn;
-    console.warn = (...args) => warnings.push(args);
-    try {
-      const h = harness(); await h.start();
-      expect([...h.definitions.keys()]).toEqual([]);
-      expect(warnings).toEqual([[`[agent-memory] journal config ${configPath}: read failed (EISDIR); journal tools will NOT be registered`]]);
-    } finally { console.warn = originalWarn; }
-  });
-
-  test("fails closed on malformed config", async () => {
-    await writeConfig("not json{{{");
-    const warnings: unknown[][] = [];
-    const originalWarn = console.warn;
-    console.warn = (...args) => warnings.push(args);
-    try {
-      const h = harness(); await h.start();
-      expect([...h.definitions.keys()]).toEqual([]);
-      expect(warnings).toEqual([[`[agent-memory] journal config ${configPath}: malformed JSON; journal tools will NOT be registered`]]);
-    } finally { console.warn = originalWarn; }
-  });
-
-  test("fails closed on invalid config", async () => {
-    await writeConfig({ journal: { enabled: "yes" } });
-    const warnings: unknown[][] = [];
-    const originalWarn = console.warn;
-    console.warn = (...args) => warnings.push(args);
-    try {
-      const h = harness(); await h.start();
-      expect([...h.definitions.keys()]).toEqual([]);
-      expect(warnings).toEqual([[`[agent-memory] journal config ${configPath}: schema validation failed; journal tools will NOT be registered`]]);
-    } finally { console.warn = originalWarn; }
-  });
-
-  test("default absent config emits no warning", async () => {
-    const warnings: unknown[][] = [];
-    const originalWarn = console.warn;
-    console.warn = (...args) => warnings.push(args);
-    try { const h = harness(); await h.start(); expect(warnings).toEqual([]); }
-    finally { console.warn = originalWarn; }
-  });
-
-  test("captures model/provider per session for interleaved context events", async () => {
-    const h = harness(); await h.start();
-    const hook = h.contextHook()!;
-    hook({ sessionID: "session-a", model: { id: "model-a", providerID: "provider-a" } });
-    hook({ sessionID: "session-b", model: { id: "model-b", providerID: "provider-b" } });
-    hook({ sessionID: "session-a", model: { id: "model-a2", providerID: "provider-a2" } });
-    await h.definitions.get("journal_write").execute({ title: "Title", body: "Body" }, { agent: "agent", sessionID: "session-b" });
-    const files = (await fs.readdir(journalDir)).filter((f) => f.endsWith(".md"));
-    expect(files).toHaveLength(1);
-    const text = await fs.readFile(path.join(journalDir, files[0]!), "utf-8");
-    expect(text).toContain("model: model-b");
-    expect(text).toContain("provider: provider-b");
-    expect(text).toContain("session_id: session-b");
-  });
-});
-
-describe("project journal index injection", () => {
-  const event = () => ({ sessionID: "s", model: { id: "m", providerID: "p" }, system: [] as Array<{ type: "text"; text: string }> });
-  async function project(body?: string) {
-    const directory = await fs.mkdtemp(path.join(os.tmpdir(), "memory-index-"));
-    if (body !== undefined) await fs.writeFile(path.join(directory, "MEMORY.md"), body);
-    return directory;
-  }
-
-  test("injects a byte-stable rendered index at exact word fit", async () => {
-    const directory = await project(Array(330).fill("pointer").join(" "));
-    try {
-      const h = harness(directory); await h.start();
-      const first = event(); const second = event();
-      await h.contextHook()!(first); await h.contextHook()!(second);
-      expect(first.system).toEqual(second.system);
-      expect(first.system).toHaveLength(1);
-      expect(first.system[0]!.text).toBe(`This is the project's journal-pointer index (MEMORY.md at the repository root). Retrieve entries with journal_search/journal_read; older lines remain relevant.\n\n${Array(330).fill("pointer").join(" ")}`);
-    } finally { await fs.rm(directory, { recursive: true, force: true }); }
-  });
-
-  test("331 words injects only the fixed notice", async () => {
-    const directory = await project(Array(331).fill("pointer").join(" "));
-    try { const h = harness(directory); await h.start(); const e = event(); await h.contextHook()!(e); expect(e.system).toEqual([{ type: "text", text: "Project journal index (MEMORY.md) exceeds the injection cap; read the file at the repository root directly for the pointer list." }]); }
-    finally { await fs.rm(directory, { recursive: true, force: true }); }
-  });
-
-  test("empty, missing, and unreadable indexes inject nothing", async () => {
-    const empty = await project("  \n\t");
-    const missing = await project();
-    const unreadable = path.join(os.tmpdir(), `memory-index-file-${Date.now()}`);
-    await fs.writeFile(unreadable, "not a directory");
-    try {
-      for (const directory of [empty, missing, unreadable]) {
-        const h = harness(directory); await h.start(); const e = event(); await h.contextHook()!(e); expect(e.system).toEqual([]);
-      }
-    } finally {
-      await fs.rm(empty, { recursive: true, force: true });
-      await fs.rm(missing, { recursive: true, force: true });
-      await fs.rm(unreadable, { force: true });
-    }
-  });
-
-  test("strips frontmatter; enforces UTF-8 byte cap for long Unicode tokens", async () => {
-    const directory = await project(`---\ntitle: hidden\n---\nvisible pointer`);
-    try { const h = harness(directory); await h.start(); const e = event(); await h.contextHook()!(e); expect(e.system[0]!.text).toContain("\n\nvisible pointer"); expect(e.system[0]!.text).not.toContain("hidden"); }
-    finally { await fs.rm(directory, { recursive: true, force: true }); }
-    const large = await project("界".repeat(8192));
-    try { const h = harness(large); await h.start(); const e = event(); await h.contextHook()!(e); expect(e.system[0]!.text).toBe("Project journal index (MEMORY.md) exceeds the injection cap; read the file at the repository root directly for the pointer list."); }
-    finally { await fs.rm(large, { recursive: true, force: true }); }
-  });
-
-  test("disabled journal registers no hook or injection", async () => {
-    const directory = await project("pointer");
-    try { await writeConfig({ journal: { enabled: false } }); const h = harness(directory); await h.start(); expect(h.contextHook()).toBeUndefined(); }
-    finally { await fs.rm(directory, { recursive: true, force: true }); }
-  });
-});

package/src/test-suite.test.ts

@@ -1,15 +0,0 @@
-import { expect, test } from "bun:test";
-import * as fs from "node:fs/promises";
-
-// Guards the two-process test split in package.json: every test file in
-// src/ must be listed in exactly one group, or it silently never runs.
-const CORE = ["doctor.test.ts", "embeddings.test.ts", "journal.test.ts", "test-suite.test.ts", "tools.test.ts"];
-const PLUGIN = ["plugin-disabled.test.ts", "plugin.test.ts"];
-
-test("every test file is covered by the test:core/test:plugin split", async () => {
-  const files = (await fs.readdir(import.meta.dir))
-    .filter((f) => f.endsWith(".test.ts"))
-    .sort();
-  const covered = [...CORE, ...PLUGIN].sort();
-  expect(files).toEqual(covered);
-});

package/src/tools.test.ts

@@ -1,115 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { JournalRead, JournalSearch, JournalWrite } from "./tools";
-import type { JournalContext } from "./tools";
-import type { JournalEntry, JournalStore } from "./journal";
-
-const context: JournalContext = { directory: "/tmp/project", model: "m", provider: "p" };
-function entry(): JournalEntry {
-  return { id: "20260101-000000-000", title: "Title", project: "/tmp", model: "m", provider: "p", agent: "a", sessionId: "s", created: new Date("2026-01-01T00:00:00.000Z"), tags: ["tag"], body: "Body", filePath: "/tmp/entry.md" };
-}
-const baseStore: JournalStore = {
-  write: async () => entry(),
-  read: async () => entry(),
-  search: async () => ({ entries: [entry()], total: 1, allTags: ["tag"] }),
-};
-
-function valid(schema: any, value: any): boolean {
-  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
-  if (schema.additionalProperties === false && Object.keys(value).some((key) => !(key in schema.properties))) return false;
-  if (schema.required?.some((key: string) => !(key in value))) return false;
-  for (const [key, field] of Object.entries<any>(schema.properties)) {
-    if (!(key in value)) continue;
-    const actual = value[key];
-    if (field.type === "string" && typeof actual !== "string") return false;
-    if (field.type === "integer" && (!Number.isInteger(actual) || actual < (field.minimum ?? -Infinity))) return false;
-  }
-  return true;
-}
-
-describe("v2 journal tools", () => {
-  test("preserves the recognizable names and descriptions", () => {
-    expect([JournalWrite(baseStore, context).name, JournalRead(baseStore).name, JournalSearch(baseStore).name]).toEqual(["journal_write", "journal_read", "journal_search"]);
-    expect(JournalWrite(baseStore, context).description).toContain("append-only");
-    expect(JournalRead(baseStore).description).toContain("by its ID");
-    expect(JournalSearch(baseStore).description).toContain("lexical OR matching");
-  });
-
-  test("journal_write description preserves its behavioral guidance", () => {
-    const description = JournalWrite(baseStore, context).description;
-    expect(description).toMatch(/insights.*discoveries|discoveries.*decisions/i);
-    expect(description).toMatch(/insights.*technical discoveries.*design decisions.*observations/i);
-    expect(description).toMatch(/never edit old ones/i);
-    expect(description).toMatch(/comma-separated/i);
-    expect(description).not.toMatch(/\d{4}-\d{2}-\d{2}T/);
-    expect(description).not.toContain("Suggested tags:");
-    const tagged = JournalWrite(baseStore, context, [{ name: "focus", description: "private detail" }]).description;
-    expect(tagged).toContain("Suggested tags: focus.");
-    expect(tagged).not.toContain("private detail");
-  });
-
-  test("read and search descriptions retain their distinct contracts", () => {
-    const read = JournalRead(baseStore).description;
-    expect(read).not.toMatch(/append.only|cannot be (edited|modified)/i);
-    expect(read).not.toMatch(/\d{4}-\d{2}-\d{2}T/);
-    const search = JournalSearch(baseStore);
-    expect(search.description).toMatch(/filters are optional/i);
-    expect(search.description).toMatch(/global across all projects/i);
-    expect(search.input.properties).toHaveProperty("project");
-    expect(search.input.properties).toHaveProperty("offset");
-    expect(search.description).toMatch(/paginate/i);
-  });
-
-  test("descriptions are nonempty and do not name sibling tools", () => {
-    const descriptions = [JournalWrite(baseStore, context).description, JournalRead(baseStore).description, JournalSearch(baseStore).description];
-    expect(descriptions.every((description) => description.trim().length > 0)).toBe(true);
-    for (const [index, description] of descriptions.entries()) {
-      for (const [otherIndex, name] of ["journal_write", "journal_read", "journal_search"].entries()) {
-        if (index !== otherIndex) expect(description).not.toContain(name);
-      }
-    }
-  });
-
-  test("uses JSON schemas, rejects malformed and unknown arguments", () => {
-    const write = JournalWrite(baseStore, context).input as any;
-    const read = JournalRead(baseStore).input as any;
-    const search = JournalSearch(baseStore).input as any;
-    expect(write.type).toBe("object");
-    expect(valid(write, { title: "t", body: "b" })).toBe(true);
-    expect(valid(write, { title: 4, body: "b" })).toBe(false);
-    expect(valid(write, { title: "t", body: "b", extra: true })).toBe(false);
-    expect(valid(read, {})).toBe(false);
-    expect(valid(read, { id: "id", extra: 1 })).toBe(false);
-    expect(valid(search, { limit: 0 })).toBe(false);
-    expect(valid(search, { offset: 1.5 })).toBe(false);
-    expect(valid(search, { unexpected: true })).toBe(false);
-    expect(valid(search, { tags: "a,b", limit: 2, offset: 0 })).toBe(true);
-  });
-
-  test("all execute methods return the v2 {content} result", async () => {
-    const writeResult = await JournalWrite(baseStore, context).execute({ title: "t", body: "b" }, { agent: "a", sessionID: "s" });
-    const readResult = await JournalRead(baseStore).execute({ id: "entry" }, {} as any);
-    const searchResult = await JournalSearch(baseStore).execute({}, {} as any);
-    for (const result of [writeResult, readResult, searchResult]) {
-      expect(Object.keys(result)).toEqual(["content"]);
-      expect(typeof result.content).toBe("string");
-    }
-    expect(writeResult.content).toContain("Journal entry created:");
-    expect(readResult.content).toContain("Body");
-    expect(searchResult.content).toContain("Found 1 candidate entries");
-  });
-
-  test("retains bounded tag inventory output formatting", async () => {
-    const populated: JournalStore = { ...baseStore, search: async () => ({ entries: [entry()], total: 1, allTags: ["alpha", "beta"] }) };
-    expect((await JournalSearch(populated).execute({}, {} as any)).content).toContain("Tags in use: alpha, beta");
-    const empty: JournalStore = { ...baseStore, search: async () => ({ entries: [], total: 0, allTags: [] }) };
-    expect((await JournalSearch(empty).execute({}, {} as any)).content).toBe("No journal entries found.");
-    const store: JournalStore = { ...baseStore, search: async () => ({ entries: [], total: 0, allTags: Array.from({ length: 21 }, (_, i) => `tag-${i}`) }) };
-    const result = await JournalSearch(store).execute({}, {} as any);
-    expect(result.content).toBe("No journal entries found.\nTags in use: 21 (filter with tags=...)");
-  });
-
-  test("journal_read formats metadata before the body", async () => {
-    const result = await JournalRead(baseStore).execute({ id: "entry" }, {} as any);
-    expect(result.content).toBe("title: Title\ncreated: 2026-01-01T00:00:00.000Z\nproject: /tmp\nmodel: m\nprovider: p\nagent: a\nsession: s\ntags: tag\n\nBody");
-  });
-});