Skip to content

Local-first 🧠 memory for Hermes Agent that lives in your Obsidian vault and remembers project context. Nightly 😴 dream passes turn repeat corrections into confirmed preferences with measurable confidence. Adapters ship for Claude Code, Codex, and OpenClaw, with an MCP server for anything else.

TypeScript
18.9 KB
Raw Blame
/**
 * Tests for src/core/brain/digest.ts.
 *
 * The digest is a deterministic renderer over Brain state. We exercise
 * each section in isolation, the empty-window collapse, the markdown-vs-JSON
 * parity, the schema shape from §8.2, and the window-filtering edge.
 *
 * Fixtures are hand-built per test for isolation; the `bootstrap` helper
 * makes a vault root with Brain/ subdirs ready for writes.
 */

import { afterEach, beforeEach, describe, expect, test } from "bun:test";
import { mkdirSync, mkdtempSync, rmSync } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";

import { renderDigest, type DigestJson } from "../../src/core/brain/digest.ts";
import { appendLogEvent } from "../../src/core/brain/log.ts";
import { brainDirs } from "../../src/core/brain/paths.ts";
import {
  moveToRetired,
  writePreference,
  type WritePreferenceInput,
} from "../../src/core/brain/preference.ts";

let tmp: string;

beforeEach(() => {
  tmp = mkdtempSync(join(tmpdir(), "o2b-brain-digest-"));
  const dirs = brainDirs(tmp);
  for (const d of [
    dirs.brain,
    dirs.inbox,
    dirs.processed,
    dirs.preferences,
    dirs.retired,
    dirs.log,
  ]) {
    mkdirSync(d, { recursive: true });
  }
});

afterEach(() => {
  rmSync(tmp, { recursive: true, force: true });
});

const SINCE = new Date("2026-05-13T20:00:00Z");
const UNTIL = new Date("2026-05-14T20:00:00Z");

function basePref(
  slug: string,
  overrides: Partial<WritePreferenceInput> = {},
): WritePreferenceInput {
  return {
    slug,
    topic: slug,
    principle: `Principle for ${slug}`,
    created_at: "2026-05-14T10:42:00Z",
    unconfirmed_until: "2026-05-28T10:42:00Z",
    status: "unconfirmed",
    evidenced_by: [`[[sig-${slug}-a]]`, `[[sig-${slug}-b]]`, `[[sig-${slug}-c]]`],
    scope: "writing",
    confirmed_at: null,
    applied_count: 0,
    violated_count: 0,
    last_evidence_at: null,
    confidence: "low",
    pinned: false,
    ...overrides,
  };
}

describe("empty-window", () => {
  test("collapses to a single-line Markdown notice and reports `empty: true`", () => {
    const res = renderDigest(tmp, { since: SINCE, until: UNTIL });
    expect(res.empty).toBe(true);
    expect(res.content).toMatch(/^Brain digest — 2026-05-14: no changes\n$/);
  });

  test("JSON form sets `summary.empty: true` and emits empty arrays for all sections", () => {
    const res = renderDigest(tmp, {
      since: SINCE,
      until: UNTIL,
      format: "json",
      now: UNTIL,
    });
    expect(res.empty).toBe(true);
    const parsed = JSON.parse(res.content) as DigestJson;
    expect(parsed.schema_version).toBe(1);
    expect(parsed.window.since).toBe(SINCE.toISOString());
    expect(parsed.window.until).toBe(UNTIL.toISOString());
    expect(parsed.summary.empty).toBe(true);
    expect(parsed.summary.new_unconfirmed_count).toBe(0);
    expect(parsed.summary.confirmed_count).toBe(0);
    expect(parsed.summary.retired_count).toBe(0);
    expect(parsed.summary.confidence_shift_count).toBe(0);
    expect(parsed.summary.contradiction_count).toBe(0);
    expect(parsed.new_unconfirmed).toEqual([]);
    expect(parsed.confirmed).toEqual([]);
    expect(parsed.retired).toEqual([]);
    expect(parsed.confidence_shifts).toEqual([]);
    expect(parsed.contradictions).toEqual([]);
  });
});

describe("New (unconfirmed, in trial) section", () => {
  test("includes unconfirmed prefs created in the window with signal count and trial deadline", () => {
    writePreference(tmp, basePref("no-internal-abbrev"));
    const res = renderDigest(tmp, { since: SINCE, until: UNTIL });
    expect(res.empty).toBe(false);
    expect(res.content).toContain("## New (unconfirmed, in trial)");
    expect(res.content).toContain(
      "[[pref-no-internal-abbrev|Principle for no-internal-abbrev]] — writing, 3 signals, trial ends 2026-05-28",
    );
  });

  test("omits unconfirmed prefs created outside the window", () => {
    writePreference(tmp, basePref("old", { created_at: "2026-04-01T00:00:00Z" }));
    const res = renderDigest(tmp, { since: SINCE, until: UNTIL });
    expect(res.empty).toBe(true);
    expect(res.content).not.toMatch(/\[\[pref-old[\]|]/);
  });
});

describe("Confirmed section", () => {
  test("lists confirmed prefs whose confirmed_at lands in the window", () => {
    writePreference(
      tmp,
      basePref("prefer-typed-errors", {
        status: "confirmed",
        confirmed_at: "2026-05-14T11:00:00Z",
        applied_count: 1,
        last_evidence_at: "2026-05-14T11:00:00Z",
      }),
    );
    appendLogEvent(tmp, {
      timestamp: "2026-05-14T11:00:00Z",
      eventType: "apply-evidence",
      body: {
        preference: "[[pref-prefer-typed-errors]]",
        artifact: "[[Daily/2026.05.14]]",
        agent: "claude",
        result: "applied",
      },
    });
    const res = renderDigest(tmp, { since: SINCE, until: UNTIL });
    expect(res.content).toContain("## Confirmed");
    expect(res.content).toContain(
      "[[pref-prefer-typed-errors|Principle for prefer-typed-errors]] — writing, first applied in [[Daily/2026.05.14]]",
    );
  });
});

describe("Retired section", () => {
  test("lists retired prefs with reason and days_stale for stale-no-evidence", () => {
    const w = writePreference(
      tmp,
      basePref("prefer-bullets-over-prose", {
        status: "confirmed",
        confirmed_at: "2026-02-12T05:00:00Z",
        created_at: "2026-02-12T05:00:00Z",
        last_evidence_at: "2026-02-12T05:00:00Z",
      }),
    );
    moveToRetired(tmp, w.path, "stale-no-evidence", {
      now: new Date("2026-05-14T05:00:00Z"),
      retired_by: "[[Brain/log/2026-05-14]]",
    });
    const res = renderDigest(tmp, { since: SINCE, until: UNTIL });
    expect(res.content).toContain("## Retired");
    // 2026-02-12 → 2026-05-14 = 91 days.
    expect(res.content).toMatch(
      /\[\[ret-prefer-bullets-over-prose\|Principle for prefer-bullets-over-prose\]\] — writing, stale-no-evidence \(91 days\)/,
    );
  });

  test("non-stale reasons render without the days_stale parenthetical", () => {
    const w = writePreference(tmp, basePref("rebut-me"));
    moveToRetired(tmp, w.path, "rebutted", {
      now: new Date("2026-05-14T05:00:00Z"),
      retired_by: "[[Brain/log/2026-05-14]]",
    });
    const res = renderDigest(tmp, { since: SINCE, until: UNTIL });
    expect(res.content).toContain("[[ret-rebut-me|Principle for rebut-me]] — writing, rebutted");
    expect(res.content).not.toMatch(/rebutted\s*\(\d+ days\)/);
  });
});

describe("Markdown ↔ JSON parity", () => {
  test("a fixture with one of each section type renders consistently across formats", () => {
    // New (unconfirmed) — 'aaa' created in window.
    writePreference(tmp, basePref("aaa"));
    // Confirmed — 'bbb' confirmed in window.
    writePreference(
      tmp,
      basePref("bbb", {
        status: "confirmed",
        confirmed_at: "2026-05-14T11:00:00Z",
        applied_count: 1,
      }),
    );
    appendLogEvent(tmp, {
      timestamp: "2026-05-14T11:00:00Z",
      eventType: "apply-evidence",
      body: {
        preference: "[[pref-bbb]]",
        artifact: "[[Daily/2026.05.14]]",
        agent: "claude",
        result: "applied",
      },
    });
    // Retired — 'ccc' moved within window.
    const ccc = writePreference(tmp, basePref("ccc"));
    moveToRetired(tmp, ccc.path, "rebutted", {
      now: new Date("2026-05-14T12:00:00Z"),
      retired_by: "[[Brain/log/2026-05-14]]",
    });

    const md = renderDigest(tmp, { since: SINCE, until: UNTIL });
    const j = renderDigest(tmp, {
      since: SINCE,
      until: UNTIL,
      format: "json",
      now: UNTIL,
    });
    expect(md.empty).toBe(false);
    expect(j.empty).toBe(false);
    const parsed = JSON.parse(j.content) as DigestJson;
    expect(parsed.new_unconfirmed.map((x) => x.id)).toEqual(["pref-aaa"]);
    expect(parsed.confirmed.map((x) => x.id)).toEqual(["pref-bbb"]);
    expect(parsed.retired.map((x) => x.id)).toEqual(["ret-ccc"]);
    // Markdown contains every id too — titled wikilink form.
    expect(md.content).toContain("[[pref-aaa|");
    expect(md.content).toContain("[[pref-bbb|");
    expect(md.content).toContain("[[ret-ccc|");
  });
});

describe("window filtering", () => {
  test("entries timestamped before `since` are excluded", () => {
    writePreference(tmp, basePref("before-window", { created_at: "2026-04-01T00:00:00Z" }));
    writePreference(tmp, basePref("inside-window"));
    const res = renderDigest(tmp, { since: SINCE, until: UNTIL });
    expect(res.content).toContain("[[pref-inside-window|");
    expect(res.content).not.toMatch(/\[\[pref-before-window[\]|]/);
  });

  test("the upper bound is exclusive — until timestamp itself is dropped", () => {
    // created_at = until exactly → must be excluded.
    writePreference(tmp, basePref("on-the-edge", { created_at: UNTIL.toISOString() }));
    const res = renderDigest(tmp, { since: SINCE, until: UNTIL });
    expect(res.empty).toBe(true);
  });
});

describe("graceful degradation for confidence shifts / contradictions", () => {
  test("a dream event without payload data renders empty sections without throwing", () => {
    // A dream event with no `confidence_shifts` / `contradictions`
    // bullets — what Task 3's current iteration may emit. We require
    // the renderer to tolerate it.
    appendLogEvent(tmp, {
      timestamp: "2026-05-14T10:00:00Z",
      eventType: "dream",
      body: {
        run_id: "dream-2026-05-14-100000",
        input_signals: "3",
        new_unconfirmed: ["[[pref-x]]"],
      },
    });
    const res = renderDigest(tmp, { since: SINCE, until: UNTIL });
    // Not empty — the dream event produces an agent_summary entry
    // (attributed to "unknown" since no agent field is present).
    expect(res.empty).toBe(false);
  });

  test("a dream event with confidence_shifts populates the section", () => {
    appendLogEvent(tmp, {
      timestamp: "2026-05-14T10:00:00Z",
      eventType: "dream",
      body: {
        run_id: "dream-2026-05-14-100000",
        confidence_shifts: [
          "[[pref-no-internal-abbrev]] medium -> high (applied: 11, violated: 0)",
        ],
      },
    });
    const res = renderDigest(tmp, {
      since: SINCE,
      until: UNTIL,
      format: "json",
      now: UNTIL,
    });
    const parsed = JSON.parse(res.content) as DigestJson;
    expect(parsed.confidence_shifts).toHaveLength(1);
    expect(parsed.confidence_shifts[0]!.id).toBe("pref-no-internal-abbrev");
    expect(parsed.confidence_shifts[0]!.from).toBe("medium");
    expect(parsed.confidence_shifts[0]!.to).toBe("high");
    expect(parsed.confidence_shifts[0]!.applied_count).toBe(11);
    expect(parsed.confidence_shifts[0]!.violated_count).toBe(0);
  });
});

describe("`empty` flag semantics", () => {
  test("non-empty data yields empty=false; CLI can use this to skip output", () => {
    writePreference(tmp, basePref("alpha"));
    const md = renderDigest(tmp, { since: SINCE, until: UNTIL });
    const js = renderDigest(tmp, {
      since: SINCE,
      until: UNTIL,
      format: "json",
      now: UNTIL,
    });
    expect(md.empty).toBe(false);
    expect(js.empty).toBe(false);
  });

  test("default window is the last 24 hours when `since` is omitted", () => {
    const now = new Date("2026-05-14T20:00:00Z");
    writePreference(tmp, basePref("recent", { created_at: "2026-05-14T15:00:00Z" }));
    writePreference(tmp, basePref("old", { created_at: "2026-04-01T00:00:00Z" }));
    const res = renderDigest(tmp, { until: now });
    expect(res.content).toContain("[[pref-recent|");
    expect(res.content).not.toMatch(/\[\[pref-old[\]|]/);
  });
});

describe("validation", () => {
  test("rejects `since > until`", () => {
    expect(() =>
      renderDigest(tmp, {
        since: new Date("2026-05-15T00:00:00Z"),
        until: new Date("2026-05-14T00:00:00Z"),
      }),
    ).toThrow(RangeError);
  });
});

describe("top_applied / top_referenced sections", () => {
  test("top_applied includes confirmed/quarantine prefs sorted by applied_count desc", () => {
    writePreference(
      tmp,
      basePref("hot-a", {
        status: "confirmed",
        confirmed_at: "2026-05-01T00:00:00Z",
        applied_count: 10,
        violated_count: 1,
        confidence: "high",
      }),
    );
    writePreference(
      tmp,
      basePref("hot-b", {
        status: "confirmed",
        confirmed_at: "2026-05-01T00:00:00Z",
        applied_count: 5,
        confidence: "medium",
      }),
    );
    writePreference(
      tmp,
      basePref("quarantine-c", {
        status: "quarantine",
        confirmed_at: "2026-05-01T00:00:00Z",
        applied_count: 3,
        violated_count: 4,
        confidence: "low",
      }),
    );
    writePreference(
      tmp,
      basePref("never-applied", {
        status: "confirmed",
        confirmed_at: "2026-05-01T00:00:00Z",
        applied_count: 0,
      }),
    );

    // Trigger a non-empty window so the markdown path renders (Top
    // sections only render when there were window-changes — confirmed
    // earlier in this same window provides that.).
    const r = renderDigest(tmp, {
      since: new Date("2026-04-30T00:00:00Z"),
      until: new Date("2026-05-05T00:00:00Z"),
      format: "json",
    });
    const json = JSON.parse(r.content) as DigestJson;
    expect(json.top_applied.map((x) => x.id)).toEqual([
      "pref-hot-a",
      "pref-hot-b",
      "pref-quarantine-c",
    ]);
    expect(json.top_applied[0]!.applied_count).toBe(10);
    expect(json.top_applied[2]!.status).toBe("quarantine");
    // applied_count: 0 prefs are excluded.
    expect(json.top_applied.find((x) => x.id === "pref-never-applied")).toBeUndefined();
  });

  test("Markdown renders Top applied with the quarantine tag", () => {
    writePreference(
      tmp,
      basePref("hot", {
        status: "confirmed",
        confirmed_at: SINCE.toISOString(),
        applied_count: 7,
      }),
    );
    writePreference(
      tmp,
      basePref("quar", {
        status: "quarantine",
        confirmed_at: SINCE.toISOString(),
        applied_count: 3,
        violated_count: 4,
      }),
    );
    const r = renderDigest(tmp, { since: SINCE, until: UNTIL, format: "markdown" });
    expect(r.content).toContain("## Top applied (2)");
    expect(r.content).toContain("[[pref-hot|");
    expect(r.content).toContain("[[pref-quar|");
    expect(r.content).toContain("[quarantine]");
  });

  test("top_referenced counts inbound wikilinks per pref", () => {
    writePreference(
      tmp,
      basePref("target", {
        status: "confirmed",
        confirmed_at: SINCE.toISOString(),
        applied_count: 1,
      }),
    );
    writePreference(
      tmp,
      basePref("source-1", {
        status: "confirmed",
        confirmed_at: SINCE.toISOString(),
        applied_count: 1,
        evidenced_by: ["[[pref-target]]"],
      }),
    );
    writePreference(
      tmp,
      basePref("source-2", {
        status: "confirmed",
        confirmed_at: SINCE.toISOString(),
        applied_count: 1,
        evidenced_by: ["[[pref-target]]"],
      }),
    );
    const r = renderDigest(tmp, { since: SINCE, until: UNTIL, format: "json" });
    const json = JSON.parse(r.content) as DigestJson;
    const targetEntry = json.top_referenced.find((x) => x.id === "pref-target");
    expect(targetEntry).toBeDefined();
    expect(targetEntry!.backlink_count).toBeGreaterThanOrEqual(2);
  });
});

describe("merge_suggestions section (§12)", () => {
  test("surfaces a near-duplicate pair in markdown and JSON", () => {
    // Both prefs are confirmed in the SAME (topic, scope) bucket and
    // share most of their `principle` tokens. The detector should
    // pick them up at the default 0.6 threshold.
    writePreference(
      tmp,
      basePref("imperative-a", {
        topic: "commits",
        principle: "Use imperative voice in commit subjects",
        status: "confirmed",
        confirmed_at: "2026-05-10T00:00:00Z",
        applied_count: 3,
        confidence: "high",
      }),
    );
    writePreference(
      tmp,
      basePref("imperative-b", {
        topic: "commits",
        principle: "Write commit subjects in imperative voice",
        status: "confirmed",
        confirmed_at: "2026-05-10T00:00:00Z",
        applied_count: 2,
        confidence: "high",
      }),
    );

    // Drive a confirmed event inside the window so the markdown path
    // renders (the digest collapses to a one-liner when nothing in
    // the window changed). Confirmation date inside [SINCE, UNTIL).
    writePreference(
      tmp,
      basePref("noop-window", {
        topic: "noop-window",
        status: "confirmed",
        confirmed_at: SINCE.toISOString(),
        applied_count: 1,
      }),
    );

    const md = renderDigest(tmp, { since: SINCE, until: UNTIL, format: "markdown" });
    expect(md.content).toContain("## Merge suggestions");
    expect(md.content).toContain("[[pref-imperative-a|");
    expect(md.content).toContain("[[pref-imperative-b|");
    expect(md.content).toContain("topic 'commits'");

    const json = renderDigest(tmp, { since: SINCE, until: UNTIL, format: "json" });
    const parsed = JSON.parse(json.content) as DigestJson;
    expect(parsed.merge_suggestions.length).toBeGreaterThanOrEqual(1);
    const pair = parsed.merge_suggestions[0]!;
    expect(pair.a < pair.b).toBe(true);
    expect(pair.topic).toBe("commits");
    expect(pair.jaccard).toBeGreaterThanOrEqual(0.6);
  });

  test("no candidates → section absent in markdown, empty array in JSON", () => {
    // Single confirmed pref → no pair → no suggestions.
    writePreference(
      tmp,
      basePref("solo", {
        status: "confirmed",
        confirmed_at: SINCE.toISOString(),
        applied_count: 1,
      }),
    );
    const md = renderDigest(tmp, { since: SINCE, until: UNTIL, format: "markdown" });
    expect(md.content).not.toContain("## Merge suggestions");
    const json = renderDigest(tmp, { since: SINCE, until: UNTIL, format: "json" });
    const parsed = JSON.parse(json.content) as DigestJson;
    expect(parsed.merge_suggestions).toEqual([]);
  });

  test("merge_suggestions does not flip the empty-window collapse", () => {
    // Build two near-duplicate prefs but place them OUTSIDE the
    // window. The window itself contains nothing → digest should
    // still collapse to the empty-window one-liner and report
    // `empty: true`, even though merge_suggestions has entries.
    writePreference(
      tmp,
      basePref("dup-a", {
        topic: "outside",
        principle: "alpha beta gamma delta",
        status: "confirmed",
        confirmed_at: "2026-04-01T00:00:00Z",
        applied_count: 1,
        confidence: "high",
      }),
    );
    writePreference(
      tmp,
      basePref("dup-b", {
        topic: "outside",
        principle: "alpha beta gamma epsilon",
        status: "confirmed",
        confirmed_at: "2026-04-01T00:00:00Z",
        applied_count: 1,
        confidence: "high",
      }),
    );
    const r = renderDigest(tmp, { since: SINCE, until: UNTIL, format: "markdown" });
    expect(r.empty).toBe(true);
    expect(r.content).toMatch(/^Brain digest — \d{4}-\d{2}-\d{2}: no changes\n$/);
  });
});