"@effect/platform-node": "catalog:",

    "@effect/platform-node-shared": "4.0.0-beta.94",

    "effect": "catalog:",

    "@noble/curves": "1.8.1",

    "@noble/hashes": "1.7.1",

    "ollama": "^0.6.3",

    "ws": "8.21.1"

  },

import { createHmac, randomBytes } from "node:crypto";

import { randomBytes } from "node:crypto";

import {

  appendFileSync,

  chmodSync,

} from "node:fs";

import { homedir } from "node:os";

import { join } from "node:path";

import { schnorr } from "@noble/curves/secp256k1";

import { bytesToHex } from "@noble/hashes/utils";

import {

  buildEngramBody,

  buildEngramEvent,

  buildSupersedingBody,

  buildSubagentMemoryContext,

  computeEngramEventId,

  consolidateEpisodes,

  engramContentDigest,

  guardEngramContent,

  harvestSubagentOutcome,

  ledgerEntriesAsHeuristics,

  promoteHeuristicToPattern,

  signSupersedingEngram,

  EngramSyncQueue,

  EngramBody,

  EngramEvent,

  ENGRAM_ALT,

  MemoryTransport,

  project,

  projectedValue,

  projectionMatches,

  verifyEngramEventId,

  COMPANION_SCHEMA_ID,

  ENGRAM_KIND,

  HarvestedLedgerEntry,

  type EngramEvent,

  type EngramBody,

  type EngramTransport,

  type ParentHeuristic,

  type Projection,

 * bounded advisory block (#226). Between sessions the ledger is the memory —

 * one JSONL file of NIP-AE-shaped engram events under `~/.openagents/memory`,

 * every value through the hard-unsafe redaction gate before it is signed, and

 * every read re-verifying event ids and supersession chains.

 * every read re-verifying event ids, NIP-01 Schnorr signatures, supersession

 * chains, and author identity.

 *

 * The signature is a local HMAC over the canonical event id with a key held at

 * `~/.openagents/memory/signing-key` (0600) — integrity against accidental

 * edits and a stable authorship mark for this machine, not a Nostr Schnorr

 * signature. When the relay sync adapter (#222) lands, the same events re-sign

 * under a real Nostr key; the body and chain shapes are already NIP-AE.

 * The secret key is a 32-byte Nostr private key held at

 * `~/.openagents/memory/signing-key` (0600). The same key file is reused from

 * the HMAC era: the 64-hex bytes are now interpreted as a secp256k1 private

 * key. Old HMAC-signed events fail verification and are not projected.

 */

const decodeLedgerEntry = S.decodeUnknownSync(HarvestedLedgerEntry);

  private readonly projectScope: string;

  private readonly now: () => number;

  private readonly dreamThreshold: number;

  private key: Buffer | undefined;

  private cachedIdentity: { readonly secretKey: Uint8Array; readonly pubkey: string } | undefined;

  private cachedProjection: Projection | undefined;

  private readonly sync: EngramSyncQueue;

    return this.sync.drain();

  }

  /** The local signing key, created on first use. */

  private signingKey(): Buffer {

    if (this.key !== undefined) return this.key;

  /**

   * The local secp256k1 private key, created on first use and stored 0600.

   *

   * HMAC-era `signing-key` files were also 64-hex bytes, but their value was

   * used as an HMAC secret. NIP-01 migrations keep the same file and treat the

   * 32 bytes as a secp256k1 private key. If the bytes are not a valid Nostr

   * private key, the file is overwritten with a fresh generated key and the

   * ledger key changes. Old HMAC-signed events then fail author/signature

   * verification and are not projected.

   */

  private signingKey(): { readonly secretKey: Uint8Array; readonly pubkey: string } {

    if (this.cachedIdentity !== undefined) return this.cachedIdentity;

    mkdirSync(this.directory, { recursive: true, mode: 0o700 });

    if (!existsSync(this.keyPath)) {

      writeFileSync(this.keyPath, randomBytes(32).toString("hex"), { mode: 0o600 });

      chmodSync(this.keyPath, 0o600);

    let loaded: string | undefined;

    if (existsSync(this.keyPath)) {

      const raw = readFileSync(this.keyPath, "utf8").trim().toLowerCase();

      if (/^[0-9a-f]{64}$/.test(raw)) {

        loaded = raw;

      }

    }

    if (loaded !== undefined) {

      const secretKey = Buffer.from(loaded, "hex");

      try {

        const pubkey = bytesToHex(schnorr.getPublicKey(secretKey));

        this.cachedIdentity = { secretKey, pubkey };

        return this.cachedIdentity;

      } catch {

        // Invalid legacy key; fall through to generate a fresh one.

      }

    }

    this.key = Buffer.from(readFileSync(this.keyPath, "utf8").trim(), "hex");

    return this.key;

    let secretKey: Uint8Array;

    let pubkey: string;

    do {

      secretKey = randomBytes(32);

      try {

        pubkey = bytesToHex(schnorr.getPublicKey(secretKey));

      } catch {

        pubkey = "";

      }

    } while (pubkey === "");

    this.writePrivateKey(Buffer.from(secretKey).toString("hex"));

    this.cachedIdentity = { secretKey, pubkey };

    return this.cachedIdentity;

  }

  private signer(): { pubkey: string; sign: (eventId: string) => string } {

    const key = this.signingKey();

    // A stable 64-hex identity derived from the key, so events from the same

    // machine share an author without the key itself ever leaving the file.

    const pubkey = createHmac("sha256", key).update("openagents.coder-memory.pubkey").digest("hex");

    return {

      pubkey,

      sign: (eventId: string) => createHmac("sha256", key).update(eventId).digest("hex"),

    };

  private writePrivateKey(privateKey: string): void {

    writeFileSync(this.keyPath, privateKey, { mode: 0o600 });

    chmodSync(this.keyPath, 0o600);

  }

  /** True when the event id, signature, and author all match this key. */

  private isValidEngram(event: EngramEvent): boolean {

    if (event.pubkey !== this.signingKey().pubkey) return false;

    if (event.id !== computeEngramEventId(event)) return false;

    try {

      return schnorr.verify(event.sig, event.id, event.pubkey);

    } catch {

      return false;

    }

  }

  /**

      relations: [],

      derivedFromSlugs: [...derivedFromSlugs],

    });

    const { pubkey, sign } = this.signer();

    const event = buildEngramEvent(

      pubkey,

      Math.floor(this.now() / 1000),

      slug,

      JSON.stringify(body),

      sign,

    );

    const { secretKey, pubkey } = this.signingKey();

    const created_at = Math.floor(this.now() / 1000);

    const tags = [

      ["d", slug],

      ["alt", ENGRAM_ALT],

    ];

    const content = JSON.stringify(body);

    const partial = { kind: ENGRAM_KIND, created_at, tags, content, pubkey };

    const id = computeEngramEventId(partial as unknown as EngramEvent);

    const sig = bytesToHex(schnorr.sign(id, secretKey));

    const event = S.decodeUnknownSync(EngramEvent)({ kind: ENGRAM_KIND, created_at, tags, content, pubkey, id, sig });

    appendFileSync(this.ledgerPath, `${JSON.stringify(event)}\n`, { mode: 0o600 });

    this.cachedProjection = undefined;

    // Local-first: the engram is on disk and readable now. Sync catches up.

    if (prior === undefined) return undefined;

    const verdict = guardEngramContent(newValue);

    if (!verdict.storable) return undefined;

    const { pubkey, sign } = this.signer();

    const event = signSupersedingEngram(

      prior,

      verdict.redacted,

      Math.max(Math.floor(this.now() / 1000), prior.created_at + 1),

      pubkey,

      sign,

    );

    const dTag = prior.tags.find((tag) => tag[0] === "d")?.[1];

    if (dTag === undefined) return undefined;

    const priorBody = S.decodeUnknownSync(EngramBody)(JSON.parse(prior.content));

    const body = buildSupersedingBody(priorBody, verdict.redacted, prior.id);

    const { secretKey, pubkey } = this.signingKey();

    const created_at = Math.max(Math.floor(this.now() / 1000), prior.created_at + 1);

    const tags = [

      ["d", dTag],

      ["alt", ENGRAM_ALT],

    ];

    const content = JSON.stringify(body);

    const partial = { kind: ENGRAM_KIND, created_at, tags, content, pubkey };

    const id = computeEngramEventId(partial as unknown as EngramEvent);

    const sig = bytesToHex(schnorr.sign(id, secretKey));

    const event = S.decodeUnknownSync(EngramEvent)({ kind: ENGRAM_KIND, created_at, tags, content, pubkey, id, sig });

    appendFileSync(this.ledgerPath, `${JSON.stringify(event)}\n`, { mode: 0o600 });

    this.cachedProjection = undefined;

    this.sync.publish(event);

    return event;

  }

  /** Every engram on disk, malformed lines dropped. The projection judges them. */

  /** Every verified engram on disk; malformed or unverified lines are dropped. */

  private events(): ReadonlyArray<EngramEvent> {

    if (!existsSync(this.ledgerPath)) return [];

    const events: Array<EngramEvent> = [];

    for (const line of readFileSync(this.ledgerPath, "utf8").split("\n")) {

      if (line.trim().length === 0) continue;

      let event: EngramEvent;

      try {

        events.push(JSON.parse(line) as EngramEvent);

        event = S.decodeUnknownSync(EngramEvent)(JSON.parse(line));

      } catch {

        continue;

      }

      if (!this.isValidEngram(event)) continue;

      events.push(event);

    }

    return events;

  }

  /** All ledger events grouped per slug in append order, invalid lines dropped. */

  /** All verified ledger events grouped per slug in append order. */

  private chains(): Map<string, Array<EngramEvent>> {

    const chains = new Map<string, Array<EngramEvent>>();

    if (!existsSync(this.ledgerPath)) return chains;

      if (line.trim().length === 0) continue;

      let event: EngramEvent;

      try {

        event = JSON.parse(line) as EngramEvent;

        event = S.decodeUnknownSync(EngramEvent)(JSON.parse(line));

      } catch {

        continue;

      }

      if (!verifyEngramEventId(event)) continue;

      if (!this.isValidEngram(event)) continue;

      const dTag = event.tags.find((tag) => tag[0] === "d")?.[1];

      if (dTag === undefined) continue;

      const chain = chains.get(dTag) ?? [];

import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";

import { createHmac } from "node:crypto";

import { appendFileSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";

import { tmpdir } from "node:os";

import { join } from "node:path";

import { afterEach, describe, expect, it } from "vitest";

import { schnorr } from "@noble/curves/secp256k1";

import { bytesToHex } from "@noble/hashes/utils";

import { CoderMemory } from "../src/coder-memory.js";

import { MemoryTransport } from "../src/memory/index.js";

import {

  MemoryTransport,

  buildEngramBody,

  buildEngramEvent,

  engramContentDigest,

} from "../src/memory/index.js";

import { DelegateFleet, type DelegateEvent, type DelegateHarness } from "../src/coder-delegate.js";

import { CoderTaskRegistry } from "../src/coder-tasks.js";

const localPrivateKeyHex = `${"0".repeat(63)}1`;

const foreignPrivateKeyHex = `${"0".repeat(63)}2`;

const runPubkey = (hex: string): string => bytesToHex(schnorr.getPublicKey(Buffer.from(hex, "hex")));

const signWith = (hex: string) => (message: string): string =>

  bytesToHex(schnorr.sign(message, Buffer.from(hex, "hex")));

const hmacPubkeyFor = (keyHex: string): string =>

  createHmac("sha256", Buffer.from(keyHex, "hex")).update("openagents.coder-memory.pubkey").digest("hex");

const hmacSignFor = (keyHex: string) => (eventId: string): string =>

  createHmac("sha256", Buffer.from(keyHex, "hex")).update(eventId).digest("hex");

const memoryAtWithKey = (

  dir: string,

  keyHex = localPrivateKeyHex,

  nowMs = 1_756_000_000_000,

): CoderMemory => {

  writeFileSync(join(dir, "signing-key"), keyHex, { mode: 0o600 });

  return new CoderMemory({ directory: dir, projectScope: "project:test", now: () => nowMs });

};

const dirs: Array<string> = [];

const freshDir = (): string => {

  const dir = mkdtempSync(join(tmpdir(), "coder-memory-test-"));

    expect(transport.stored()).toHaveLength(1);

  });

});

describe("NIP-01 secp256k1 ledger integrity", () => {

  const makeBody = (slug: string, value: string) =>

    buildEngramBody(

      slug,

      value,

      {

        admission: "admitted",

        entityId: "test",

        contentDigest: engramContentDigest(value),

        sourceEventRefs: [],

        relations: [],

        derivedFromSlugs: [],

      } as const,

    );

  it("records an engram with a 128-hex NIP-01 Schnorr signature and its own public key", () => {

    const dir = freshDir();

    const memory = memoryAtWithKey(dir, localPrivateKeyHex);

    const event = memory.record("note/nip01", "ranged reads are better", "note-1");

    expect(event).toBeDefined();

    expect(event!.sig).toMatch(/^[0-9a-f]{128}$/);

    expect(event!.pubkey).toBe(runPubkey(localPrivateKeyHex));

    expect(memoryAtWithKey(dir, localPrivateKeyHex).bodies()).toHaveLength(1);

  });

  it("rejects an event with a valid content id but an invalid signature", () => {

    const dir = freshDir();

    memoryAtWithKey(dir, localPrivateKeyHex).record("note/one", "a finding", "note-1");

    const path = join(dir, "engrams.jsonl");

    const lines = readFileSync(path, "utf8").trim().split("\n");

    const event = JSON.parse(lines[0]!);

    event.sig = "f".repeat(128);

    rmSync(path);

    writeFileSync(path, `${JSON.stringify(event)}\n`);

    expect(memoryAtWithKey(dir, localPrivateKeyHex).bodies()).toHaveLength(0);

  });

  it("rejects a foreign-key engram with a valid NIP-01 signature", () => {

    const dir = freshDir();

    memoryAtWithKey(dir, localPrivateKeyHex);

    const foreignPubkey = runPubkey(foreignPrivateKeyHex);

    const foreignSign = signWith(foreignPrivateKeyHex);

    const foreignEvent = buildEngramEvent(

      foreignPubkey,

      1000,

      "foreign/one",

      JSON.stringify(makeBody("foreign/one", "from someone else")),

      foreignSign,

    );

    appendFileSync(join(dir, "engrams.jsonl"), `${JSON.stringify(foreignEvent)}\n`);

    expect(memoryAtWithKey(dir, localPrivateKeyHex).bodies()).toHaveLength(0);

  });

  it("does not crash on an HMAC-era ledger and does not project its events", () => {

    const dir = freshDir();

    const hmacPubkey = hmacPubkeyFor(localPrivateKeyHex);

    const hmacSign = hmacSignFor(localPrivateKeyHex);

    const body = makeBody("hmac/one", "hmac-era content");

    const hmacEvent = buildEngramEvent(

      hmacPubkey,

      1000,

      "hmac/one",

      JSON.stringify(body),

      hmacSign,

    );

    writeFileSync(join(dir, "signing-key"), localPrivateKeyHex, { mode: 0o600 });

    writeFileSync(join(dir, "engrams.jsonl"), `${JSON.stringify(hmacEvent)}\n`);

    const reader = new CoderMemory({

      directory: dir,

      projectScope: "project:test",

      now: () => 1_756_000_000_000,

    });

    expect(() => reader.bodies()).not.toThrow();

    expect(reader.bodies()).toHaveLength(0);

    // New NIP-01 records continue to work using the same key file.

    reader.record("note/one", "new fact", "note-1");

    expect(reader.bodies()).toHaveLength(1);

  });

});

      '@effect/platform-node-shared':

        specifier: 4.0.0-beta.94

        version: 4.0.0-beta.94(effect@4.0.0-beta.94)

      '@noble/curves':

        specifier: 1.8.1

        version: 1.8.1

      '@noble/hashes':

        specifier: 1.7.1

        version: 1.7.1

      effect:

        specifier: 4.0.0-beta.94

        version: 4.0.0-beta.94

    dependencies:

      '@testing-library/dom': 10.4.1

      '@testing-library/user-event': 14.6.1(@testing-library/dom@10.4.1)

      '@vitest/browser': 4.1.10(vite@8.1.4(@types/node@24.13.1)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.49.0)(tsx@4.20.6)(yaml@2.9.0))(vitest@4.1.10)

      '@vitest/browser': 4.1.10(@voidzero-dev/vite-plus-core@0.2.4(@types/node@24.13.1)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.49.0)(tsx@4.20.6)(typescript@6.0.3)(yaml@2.9.0))(vitest@4.1.10)

      vitest: 4.1.10(@opentelemetry/api@1.9.0)(@types/node@24.13.1)(@vitest/browser-preview@4.1.10)(@voidzero-dev/vite-plus-core@0.2.4(@types/node@24.13.1)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.49.0)(tsx@4.20.6)(typescript@6.0.3)(yaml@2.9.0))(happy-dom@20.10.6)

    transitivePeerDependencies:

      - bufferutil

      - msw

      - utf-8-validate

      - vite

    optional: true

  '@vitest/browser-preview@4.1.10(vite@8.1.4(@types/node@24.13.1)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.49.0)(tsx@4.20.6)(yaml@2.9.0))(vitest@4.1.10)':

    dependencies:

      - msw

      - utf-8-validate

      - vite

    optional: true

  '@vitest/browser@4.1.10(@voidzero-dev/vite-plus-core@0.2.4(@types/node@24.13.1)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.49.0)(tsx@4.20.6)(typescript@6.0.3)(yaml@2.9.0))(vitest@4.1.10)':

    dependencies:

      '@blazediff/core': 1.9.1

      '@vitest/mocker': 4.1.10(@voidzero-dev/vite-plus-core@0.2.4(@types/node@24.13.1)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.49.0)(tsx@4.20.6)(typescript@6.0.3)(yaml@2.9.0))

      '@vitest/utils': 4.1.10

      magic-string: 0.30.21

      pngjs: 7.0.0

      sirv: 3.0.2

      tinyrainbow: 3.1.0

      vitest: 4.1.10(@opentelemetry/api@1.9.0)(@types/node@24.13.1)(@vitest/browser-preview@4.1.10)(@voidzero-dev/vite-plus-core@0.2.4(@types/node@24.13.1)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.49.0)(tsx@4.20.6)(typescript@6.0.3)(yaml@2.9.0))(happy-dom@20.10.6)

      ws: 8.21.1

    transitivePeerDependencies:

      - bufferutil

      - msw

      - utf-8-validate

      - vite

  '@vitest/browser@4.1.10(vite@8.1.4(@types/node@24.13.1)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.49.0)(tsx@4.20.6)(yaml@2.9.0))(vitest@4.1.10)':

    dependencies:

      - msw

      - utf-8-validate

      - vite

    optional: true

  '@vitest/expect@4.1.10':

    dependencies:

    dependencies:

      '@oxc-project/types': 0.138.0

      '@oxlint/plugins': 1.68.0

      '@vitest/browser': 4.1.10(vite@8.1.4(@types/node@24.13.1)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.49.0)(tsx@4.20.6)(yaml@2.9.0))(vitest@4.1.10)

      '@vitest/browser-preview': 4.1.10(vite@8.1.4(@types/node@24.13.1)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.49.0)(tsx@4.20.6)(yaml@2.9.0))(vitest@4.1.10)

      '@vitest/browser': 4.1.10(@voidzero-dev/vite-plus-core@0.2.4(@types/node@24.13.1)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.49.0)(tsx@4.20.6)(typescript@6.0.3)(yaml@2.9.0))(vitest@4.1.10)

      '@vitest/browser-preview': 4.1.10(@voidzero-dev/vite-plus-core@0.2.4(@types/node@24.13.1)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.49.0)(tsx@4.20.6)(typescript@6.0.3)(yaml@2.9.0))(vitest@4.1.10)

      '@vitest/expect': 4.1.10

      '@vitest/mocker': 4.1.10(@voidzero-dev/vite-plus-core@0.2.4(@types/node@24.13.1)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.49.0)(tsx@4.20.6)(typescript@6.0.3)(yaml@2.9.0))

      '@vitest/pretty-format': 4.1.10