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
6.4 KB
Raw Blame
/**
 * The reach and ownership views judge a store record by its own partition
 * and fields once switched (task 2.10, design D14 item 18): a shared
 * preference is visible at remote reach like an open page, a private one
 * is not, and an owned one only to its owner. At local reach everything is
 * visible. The answers equal those an unswitched machine gives for the
 * same preferences written as pages.
 */
import { describe, expect, test } from "bun:test";
import { readFileSync, writeFileSync } from "node:fs";
import { join, relative, sep } from "node:path";

import { ownerScopeView } from "../../../src/core/brain/owner-scope-view.ts";
import { moveToRetired, writePreference } from "../../../src/core/brain/preference.ts";
import {
  existingPreferencePageText,
  writePreferencePageText,
} from "../../../src/core/brain/preference-page-write.ts";
import { reachView } from "../../../src/core/brain/reach-view.ts";
import { TRANSPORT_REACH } from "../../../src/core/graph/transport-reach.ts";
import { formatFrontmatter, parseFrontmatterText } from "../../../src/core/vault.ts";
import { laneVaultRoot, writeLaneText } from "../../../src/core/store/lane-pages.ts";
import { makeStoreEnv } from "../store/fixtures/store-env.ts";
import { withMemoryFixture, type MemoryMode } from "./fixtures/memory-twins.ts";

const pref = (slug: string) => ({
  slug,
  topic: slug,
  principle: `principle ${slug}`,
  created_at: "2026-11-01T00:00:00Z",
  unconfirmed_until: "2026-11-30T00:00:00Z",
  status: "unconfirmed" as const,
  evidenced_by: [] as string[],
});

/** Rewrite `pref-<slug>`'s page with `extra` frontmatter keys. */
function withKeys(vault: string, slug: string, extra: Record<string, string>): void {
  const text = existingPreferencePageText(vault, slug, (p) => readFileSync(p, "utf8"));
  if (text === null) throw new Error("no preference");
  const [meta, body] = parseFrontmatterText(text);
  writePreferencePageText(vault, slug, formatFrontmatter({ ...meta, ...extra }, body));
}

const REFS = ["pref-open", "pref-secret", "pref-owned", "[[pref-open]]", "pref-absent"];

function answers(mode: MemoryMode) {
  return withMemoryFixture(
    mode,
    (env) => {
      for (const slug of ["open", "secret", "owned"]) {
        writePreference(env.vault, pref(slug), { authority: "agent" });
      }
      withKeys(env.vault, "secret", { visibility: "private" });
      withKeys(env.vault, "owned", { owner: "alice" });
      const remote = reachView(env.vault, TRANSPORT_REACH.remote);
      const local = reachView(env.vault, TRANSPORT_REACH.local);
      const alice = ownerScopeView(env.vault, "alice");
      const bob = ownerScopeView(env.vault, "bob");
      return {
        remote: REFS.map((r) => remote.visible(r)),
        local: REFS.map((r) => local.visible(r)),
        alice: REFS.map((r) => alice.visible(r)),
        bob: REFS.map((r) => bob.visible(r)),
      };
    },
    { seed: false },
  );
}

describe("store record visibility", () => {
  const legacy = answers("legacy");
  const switched = answers("switched");

  test("remote reach: a shared record is visible, a private one is not", () => {
    expect(switched.remote).toEqual([true, false, true, true, true]);
  });

  test("local reach: every record is visible", () => {
    expect(switched.local).toEqual([true, true, true, true, true]);
  });

  test("owner scope: an owned record only to its owner", () => {
    expect(switched.alice).toEqual([true, true, true, true, true]);
    expect(switched.bob).toEqual([true, true, false, true, true]);
  });

  test("the answers equal the unswitched machine's for the same pages", () => {
    expect(switched).toEqual(legacy);
  });
});

describe("store record visibility with no vault", () => {
  test("a retired private preference spelled pref-x is hidden; lane pages by their record", () => {
    const env = makeStoreEnv("osb-visibility-novault-", {
      legacyTree: false,
      configureVault: false,
    });
    try {
      const written = writePreference(
        null,
        { ...pref("hush"), principle: "keep <private>this</private> to me" },
        { authority: "agent" },
      );
      moveToRetired(null, written.path, "stale-no-evidence", {
        now: new Date("2026-11-07T12:00:00Z"),
        retired_by: "@t",
      });
      const root = laneVaultRoot(null);
      writeLaneText(
        root,
        join(root, "Brain", "decisions", "open.md"),
        "---\nkind: d\n---\nOpen.\n",
      );
      writeLaneText(
        root,
        join(root, "Brain", "decisions", "held.md"),
        "---\nkind: d\nvisibility: [private]\n---\nHeld.\n",
      );
      const remote = reachView(null, TRANSPORT_REACH.remote);
      expect(remote.visible("[[ret-hush]]")).toBe(false);
      expect(remote.visible("[[pref-hush]]")).toBe(false);
      expect(remote.visible("Brain/decisions/open.md")).toBe(true);
      expect(remote.visible("Brain/decisions/held.md")).toBe(false);
      expect(remote.visible("Brain/decisions/gone.md")).toBe(false);
      expect(remote.visible("tension-unknown")).toBe(true);
    } finally {
      env.cleanup();
    }
  });

  test("lane pages follow each view's own rule: reach, owner scope, containment", () => {
    const env = makeStoreEnv("osb-visibility-novault-lanes-", {
      legacyTree: false,
      configureVault: false,
    });
    try {
      const root = laneVaultRoot(null);
      writeLaneText(
        root,
        join(root, "Brain", "decisions", "held.md"),
        "---\nkind: d\nvisibility: [private]\n---\nHeld.\n",
      );
      writeLaneText(
        root,
        join(root, "Brain", "decisions", "bobs.md"),
        "---\nkind: d\nowner: bob\n---\nBob's.\n",
      );
      // A private page is readable at local reach, as a private record is.
      expect(reachView(null, TRANSPORT_REACH.local).visible("Brain/decisions/held.md")).toBe(true);
      // Another scope's page is hidden from alice, shown to bob.
      expect(ownerScopeView(null, "alice").visible("Brain/decisions/bobs.md")).toBe(false);
      expect(ownerScopeView(null, "bob").visible("Brain/decisions/bobs.md")).toBe(true);
      // A reference that climbs out of Brain/ names no lane page.
      writeFileSync(join(env.parent, "outside.md"), "---\nkind: d\n---\nOutside.\n");
      const climb = `Brain/${relative(join(root, "Brain"), join(env.parent, "outside.md"))
        .split(sep)
        .join("/")}`;
      expect(climb).toContain("..");
      expect(reachView(null, TRANSPORT_REACH.remote).visible(climb)).toBe(false);
    } finally {
      env.cleanup();
    }
  });
});