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
import { afterEach, beforeEach, describe, expect, test } from "bun:test";
import { mkdtempSync, readFileSync, rmSync } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { isPinned, setPinned } from "../../src/core/brain/pin.ts";
import { parseLogDay } from "../../src/core/brain/log.ts";
import { parsePreference, writePreference } from "../../src/core/brain/preference.ts";
import { BrainPreferenceNotFoundError } from "../../src/core/brain/apply-evidence.ts";
import { bootstrapBrain } from "../../src/core/brain/init.ts";
import { atomicWriteFileSync } from "../../src/core/fs-atomic.ts";
import type { BrainPreference } from "../../src/core/brain/types.ts";
import { useUnshardedLegacyLog } from "../helpers/device-id.ts";
// The legacy day log and ledgers are read under their un-sharded names.
useUnshardedLegacyLog();
let vault: string;
let configHome: string;
let configPath: string;
beforeEach(() => {
vault = mkdtempSync(join(tmpdir(), "o2b-pin-vault-"));
configHome = mkdtempSync(join(tmpdir(), "o2b-pin-cfg-"));
configPath = join(configHome, "config.yaml");
atomicWriteFileSync(configPath, `vault: ${vault}\n`);
bootstrapBrain(vault, { configPath });
});
afterEach(() => {
rmSync(vault, { recursive: true, force: true });
rmSync(configHome, { recursive: true, force: true });
});
function makePref(slug: string, pinned: boolean): string {
const r = writePreference(vault, {
slug,
topic: slug,
principle: `Rule for ${slug}`,
created_at: "2026-05-14T10:42:00Z",
unconfirmed_until: "2026-05-28T10:42:00Z",
status: "unconfirmed",
evidenced_by: [`[[sig-2026-05-13-${slug}]]`],
pinned,
});
return r.path;
}
describe("setPinned β happy paths", () => {
test("false β true: changed: true, log gets a pin event, frontmatter flipped", () => {
const path = makePref("flippable", false);
const before = parsePreference(path);
expect(before.pinned).toBe(false);
const res = setPinned(vault, "flippable", true, {
now: new Date("2026-05-14T07:00:00Z"),
agent: "claude",
});
expect(res.changed).toBe(true);
expect(res.path).toBe(path);
const after = parsePreference(path);
expect(after.pinned).toBe(true);
const { entries } = parseLogDay(vault, "2026-05-14");
expect(entries).toHaveLength(1);
expect(entries[0]!.eventType).toBe("pin");
expect(entries[0]!.body["preference"]).toBe("[[pref-flippable|Rule for flippable]]");
expect(entries[0]!.body["agent"]).toBe("claude");
});
test("true β false: changed: true, log gets an unpin event", () => {
const path = makePref("unpinnable", true);
const res = setPinned(vault, "unpinnable", false, {
now: new Date("2026-05-14T08:00:00Z"),
});
expect(res.changed).toBe(true);
const reparsed = parsePreference(path);
expect(reparsed.pinned).toBe(false);
const { entries } = parseLogDay(vault, "2026-05-14");
expect(entries).toHaveLength(1);
expect(entries[0]!.eventType).toBe("unpin");
});
test("accepts both 'pref-foo' and 'foo' forms", () => {
makePref("either-form", false);
const a = setPinned(vault, "pref-either-form", true, {
now: new Date("2026-05-14T09:00:00Z"),
});
expect(a.changed).toBe(true);
// Idempotent path: prefixed form should still resolve to same file.
const b = setPinned(vault, "either-form", true, {
now: new Date("2026-05-14T09:00:01Z"),
});
expect(b.changed).toBe(false);
});
});
describe("setPinned β idempotency", () => {
test("true β true: changed: false and no log event", () => {
makePref("already-pinned", true);
const res = setPinned(vault, "already-pinned", true, {
now: new Date("2026-05-14T10:00:00Z"),
});
expect(res.changed).toBe(false);
// The log file should not have been created on an idempotent
// no-op β the appender writes the canonical header on first
// event, so a missing file is the cleanest assertion.
const { entries } = parseLogDay(vault, "2026-05-14");
expect(entries).toEqual([]);
});
test("false β false: changed: false and no log event", () => {
makePref("never-pinned", false);
const res = setPinned(vault, "never-pinned", false, {
now: new Date("2026-05-14T10:00:00Z"),
});
expect(res.changed).toBe(false);
const { entries } = parseLogDay(vault, "2026-05-14");
expect(entries).toEqual([]);
});
});
describe("setPinned β body preservation", () => {
test("preference body (How to apply section, etc) is unchanged", () => {
const path = makePref("preserve-body", false);
const before = readFileSync(path, "utf8");
const bodyBefore = before.split("---\n").slice(2).join("---\n");
setPinned(vault, "preserve-body", true, {
now: new Date("2026-05-14T10:00:00Z"),
});
const after = readFileSync(path, "utf8");
const bodyAfter = after.split("---\n").slice(2).join("---\n");
expect(bodyAfter).toBe(bodyBefore);
});
});
describe("setPinned β error paths", () => {
test("missing preference throws BrainPreferenceNotFoundError", () => {
expect(() => setPinned(vault, "does-not-exist", true)).toThrow(BrainPreferenceNotFoundError);
});
test("empty pref_id throws", () => {
expect(() => setPinned(vault, "", true)).toThrow(/missing field|empty slug/);
});
});
describe("isPinned β accessor", () => {
test("returns false on a parsed preference whose frontmatter omits pinned", () => {
// Construct an object that mimics a parsed preference with
// pinned: false (the parser's default).
const fake: BrainPreference = Object.freeze({
kind: "brain-preference",
id: "pref-x",
created_at: "2026-05-14T10:42:00Z",
confirmed_at: null,
unconfirmed_until: "2026-05-28T10:42:00Z",
tags: ["brain"],
topic: "x",
status: "unconfirmed",
principle: "...",
evidenced_by: [],
applied_count: 0,
violated_count: 0,
last_evidence_at: null,
confidence: "low",
confidence_value: null,
pinned: false,
});
expect(isPinned(fake)).toBe(false);
});
test("returns true when frontmatter explicitly sets pinned: true", () => {
makePref("explicit-pinned", true);
const parsed = parsePreference(`${vault}/Brain/preferences/pref-explicit-pinned.md`);
expect(isPinned(parsed)).toBe(true);
});
});