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
5.3 KB
Raw Blame
/**
 * Continuity read-model (Memory Observability Suite kernel).
 *
 * One normalization layer between the raw JSONL store and every
 * read-side consumer (ATOF/ATIF export, bench harness): schema-version
 * dispatch with legacy records reading as v1, a caller-explicit masking
 * policy for `private` records, and fail-soft handling of unknown kinds
 * and malformed rows - so consumers cannot disagree on any of it.
 */

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 { appendContinuityRecord } from "../../../src/core/brain/continuity/store.ts";
import {
  loadNormalizedContinuityRecords,
  normalizeContinuityRecord,
} from "../../../src/core/brain/continuity/read-model.ts";
import { CONTINUITY_SCHEMA_VERSION } from "../../../src/core/brain/continuity/types.ts";

let vault: string;

beforeEach(() => {
  vault = mkdtempSync(join(tmpdir(), "o2b-read-model-"));
  // A legacy Brain/ tree: an unswitched machine (a vault without one is store-only).
  mkdirSync(join(vault, "Brain"), { recursive: true });
});

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

const LEGACY_RAW = {
  id: "ctn_20260101120000_aaaaaaaaaaaaaaaa",
  kind: "recall_telemetry",
  createdAt: "2026-01-01T12:00:00Z",
  sourceRefs: [{ id: "note-a" }],
  payload: { status: "ok" },
  private: false,
  redacted: false,
};

describe("normalizeContinuityRecord", () => {
  test("a stamped record keeps its version; a legacy record reads as v1", () => {
    const stamped = normalizeContinuityRecord({
      ...LEGACY_RAW,
      schema: CONTINUITY_SCHEMA_VERSION,
    });
    expect(stamped).not.toBeNull();
    expect(stamped!.schema).toBe(CONTINUITY_SCHEMA_VERSION);
    expect(stamped!.legacy).toBe(false);

    const legacy = normalizeContinuityRecord(LEGACY_RAW);
    expect(legacy).not.toBeNull();
    expect(legacy!.schema).toBe(CONTINUITY_SCHEMA_VERSION);
    expect(legacy!.legacy).toBe(true);
  });

  test("session/turn correlation ids surface as first-class fields", () => {
    const normalized = normalizeContinuityRecord({
      ...LEGACY_RAW,
      kind: "session_turn",
      payload: { session_id: "s-1", turn_id: "t-3", role: "user", text: "hello" },
    });
    expect(normalized!.sessionId).toBe("s-1");
    expect(normalized!.turnId).toBe("t-3");
  });

  test("agent_id surfaces as a first-class field (t_5be0654d)", () => {
    const normalized = normalizeContinuityRecord({
      ...LEGACY_RAW,
      kind: "token_impact",
      payload: { session_id: "s-1", agent_id: "claude-dev-agent", delta_tokens: 60 },
    });
    expect(normalized!.agentId).toBe("claude-dev-agent");
    // Absent agent_id leaves the field undefined (byte-identical for old records).
    const without = normalizeContinuityRecord(LEGACY_RAW);
    expect(without!.agentId).toBeUndefined();
  });

  test("malformed rows and non-record values normalize to null, fail-soft", () => {
    expect(normalizeContinuityRecord(null)).toBeNull();
    expect(normalizeContinuityRecord("garbage")).toBeNull();
    expect(normalizeContinuityRecord({ kind: "recall_telemetry" })).toBeNull();
    // Unknown kinds stay readable - the evolution rule says additive.
    const unknown = normalizeContinuityRecord({ ...LEGACY_RAW, kind: "future_kind" });
    expect(unknown).not.toBeNull();
    expect(unknown!.kind).toBe("future_kind");
  });
});

describe("loadNormalizedContinuityRecords", () => {
  test("private records are dropped by default and kept only on request", () => {
    appendContinuityRecord(vault, {
      kind: "context_receipt",
      createdAt: "2026-06-03T10:00:00Z",
      payload: { text: "open detail" },
    });
    appendContinuityRecord(vault, {
      kind: "context_receipt",
      createdAt: "2026-06-03T10:01:00Z",
      payload: { text: "carries a <private>secret plan</private> region" },
    });

    const safe = loadNormalizedContinuityRecords(vault);
    expect(safe).toHaveLength(1);
    expect(JSON.stringify(safe)).not.toContain("secret plan");

    const all = loadNormalizedContinuityRecords(vault, { keepPrivate: true });
    expect(all).toHaveLength(2);
    // Even kept records stay redaction-masked: the store stripped the
    // region at write time and the read-model never un-masks.
    expect(JSON.stringify(all)).not.toContain("secret plan");
  });

  test("kind and session filters narrow the load", () => {
    appendContinuityRecord(vault, {
      kind: "session_turn",
      createdAt: "2026-06-03T10:00:00Z",
      payload: { session_id: "s-1", turn_id: "t-1", role: "user", text: "alpha" },
    });
    appendContinuityRecord(vault, {
      kind: "session_turn",
      createdAt: "2026-06-03T10:01:00Z",
      payload: { session_id: "s-2", turn_id: "t-1", role: "user", text: "beta" },
    });
    appendContinuityRecord(vault, {
      kind: "recall_telemetry",
      createdAt: "2026-06-03T10:02:00Z",
      payload: { status: "ok", session_id: "s-1" },
    });

    const turns = loadNormalizedContinuityRecords(vault, { kind: "session_turn" });
    expect(turns).toHaveLength(2);
    const sessionOne = loadNormalizedContinuityRecords(vault, { sessionId: "s-1" });
    expect(sessionOne).toHaveLength(2);
    expect(sessionOne.every((r) => r.sessionId === "s-1")).toBe(true);
  });
});