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
/**
* Event-time vs storage-time discipline (Time-Aware Recall &
* Activation Suite, t_b7191486): documents declaring `valid_from` /
* `valid_until` are filtered by their validity window (interval
* overlap), never by storage mtime; documents without validity fields
* keep the mtime fallback byte-identically.
*/
import { test, expect, beforeEach, afterEach, describe } from "bun:test";
import { utimesSync } from "node:fs";
import { eventTimeInRange, parseValidityWindow } from "../../../src/core/search/validity.ts";
import { indexVault } from "../../../src/core/search/indexer.ts";
import { search } from "../../../src/core/search/search.ts";
import { createTempVault, makeConfig, writeMd } from "../../helpers/search-fixtures.ts";
const DAY = 24 * 60 * 60 * 1000;
describe("parseValidityWindow (pure)", () => {
test("absent fields mean no window", () => {
expect(parseValidityWindow({})).toBeNull();
expect(parseValidityWindow({ other: "x" })).toBeNull();
});
test("bare ISO dates resolve to day bounds in UTC", () => {
const w = parseValidityWindow({ valid_from: "2026-05-01", valid_until: "2026-05-03" });
expect(w?.validFromMs).toBe(Date.UTC(2026, 4, 1));
expect(w?.validUntilMs).toBe(Date.UTC(2026, 4, 4) - 1);
expect(w?.invalid).toBe(false);
});
test("one-sided windows leave the other edge open", () => {
const from = parseValidityWindow({ valid_from: "2026-05-01T10:00:00Z" });
expect(from?.validFromMs).toBe(Date.UTC(2026, 4, 1, 10));
expect(from?.validUntilMs).toBeNull();
const until = parseValidityWindow({ valid_until: "2026-05-01" });
expect(until?.validFromMs).toBeNull();
});
test("junk values flag the window invalid", () => {
const w = parseValidityWindow({ valid_from: "soonish" });
expect(w?.invalid).toBe(true);
});
});
describe("eventTimeInRange (pure)", () => {
const range = { sinceMs: Date.UTC(2026, 4, 10), untilMs: Date.UTC(2026, 4, 20) };
test("overlap semantics: any intersection passes", () => {
const before = parseValidityWindow({ valid_from: "2026-05-01", valid_until: "2026-05-05" });
const spanning = parseValidityWindow({ valid_from: "2026-05-05", valid_until: "2026-05-15" });
const inside = parseValidityWindow({ valid_from: "2026-05-12", valid_until: "2026-05-13" });
expect(eventTimeInRange(before, 0, range)).toBe(false);
expect(eventTimeInRange(spanning, 0, range)).toBe(true);
expect(eventTimeInRange(inside, 0, range)).toBe(true);
});
test("no window falls back to mtime", () => {
const inRangeMtime = Date.UTC(2026, 4, 15) / 1000;
const outRangeMtime = Date.UTC(2026, 4, 1) / 1000;
expect(eventTimeInRange(null, inRangeMtime, range)).toBe(true);
expect(eventTimeInRange(null, outRangeMtime, range)).toBe(false);
});
test("an invalid window also falls back to mtime", () => {
const w = parseValidityWindow({ valid_from: "garbage" });
expect(eventTimeInRange(w, Date.UTC(2026, 4, 15) / 1000, range)).toBe(true);
expect(eventTimeInRange(w, Date.UTC(2026, 4, 1) / 1000, range)).toBe(false);
});
});
describe("search() event-time discipline", () => {
let vault: string;
let dbPath: string;
let cleanup: () => void;
beforeEach(() => {
({ vault, dbPath, cleanup } = createTempVault("validity"));
});
afterEach(() => {
cleanup();
});
test("event time is the authority over storage time, both directions", async () => {
const now = Date.now();
const recentEvent = new Date(now - 2 * DAY).toISOString();
const oldEvent = new Date(now - 200 * DAY).toISOString();
// Old file describing a recent event: must be FOUND by since=7d.
const oldFile = writeMd(
vault,
"Brain/notes/old-file-recent-event.md",
`---\nvalid_from: ${recentEvent}\n---\n\n# Recent\n\nHarbor dredging incident report.\n`,
);
// Fresh file describing an old, closed event: must be EXCLUDED.
writeMd(
vault,
"Brain/notes/new-file-old-event.md",
`---\nvalid_from: ${oldEvent}\nvalid_until: ${oldEvent}\n---\n\n# Old\n\nHarbor dredging incident report.\n`,
);
// No validity fields: mtime fallback keeps it in range.
writeMd(vault, "Brain/notes/plain.md", "# Plain\n\nHarbor dredging incident report.\n");
const config = makeConfig({ vault, dbPath, maxHops: 0, mmrLambda: 1 });
await indexVault(config);
// Make the event-recent file's mtime ancient AFTER indexing the
// content (the index stores mtime at index time, so reindex).
const ancient = new Date(now - 300 * DAY);
utimesSync(oldFile, ancient, ancient);
await indexVault(config);
const outcome = await search(config, { query: "harbor dredging incident", since: "7d" });
const paths = outcome.results.map((r) => r.path);
expect(paths).toContain("Brain/notes/old-file-recent-event.md");
expect(paths).not.toContain("Brain/notes/new-file-old-event.md");
expect(paths).toContain("Brain/notes/plain.md");
});
test("an unparseable validity value warns and falls back to mtime", async () => {
writeMd(
vault,
"Brain/notes/broken.md",
"---\nvalid_from: not-a-date\n---\n\n# Broken\n\nHarbor dredging incident report.\n",
);
const config = makeConfig({ vault, dbPath, maxHops: 0, mmrLambda: 1 });
await indexVault(config);
const outcome = await search(config, { query: "harbor dredging incident", since: "7d" });
expect(outcome.results.map((r) => r.path)).toContain("Brain/notes/broken.md");
expect(outcome.warnings.some((w) => w.includes("validity"))).toBe(true);
});
});