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 { existsSync, mkdtempSync, readFileSync, readdirSync, rmSync, writeFileSync } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { appendApplyEvidence } from "../../src/core/brain/apply-evidence.ts";
import { dream } from "../../src/core/brain/dream.ts";
import { parseLogDay } from "../../src/core/brain/log.ts";
import { mergePreferences } from "../../src/core/brain/merge.ts";
import {
brainConfigPath,
brainDirs,
preferencePath,
retiredPath,
} from "../../src/core/brain/paths.ts";
import {
moveToRetired,
parsePreference,
parseRetired,
writePreference,
} from "../../src/core/brain/preference.ts";
import { writeSignal } from "../../src/core/brain/signal.ts";
import { bootstrapBrain } from "../../src/core/brain/init.ts";
import { atomicWriteFileSync } from "../../src/core/fs-atomic.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-dream-vault-"));
configHome = mkdtempSync(join(tmpdir(), "o2b-dream-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 seedSignal(opts: {
topic: string;
slug: string;
signal: "positive" | "negative";
date: string;
principle?: string;
}): void {
writeSignal(vault, {
topic: opts.topic,
signal: opts.signal,
agent: "claude",
principle: opts.principle ?? `Rule for ${opts.topic}`,
created_at: `${opts.date}T10:00:00Z`,
date: opts.date,
slug: opts.slug,
scope: "writing",
});
}
function listInboxActive(): string[] {
const dirs = brainDirs(vault);
return readdirSync(dirs.inbox).filter((n) => n.endsWith(".md"));
}
function listInboxProcessed(): string[] {
const dirs = brainDirs(vault);
if (!existsSync(dirs.processed)) return [];
return readdirSync(dirs.processed).filter((n) => n.endsWith(".md"));
}
function listPreferences(): string[] {
return readdirSync(brainDirs(vault).preferences).filter((n) => n.endsWith(".md"));
}
function listRetired(): string[] {
const dirs = brainDirs(vault);
if (!existsSync(dirs.retired)) return [];
return readdirSync(dirs.retired).filter((n) => n.endsWith(".md"));
}
// ----- Happy path threshold ----------------------------------------------
describe("dream — happy-path threshold (3 same-sign signals)", () => {
test("creates one unconfirmed preference and moves the signals to processed/", () => {
seedSignal({ topic: "no-abbrev", slug: "a", signal: "negative", date: "2026-05-14" });
seedSignal({ topic: "no-abbrev", slug: "b", signal: "negative", date: "2026-05-14" });
seedSignal({ topic: "no-abbrev", slug: "c", signal: "negative", date: "2026-05-14" });
expect(listInboxActive()).toHaveLength(3);
const res = dream(vault, { now: new Date("2026-05-14T20:00:00Z") });
expect(res.changed).toBe(true);
expect(res.new_unconfirmed).toEqual(["pref-no-abbrev"]);
expect(listPreferences()).toEqual(["pref-no-abbrev.md"]);
expect(listInboxActive()).toEqual([]);
expect(listInboxProcessed()).toHaveLength(3);
const pref = parsePreference(preferencePath(vault, "no-abbrev"));
expect(pref.status).toBe("unconfirmed");
expect(pref.applied_count).toBe(0);
expect(pref.violated_count).toBe(0);
expect(pref.confidence).toBe("low");
expect(pref.evidenced_by.length).toBe(3);
});
});
// ----- Contradiction window ------------------------------------------------
describe("dream — mixed-sign within window does not create a preference", () => {
test("2 negative + 1 positive cancel below threshold; no pref created", () => {
seedSignal({ topic: "mixed", slug: "a", signal: "negative", date: "2026-05-14" });
seedSignal({ topic: "mixed", slug: "b", signal: "negative", date: "2026-05-14" });
seedSignal({ topic: "mixed", slug: "c", signal: "positive", date: "2026-05-14" });
const res = dream(vault, { now: new Date("2026-05-14T20:00:00Z") });
// Some bookkeeping still happens (contradiction flag), so we don't
// assert `changed: false` strictly — but a pref must not appear.
expect(listPreferences()).toEqual([]);
expect(res.new_unconfirmed).toEqual([]);
expect(res.contradictions).toContain("mixed");
});
});
// ----- Rebuttal ------------------------------------------------------------
describe("dream — rebuttal of a confirmed preference", () => {
test("3 opposite-sign signals retire the confirmed pref with reason: rebutted", () => {
// Seed an existing confirmed pref with sign-derivation indirectly:
// we put 3 positive signals so the "active sign" heuristic in dream
// detects positive, and a single negative will count against it.
// To simplify, we'll instead seed 3 negative signals to attack a
// positive preference. We construct the pref by hand.
writePreference(vault, {
slug: "positive-rule",
topic: "positive-rule",
principle: "Do X (positive rule)",
created_at: "2026-04-01T00:00:00Z",
unconfirmed_until: "2026-04-15T00:00:00Z",
status: "confirmed",
evidenced_by: [],
confirmed_at: "2026-04-05T00:00:00Z",
applied_count: 3,
violated_count: 0,
last_evidence_at: "2026-05-10T00:00:00Z",
confidence: "medium",
});
// 3 opposite-sign signals.
seedSignal({ topic: "positive-rule", slug: "r1", signal: "negative", date: "2026-05-14" });
seedSignal({ topic: "positive-rule", slug: "r2", signal: "negative", date: "2026-05-14" });
seedSignal({ topic: "positive-rule", slug: "r3", signal: "negative", date: "2026-05-14" });
const res = dream(vault, { now: new Date("2026-05-14T20:00:00Z") });
// The pref should have been retired with reason rebutted.
expect(listPreferences().some((n) => n === "pref-positive-rule.md")).toBe(false);
expect(listRetired().some((n) => n === "ret-positive-rule.md")).toBe(true);
const retired = parseRetired(retiredPath(vault, "positive-rule"));
expect(retired.retired_reason).toBe("rebutted");
expect(res.retired.map((r) => r.reason)).toContain("rebutted");
});
});
// ----- Pin protection: stale-no-evidence ----------------------------------
describe("dream — pinned preference survives stale-no-evidence", () => {
test("clock past stale_evidence_days does NOT retire a pinned pref", () => {
writePreference(vault, {
slug: "pinned-stale",
topic: "pinned-stale",
principle: "Pinned rule",
created_at: "2026-01-01T00:00:00Z",
unconfirmed_until: "2026-01-15T00:00:00Z",
status: "confirmed",
evidenced_by: [],
confirmed_at: "2026-01-05T00:00:00Z",
applied_count: 5,
violated_count: 0,
last_evidence_at: "2026-01-10T00:00:00Z",
confidence: "medium",
pinned: true,
});
// Default stale_evidence_days = 90; pick a now well past that.
const res = dream(vault, { now: new Date("2026-08-01T00:00:00Z") });
expect(listPreferences()).toContain("pref-pinned-stale.md");
expect(listRetired()).not.toContain("ret-pinned-stale.md");
expect(res.retired.map((r) => r.id)).not.toContain("ret-pinned-stale");
// A `retire` event with `blocked: pinned` must have been logged.
const { entries } = parseLogDay(vault, "2026-08-01");
const retainEvents = entries.filter(
(e) =>
e.eventType === "retire" &&
typeof e.body["blocked"] === "string" &&
e.body["blocked"] === "pinned",
);
expect(retainEvents.length).toBeGreaterThan(0);
});
});
// ----- Stale-no-evidence (unpinned) ---------------------------------------
describe("dream — stale-no-evidence retires confirmed pref", () => {
test("confirmed pref with old last_evidence_at retires", () => {
writePreference(vault, {
slug: "stale-rule",
topic: "stale-rule",
principle: "Old rule",
created_at: "2026-01-01T00:00:00Z",
unconfirmed_until: "2026-01-15T00:00:00Z",
status: "confirmed",
evidenced_by: [],
confirmed_at: "2026-01-05T00:00:00Z",
applied_count: 3,
violated_count: 0,
last_evidence_at: "2026-01-10T00:00:00Z",
confidence: "medium",
});
const res = dream(vault, { now: new Date("2026-08-01T00:00:00Z") });
expect(listPreferences()).not.toContain("pref-stale-rule.md");
expect(listRetired()).toContain("ret-stale-rule.md");
expect(res.retired.map((r) => r.reason)).toContain("stale-no-evidence");
});
test("superseding a retired topic uses a fresh slug so later retire does not collide", () => {
writePreference(vault, {
slug: "evolving-rule",
topic: "evolving-rule",
principle: "Old rule",
created_at: "2026-01-01T00:00:00Z",
unconfirmed_until: "2026-01-15T00:00:00Z",
status: "confirmed",
evidenced_by: [],
confirmed_at: "2026-01-05T00:00:00Z",
applied_count: 3,
violated_count: 0,
last_evidence_at: "2026-01-10T00:00:00Z",
confidence: "medium",
});
moveToRetired(vault, preferencePath(vault, "evolving-rule"), "rebutted", {
now: new Date("2026-02-01T00:00:00Z"),
retired_by: "[[Brain/log/2026-02-01]]",
});
seedSignal({ topic: "evolving-rule", slug: "a", signal: "negative", date: "2026-05-14" });
seedSignal({ topic: "evolving-rule", slug: "b", signal: "negative", date: "2026-05-14" });
seedSignal({ topic: "evolving-rule", slug: "c", signal: "negative", date: "2026-05-14" });
const created = dream(vault, { now: new Date("2026-05-14T20:00:00Z") });
expect(created.new_unconfirmed).toEqual(["pref-evolving-rule-2"]);
expect(listPreferences()).toContain("pref-evolving-rule-2.md");
expect(listRetired()).toContain("ret-evolving-rule.md");
const retired = dream(vault, { now: new Date("2026-06-15T00:00:00Z") });
expect(retired.retired).toContainEqual({
id: "ret-evolving-rule-2",
reason: "expired-unconfirmed",
});
expect(listPreferences()).not.toContain("pref-evolving-rule-2.md");
expect(listRetired()).toEqual(
expect.arrayContaining(["ret-evolving-rule.md", "ret-evolving-rule-2.md"]),
);
});
});
// ----- Expired-unconfirmed --------------------------------------------------
describe("dream — expired-unconfirmed retires unconfirmed pref past window", () => {
test("now > unconfirmed_until triggers retire", () => {
writePreference(vault, {
slug: "expiring",
topic: "expiring",
principle: "Trial rule",
created_at: "2026-05-01T00:00:00Z",
unconfirmed_until: "2026-05-10T00:00:00Z",
status: "unconfirmed",
evidenced_by: [],
});
const res = dream(vault, { now: new Date("2026-05-14T00:00:00Z") });
expect(listPreferences()).not.toContain("pref-expiring.md");
expect(listRetired()).toContain("ret-expiring.md");
const retired = parseRetired(retiredPath(vault, "expiring"));
expect(retired.retired_reason).toBe("expired-unconfirmed");
expect(res.retired.map((r) => r.reason)).toContain("expired-unconfirmed");
});
});
// ----- Promotion ----------------------------------------------------------
describe("dream — unconfirmed → confirmed promotion on first applied evidence", () => {
test("first applied apply-evidence flips status and stamps confirmed_at", () => {
writePreference(vault, {
slug: "promote-me",
topic: "promote-me",
principle: "Trial rule",
created_at: "2026-05-01T00:00:00Z",
unconfirmed_until: "2026-05-30T00:00:00Z",
status: "unconfirmed",
evidenced_by: [],
});
// Drop an apply-evidence log entry.
appendApplyEvidence(
vault,
{
pref_id: "promote-me",
artifact: "[[x]]",
result: "applied",
agent: "claude",
},
{ now: new Date("2026-05-05T10:00:00Z") },
);
const res = dream(vault, { now: new Date("2026-05-06T00:00:00Z") });
expect(res.confirmed).toContain("pref-promote-me");
const pref = parsePreference(preferencePath(vault, "promote-me"));
expect(pref.status).toBe("confirmed");
expect(pref.confirmed_at).toBe("2026-05-05T10:00:00Z");
expect(pref.applied_count).toBe(1);
expect(pref.violated_count).toBe(0);
expect(pref.last_evidence_at).toBe("2026-05-05T10:00:00Z");
});
test("preserves evidence counts folded by brain merge", () => {
writePreference(vault, {
slug: "keep",
topic: "merge-evidence",
principle: "Keep this merged preference",
created_at: "2026-05-01T00:00:00Z",
unconfirmed_until: "2026-05-30T00:00:00Z",
status: "confirmed",
confirmed_at: "2026-05-02T00:00:00Z",
evidenced_by: ["[[sig-keep]]"],
});
writePreference(vault, {
slug: "drop",
topic: "merge-evidence",
principle: "Drop this merged preference",
created_at: "2026-05-01T00:00:00Z",
unconfirmed_until: "2026-05-30T00:00:00Z",
status: "confirmed",
confirmed_at: "2026-05-02T00:00:00Z",
evidenced_by: ["[[sig-drop]]"],
});
appendApplyEvidence(
vault,
{ pref_id: "keep", artifact: "[[k1]]", result: "applied", agent: "claude" },
{ now: new Date("2026-05-03T10:00:00Z") },
);
appendApplyEvidence(
vault,
{ pref_id: "keep", artifact: "[[k2]]", result: "applied", agent: "claude" },
{ now: new Date("2026-05-03T11:00:00Z") },
);
appendApplyEvidence(
vault,
{ pref_id: "drop", artifact: "[[d1]]", result: "applied", agent: "claude" },
{ now: new Date("2026-05-04T10:00:00Z") },
);
appendApplyEvidence(
vault,
{ pref_id: "drop", artifact: "[[d2]]", result: "violated", agent: "claude" },
{ now: new Date("2026-05-05T10:00:00Z") },
);
dream(vault, { now: new Date("2026-05-06T00:00:00Z") });
mergePreferences(vault, "pref-keep", "pref-drop", {
now: new Date("2026-05-07T00:00:00Z"),
agentName: "test-agent",
});
dream(vault, { now: new Date("2026-05-08T00:00:00Z") });
const pref = parsePreference(preferencePath(vault, "keep"));
expect(pref.applied_count).toBe(3);
expect(pref.violated_count).toBe(1);
expect(pref.last_evidence_at).toBe("2026-05-05T10:00:00Z");
});
});
// ----- Confidence formula -------------------------------------------------
describe("dream — confidence formula at boundaries", () => {
// We exercise the formula indirectly: seed evidence, run dream, read
// pref.confidence. Default config (from policy.ts):
// low_max_applied: 2, stale_evidence_days: 90,
// medium_min: 0.40, high_min: 0.75.
function setupForConfidence(
slug: string,
applied: number,
violated: number,
fresh: boolean,
): void {
writePreference(vault, {
slug,
topic: slug,
principle: "rule",
created_at: "2026-01-01T00:00:00Z",
unconfirmed_until: "2026-12-31T00:00:00Z",
status: "unconfirmed",
evidenced_by: [],
});
// Generate apply-evidence entries spread over days. The most
// recent one drives `last_evidence_at`. "fresh" anchors near
// `now` so freshness ≈ 1.0; "stale" puts evidence ~78 days back
// so the freshness multiplier collapses confidence_value.
const baseDate = fresh ? "2026-05-14" : "2026-01-01";
for (let i = 0; i < applied; i++) {
const d = new Date(`${baseDate}T10:00:0${i % 10}Z`);
appendApplyEvidence(
vault,
{ pref_id: slug, artifact: `[[a${i}]]`, result: "applied", agent: "claude" },
{ now: d },
);
}
for (let i = 0; i < violated; i++) {
const d = new Date(`${baseDate}T11:00:0${i % 10}Z`);
appendApplyEvidence(
vault,
{ pref_id: slug, artifact: `[[v${i}]]`, result: "violated", agent: "claude" },
{ now: d },
);
}
}
test("applied=0 → low", () => {
setupForConfidence("c-zero", 0, 0, true);
dream(vault, { now: new Date("2026-05-15T00:00:00Z") });
// No evidence at all means no refresh; the original `low` default
// remains.
const p = parsePreference(preferencePath(vault, "c-zero"));
expect(p.confidence).toBe("low");
});
test("applied=2 (== low_max_applied) → low", () => {
setupForConfidence("c-low-boundary", 2, 0, true);
dream(vault, { now: new Date("2026-05-15T00:00:00Z") });
const p = parsePreference(preferencePath(vault, "c-low-boundary"));
expect(p.confidence).toBe("low");
});
test("applied=3, violated=0, fresh → medium", () => {
setupForConfidence("c-medium", 3, 0, true);
dream(vault, { now: new Date("2026-05-15T00:00:00Z") });
const p = parsePreference(preferencePath(vault, "c-medium"));
expect(p.confidence).toBe("medium");
});
test("applied=10, violated=0, fresh → medium (Wilson ≈ 0.72, below high_min)", () => {
setupForConfidence("c-medium-10", 10, 0, true);
dream(vault, { now: new Date("2026-05-15T00:00:00Z") });
const p = parsePreference(preferencePath(vault, "c-medium-10"));
expect(p.confidence).toBe("medium");
});
test("applied=20, violated=0, fresh → high (Wilson ≈ 0.84, crosses high_min)", () => {
setupForConfidence("c-high", 20, 0, true);
dream(vault, { now: new Date("2026-05-15T00:00:00Z") });
const p = parsePreference(preferencePath(vault, "c-high"));
expect(p.confidence).toBe("high");
});
test("applied=10, violated>=applied → low", () => {
setupForConfidence("c-violated", 10, 10, true);
dream(vault, { now: new Date("2026-05-15T00:00:00Z") });
const p = parsePreference(preferencePath(vault, "c-violated"));
expect(p.confidence).toBe("low");
});
test("applied=10, violated=0, stale → low (freshness collapses the numeric value)", () => {
setupForConfidence("c-stale", 10, 0, false);
// Now is well beyond the freshness boundary but BEFORE the
// stale_evidence_days retire boundary (90 days). 2026-03-20 sits
// 78 days after the seeded evidence; freshness ≈ 0.13 multiplied
// by Wilson ≈ 0.72 yields value ≈ 0.10 — squarely in the low band.
dream(vault, { now: new Date("2026-03-20T00:00:00Z") });
const p = parsePreference(preferencePath(vault, "c-stale"));
expect(p.confidence).toBe("low");
});
});
// ----- Idempotency -------------------------------------------------------
describe("dream — idempotency and determinism", () => {
test("two consecutive runs with no new input: second run returns changed=false and writes no log entry", () => {
seedSignal({ topic: "idem", slug: "a", signal: "negative", date: "2026-05-14" });
seedSignal({ topic: "idem", slug: "b", signal: "negative", date: "2026-05-14" });
seedSignal({ topic: "idem", slug: "c", signal: "negative", date: "2026-05-14" });
const first = dream(vault, { now: new Date("2026-05-14T20:00:00Z") });
expect(first.changed).toBe(true);
const logBefore = readFileSync(join(brainDirs(vault).log, "2026-05-14.md"), "utf8");
// Second run on a fresh `now` so the run_id would be different.
const second = dream(vault, { now: new Date("2026-05-14T20:01:00Z") });
expect(second.changed).toBe(false);
const logAfter = readFileSync(join(brainDirs(vault).log, "2026-05-14.md"), "utf8");
expect(logAfter).toBe(logBefore);
});
test("determinism: same vault state + same --now → byte-identical preference files", () => {
seedSignal({ topic: "det", slug: "a", signal: "negative", date: "2026-05-14" });
seedSignal({ topic: "det", slug: "b", signal: "negative", date: "2026-05-14" });
seedSignal({ topic: "det", slug: "c", signal: "negative", date: "2026-05-14" });
const now = new Date("2026-05-14T20:00:00Z");
dream(vault, { now });
const prefBytes1 = readFileSync(preferencePath(vault, "det"), "utf8");
// Run dream again at the same now; since nothing else changed and
// the pref already exists, the second run should be a no-op and
// the bytes must match exactly.
dream(vault, { now });
const prefBytes2 = readFileSync(preferencePath(vault, "det"), "utf8");
expect(prefBytes2).toBe(prefBytes1);
});
});
// ----- Corrupted frontmatter tolerance ------------------------------------
describe("dream — corrupted frontmatter tolerance", () => {
test("valid signals processed; corrupted file produces skip-corrupted-frontmatter and does NOT abort", () => {
const dirs = brainDirs(vault);
seedSignal({ topic: "okay", slug: "a", signal: "negative", date: "2026-05-14" });
seedSignal({ topic: "okay", slug: "b", signal: "negative", date: "2026-05-14" });
seedSignal({ topic: "okay", slug: "c", signal: "negative", date: "2026-05-14" });
// Plant a corrupt signal file.
writeFileSync(
join(dirs.inbox, "sig-2026-05-14-broken.md"),
"---\nbroken: yaml\nno-required-fields: true\n---\n\nbody\n",
);
const res = dream(vault, { now: new Date("2026-05-14T20:00:00Z") });
expect(res.changed).toBe(true);
// The valid topic still got its preference.
expect(listPreferences()).toContain("pref-okay.md");
const { entries } = parseLogDay(vault, "2026-05-14");
const skips = entries.filter((e) => e.eventType === "skip-corrupted-frontmatter");
expect(skips.length).toBeGreaterThan(0);
expect(String(skips[0]!.body["path"])).toContain("sig-2026-05-14-broken.md");
});
});
// ----- Dry run ------------------------------------------------------------
describe("dream — dryRun mode", () => {
test("dryRun=true: summary planned but no files mutated", () => {
seedSignal({ topic: "dry", slug: "a", signal: "negative", date: "2026-05-14" });
seedSignal({ topic: "dry", slug: "b", signal: "negative", date: "2026-05-14" });
seedSignal({ topic: "dry", slug: "c", signal: "negative", date: "2026-05-14" });
const beforeInbox = listInboxActive().toSorted();
const beforePrefs = listPreferences().toSorted();
const beforeLog = existsSync(join(brainDirs(vault).log, "2026-05-14.md"));
const res = dream(vault, {
now: new Date("2026-05-14T20:00:00Z"),
dryRun: true,
});
expect(res.changed).toBe(true);
expect(res.new_unconfirmed).toEqual(["pref-dry"]);
expect(res.moved_to_processed).toHaveLength(3);
// dry_run flag distinguishes a planned-only return from a real run.
expect(res.dry_run).toBe(true);
// No log path on dry-run: the run never wrote to log/.
expect(res.log_path).toBeUndefined();
// Nothing actually changed on disk.
expect(listInboxActive().toSorted()).toEqual(beforeInbox);
expect(listPreferences().toSorted()).toEqual(beforePrefs);
expect(existsSync(join(brainDirs(vault).log, "2026-05-14.md"))).toBe(beforeLog);
});
});
// ----- Empty vault edge case ---------------------------------------------
describe("dream — empty Brain (no signals, no prefs)", () => {
test("returns changed=false with no log entry and no snapshot", () => {
const res = dream(vault, { now: new Date("2026-05-14T20:00:00Z") });
expect(res.changed).toBe(false);
expect(res.snapshot_path).toBeUndefined();
expect(existsSync(join(brainDirs(vault).log, "2026-05-14.md"))).toBe(false);
// Brain config still in place from bootstrap.
expect(existsSync(brainConfigPath(vault))).toBe(true);
});
});
// ----- Quarantine ---------------------------------------------------------
//
// Default brain config (`policy.ts`): low_max_applied = 2. The entry
// condition is `violated_count ≥ applied_count AND applied_count >
// low_max_applied`, so the smallest fixture needs applied ≥ 3 with
// violated ≥ applied. We seed evidence directly through the log.
describe("dream — quarantine entry", () => {
test("confirmed pref crosses violated≥applied with applied>low_max → quarantine", () => {
writePreference(vault, {
slug: "quarantine-target",
topic: "quarantine-target",
principle: "Trial rule",
created_at: "2026-05-01T00:00:00Z",
unconfirmed_until: "2026-05-30T00:00:00Z",
status: "confirmed",
confirmed_at: "2026-05-02T00:00:00Z",
evidenced_by: [],
applied_count: 0,
violated_count: 0,
last_evidence_at: null,
confidence: "low",
});
// 3 applied + 3 violated → entry condition met (applied=3 > 2 and violated=3 ≥ applied=3).
for (let i = 0; i < 3; i++) {
appendApplyEvidence(
vault,
{ pref_id: "quarantine-target", artifact: "[[a]]", result: "applied", agent: "claude" },
{ now: new Date(`2026-05-0${i + 3}T10:00:00Z`) },
);
}
for (let i = 0; i < 3; i++) {
appendApplyEvidence(
vault,
{ pref_id: "quarantine-target", artifact: "[[b]]", result: "violated", agent: "claude" },
{ now: new Date(`2026-05-0${i + 6}T10:00:00Z`) },
);
}
const res = dream(vault, { now: new Date("2026-05-10T00:00:00Z") });
expect(res.changed).toBe(true);
const pref = parsePreference(preferencePath(vault, "quarantine-target"));
expect(pref.status).toBe("quarantine");
expect(pref.applied_count).toBe(3);
expect(pref.violated_count).toBe(3);
// The pref stays in preferences/, NOT retired.
expect(listPreferences()).toContain("pref-quarantine-target.md");
expect(listRetired()).not.toContain("ret-quarantine-target.md");
});
test("low_max_applied gating — applied=2 with violated=2 stays confirmed", () => {
writePreference(vault, {
slug: "below-threshold",
topic: "below-threshold",
principle: "Trial rule",
created_at: "2026-05-01T00:00:00Z",
unconfirmed_until: "2026-05-30T00:00:00Z",
status: "confirmed",
confirmed_at: "2026-05-02T00:00:00Z",
evidenced_by: [],
applied_count: 0,
violated_count: 0,
last_evidence_at: null,
confidence: "low",
});
for (let i = 0; i < 2; i++) {
appendApplyEvidence(
vault,
{ pref_id: "below-threshold", artifact: "[[a]]", result: "applied", agent: "claude" },
{ now: new Date(`2026-05-0${i + 3}T10:00:00Z`) },
);
appendApplyEvidence(
vault,
{ pref_id: "below-threshold", artifact: "[[b]]", result: "violated", agent: "claude" },
{ now: new Date(`2026-05-0${i + 5}T10:00:00Z`) },
);
}
dream(vault, { now: new Date("2026-05-10T00:00:00Z") });
const pref = parsePreference(preferencePath(vault, "below-threshold"));
expect(pref.status).toBe("confirmed");
});
});
describe("dream — quarantine → retired (quarantine-violated)", () => {
test("new violated event on quarantine pref retires it", () => {
// Seed an already-quarantined pref directly: writePreference
// accepts the new status. applied=3, violated=3 is the persisted
// snapshot. Then add one more violated event in the log so
// dream sees violated > rec.pref.violated_count.
writePreference(vault, {
slug: "to-retire",
topic: "to-retire",
principle: "Probationary rule",
created_at: "2026-05-01T00:00:00Z",
unconfirmed_until: "2026-05-30T00:00:00Z",
status: "quarantine",
confirmed_at: "2026-05-02T00:00:00Z",
evidenced_by: [],
applied_count: 3,
violated_count: 3,
last_evidence_at: "2026-05-08T00:00:00Z",
confidence: "low",
});
// Mirror those counters in the log so the recompute matches the
// persisted snapshot, then add the trigger event.
for (let i = 0; i < 3; i++) {
appendApplyEvidence(
vault,
{ pref_id: "to-retire", artifact: "[[a]]", result: "applied", agent: "claude" },
{ now: new Date(`2026-05-0${i + 3}T10:00:00Z`) },
);
appendApplyEvidence(
vault,
{ pref_id: "to-retire", artifact: "[[b]]", result: "violated", agent: "claude" },
{ now: new Date(`2026-05-0${i + 6}T10:00:00Z`) },
);
}
appendApplyEvidence(
vault,
{ pref_id: "to-retire", artifact: "[[c]]", result: "violated", agent: "claude" },
{ now: new Date("2026-05-09T10:00:00Z") },
);
const res = dream(vault, { now: new Date("2026-05-10T00:00:00Z") });
expect(res.changed).toBe(true);
expect(listPreferences()).not.toContain("pref-to-retire.md");
expect(listRetired()).toContain("ret-to-retire.md");
const retired = parseRetired(retiredPath(vault, "to-retire"));
expect(retired.retired_reason).toBe("quarantine-violated");
expect(res.retired.map((r) => r.reason)).toContain("quarantine-violated");
});
test("pinned quarantine pref logs retain-pinned instead of retiring", () => {
writePreference(vault, {
slug: "pinned-quar",
topic: "pinned-quar",
principle: "Pinned rule",
created_at: "2026-05-01T00:00:00Z",
unconfirmed_until: "2026-05-30T00:00:00Z",
status: "quarantine",
confirmed_at: "2026-05-02T00:00:00Z",
evidenced_by: [],
applied_count: 3,
violated_count: 3,
last_evidence_at: "2026-05-08T00:00:00Z",
confidence: "low",
pinned: true,
});
for (let i = 0; i < 3; i++) {
appendApplyEvidence(
vault,
{ pref_id: "pinned-quar", artifact: "[[a]]", result: "applied", agent: "claude" },
{ now: new Date(`2026-05-0${i + 3}T10:00:00Z`) },
);
appendApplyEvidence(
vault,
{ pref_id: "pinned-quar", artifact: "[[b]]", result: "violated", agent: "claude" },
{ now: new Date(`2026-05-0${i + 6}T10:00:00Z`) },
);
}
appendApplyEvidence(
vault,
{ pref_id: "pinned-quar", artifact: "[[c]]", result: "violated", agent: "claude" },
{ now: new Date("2026-05-09T10:00:00Z") },
);
dream(vault, { now: new Date("2026-05-10T00:00:00Z") });
expect(listPreferences()).toContain("pref-pinned-quar.md");
expect(listRetired()).not.toContain("ret-pinned-quar.md");
const log = parseLogDay(vault, "2026-05-10");
const blocked = log.entries.find(
(e) =>
e.eventType === "retire" &&
e.body["preference"] === "[[pref-pinned-quar|Pinned rule]]" &&
e.body["blocked"] === "pinned",
);
expect(blocked).toBeDefined();
expect(blocked!.body["reason"]).toBe("quarantine-violated");
});
});
describe("dream — outdated evidence retires with superseded-by-context", () => {
test("single outdated event retires a confirmed pref", () => {
writePreference(vault, {
slug: "context-shift",
topic: "context-shift",
principle: "Recoverable rule",
created_at: "2026-05-01T00:00:00Z",
unconfirmed_until: "2026-05-30T00:00:00Z",
status: "confirmed",
confirmed_at: "2026-05-02T00:00:00Z",
evidenced_by: [],
applied_count: 4,
violated_count: 0,
last_evidence_at: "2026-05-08T00:00:00Z",
confidence: "medium",
});
appendApplyEvidence(
vault,
{ pref_id: "context-shift", artifact: "[[x]]", result: "outdated", agent: "claude" },
{ now: new Date("2026-05-09T10:00:00Z") },
);
const res = dream(vault, { now: new Date("2026-05-10T00:00:00Z") });
expect(res.changed).toBe(true);
expect(listPreferences()).not.toContain("pref-context-shift.md");
expect(listRetired()).toContain("ret-context-shift.md");
const retired = parseRetired(retiredPath(vault, "context-shift"));
expect(retired.retired_reason).toBe("superseded-by-context");
expect(res.retired.map((r) => r.reason)).toContain("superseded-by-context");
});
test("pinned pref also retires on outdated — pin doesn't protect against context shifts", () => {
writePreference(vault, {
slug: "pinned-outdated",
topic: "pinned-outdated",
principle: "Pinned rule",
created_at: "2026-05-01T00:00:00Z",
unconfirmed_until: "2026-05-30T00:00:00Z",
status: "confirmed",
confirmed_at: "2026-05-02T00:00:00Z",
evidenced_by: [],
applied_count: 3,
violated_count: 0,
last_evidence_at: "2026-05-08T00:00:00Z",
confidence: "medium",
pinned: true,
});
appendApplyEvidence(
vault,
{ pref_id: "pinned-outdated", artifact: "[[x]]", result: "outdated", agent: "claude" },
{ now: new Date("2026-05-09T10:00:00Z") },
);
const res = dream(vault, { now: new Date("2026-05-10T00:00:00Z") });
expect(res.changed).toBe(true);
expect(listPreferences()).not.toContain("pref-pinned-outdated.md");
expect(listRetired()).toContain("ret-pinned-outdated.md");
});
});
describe("dream — quarantine → confirmed (recovery)", () => {
test("applied > violated returns quarantine pref to confirmed", () => {
writePreference(vault, {
slug: "recover",
topic: "recover",
principle: "Recoverable rule",
created_at: "2026-05-01T00:00:00Z",
unconfirmed_until: "2026-05-30T00:00:00Z",
status: "quarantine",
confirmed_at: "2026-05-02T00:00:00Z",
evidenced_by: [],
applied_count: 3,
violated_count: 3,
last_evidence_at: "2026-05-08T00:00:00Z",
confidence: "low",
});
for (let i = 0; i < 3; i++) {
appendApplyEvidence(
vault,
{ pref_id: "recover", artifact: "[[a]]", result: "applied", agent: "claude" },
{ now: new Date(`2026-05-0${i + 3}T10:00:00Z`) },
);
appendApplyEvidence(
vault,
{ pref_id: "recover", artifact: "[[b]]", result: "violated", agent: "claude" },
{ now: new Date(`2026-05-0${i + 6}T10:00:00Z`) },
);
}
// Two fresh applied events flip the balance: applied=5 > violated=3.
appendApplyEvidence(
vault,
{ pref_id: "recover", artifact: "[[c]]", result: "applied", agent: "claude" },
{ now: new Date("2026-05-09T10:00:00Z") },
);
appendApplyEvidence(
vault,
{ pref_id: "recover", artifact: "[[d]]", result: "applied", agent: "claude" },
{ now: new Date("2026-05-09T11:00:00Z") },
);
dream(vault, { now: new Date("2026-05-10T00:00:00Z") });
const pref = parsePreference(preferencePath(vault, "recover"));
expect(pref.status).toBe("confirmed");
expect(pref.applied_count).toBe(5);
expect(pref.violated_count).toBe(3);
expect(listRetired()).not.toContain("ret-recover.md");
});
});