"note": "Heuristic false-green LEADS, not findings. A finding requires a demonstrated reproduction (surviving mutation via mutation-runner). Do not treat a candidate as a confirmed false green. Coverage-theater leads may include tests that delegate their assertion to a custom helper the classifier does not recognise; verify before acting.",

  "sourceDigest": "sha256:dd810dd48c5bdbc9becd7fcc01dd41a4ca2abf0b2d6f6a545907247f6e3e8361",

  "summary": {

    "filesScanned": 2464,

    "filesScanned": 2465,

    "candidateCount": 16,

    "byMode": {

      "false_green_coverage_theater": 15,

{

  "schemaVersion": "1",

  "repository": "OpenAgentsInc/openagents",

  "sourceDigest": "sha256:432d55f76eea481e2c0451fb1f2511fa7e93ec7ac0f709ccb0aaed7ed1fa912c",

  "sourceDigest": "sha256:d54f284f2e5b93477ae762b1e4ca044f5be9959a7496e1e3fb4933e29b74c68b",

  "surfaces": [

    {

      "id": "app:@openagentsinc/acceptance-runner",

      "oracles": [

        {

          "type": "test",

          "ref": "packages/agent-experience-memory (9 tracked test files)"

          "ref": "packages/agent-experience-memory (10 tracked test files)"

        }

      ],

      "obligation": {

export * from "./engram.js";

export * from "./consolidation.js";

export * from "./subagent-memory.js";

export * from "./projection.js";

import { describe, expect, test } from "vite-plus/test";

import {

  buildEngramBody,

  buildEngramEvent,

  engramContentDigest,

  signSupersedingEngram,

  type EngramEvent,

} from "./engram.js";

import { project, projectedValue, projectionMatches } from "./projection.js";

const PUBKEY = "a".repeat(64);

const sign = (eventId: string): string => `sig-${eventId.slice(0, 16)}`;

const engram = (

  slug: string,

  value: string | null,

  createdAt: number,

  entityId = "entity-1",

  derivedFromSlugs: ReadonlyArray<string> = [],

): EngramEvent => {

  const body = buildEngramBody(slug, value, {

    admission: "admitted",

    entityId,

    contentDigest: engramContentDigest(value),

    sourceEventRefs: [],

    relations: [],

    derivedFromSlugs: [...derivedFromSlugs],

  });

  return buildEngramEvent(PUBKEY, createdAt, slug, JSON.stringify(body), sign);

};

describe("projecting an engram log", () => {

  test("derives the live value per slug", () => {

    const projection = project([

      engram("note/one", "first", 1_000),

      engram("note/two", "second", 1_001),

    ]);

    expect(projectedValue(projection, "note/one")).toBe("first");

    expect(projectedValue(projection, "note/two")).toBe("second");

    expect(projection.entries).toHaveLength(2);

  });

  test("resolves a supersession chain to its newest value", () => {

    const first = engram("note/one", "first", 1_000);

    const second = signSupersedingEngram(first, "corrected", 1_001, PUBKEY, sign);

    const third = signSupersedingEngram(second, "corrected twice", 1_002, PUBKEY, sign);

    const projection = project([first, second, third]);

    expect(projectedValue(projection, "note/one")).toBe("corrected twice");

    expect(projection.entries[0]?.revisions).toBe(3);

    expect(projection.entries[0]?.head).toBe(third.id);

  });

  test("names a tombstoned slug rather than dropping it silently", () => {

    const first = engram("note/one", "first", 1_000);

    const tombstone = signSupersedingEngram(first, null, 1_001, PUBKEY, sign);

    const projection = project([first, tombstone]);

    expect(projection.tombstoned).toEqual(["note/one"]);

    expect(projectedValue(projection, "note/one")).toBeUndefined();

  });

  test("is order-independent: shuffled arrival projects identically", () => {

    const first = engram("note/one", "first", 1_000);

    const second = signSupersedingEngram(first, "corrected", 1_001, PUBKEY, sign);

    const other = engram("note/two", "second", 1_002);

    const forwards = project([first, second, other]);

    const backwards = project([other, second, first]);

    expect(backwards.digest).toBe(forwards.digest);

  });

  test("is idempotent: a cold rebuild equals the warm one", () => {

    const events = [

      engram("note/one", "first", 1_000),

      engram("note/two", "second", 1_001, "entity-2"),

    ];

    expect(project(events).digest).toBe(project(events).digest);

    expect(projectionMatches(project(events), events)).toBe(true);

  });

  test("refuses a tampered event and counts it", () => {

    const authentic = engram("note/one", "authentic", 1_000);

    const tampered: EngramEvent = {

      ...authentic,

      content: authentic.content.replace("authentic", "forged"),

    };

    const projection = project([tampered]);

    expect(projection.entries).toHaveLength(0);

    expect(projection.rejected.unverified).toBe(1);

  });

  test("drops a forked chain whole rather than applying half a correction", () => {

    const first = engram("note/one", "first", 1_000);

    const branchA = signSupersedingEngram(first, "branch a", 1_001, PUBKEY, sign);

    const branchB = signSupersedingEngram(first, "branch b", 1_002, PUBKEY, sign);

    const projection = project([first, branchA, branchB]);

    expect(projectedValue(projection, "note/one")).toBeUndefined();

    expect(projection.rejected.unresolvedChain).toBe(3);

  });

  test("drops a chain whose prior link is missing", () => {

    const first = engram("note/one", "first", 1_000);

    const second = signSupersedingEngram(first, "corrected", 1_001, PUBKEY, sign);

    // The root never arrived.

    const projection = project([second]);

    expect(projectedValue(projection, "note/one")).toBeUndefined();

    expect(projection.rejected.unresolvedChain).toBe(1);

  });

  test("gathers slugs under the entity that names them, and derivation edges", () => {

    const projection = project([

      engram("fact/a", "a", 1_000, "entity-1"),

      engram("fact/b", "b", 1_001, "entity-1"),

      engram("heuristic/x", "distilled", 1_002, "entity-2", ["fact/a", "fact/b"]),

    ]);

    const entity = projection.entities.find((candidate) => candidate.entityId === "entity-1");

    expect(entity?.slugs).toEqual(["fact/a", "fact/b"]);

    expect(projection.relations).toEqual([

      { from: "heuristic/x", to: "fact/a", type: "derived_from" },

      { from: "heuristic/x", to: "fact/b", type: "derived_from" },

    ]);

  });

  test("notices when the log has moved past the projection", () => {

    const events = [engram("note/one", "first", 1_000)];

    const projection = project(events);

    const grown = [...events, engram("note/two", "second", 1_001)];

    expect(projectionMatches(projection, grown)).toBe(false);

  });

});

import { Schema as S } from "effect";

import { canonicalStringify } from "./internal/canonical.js";

import { sha256Hex } from "./internal/sha256.js";

import { computeEngramEventId, EngramBody, type EngramEvent } from "./engram.js";

/**

 * The derived projection over an engram log (issue #223).

 *

 * The engram stream is the authority; this is a view of it. Nothing here is

 * stored anywhere that survives a process, and nothing here can be repaired in

 * place — a projection that disagrees with the log is discarded and rebuilt.

 * That is the whole design: an append-only signed log is the thing you can

 * trust, and a queryable index over it is a convenience that must never become

 * a second source of truth.

 *

 * Three properties the tests hold this to:

 *

 * 1. **Derived only.** `project` is a pure function of the events it is given.

 *    No clock, no randomness, no ambient state.

 * 2. **Idempotent.** Projecting the same log twice produces an identical

 *    value, digest included, so a cold-start rebuild is indistinguishable from

 *    a warm one.

 * 3. **Order-independent.** Events arriving in any order — a relay replaying

 *    out of sequence, two clients merging — project to the same value, because

 *    order is taken from `created_at` and the supersession chain rather than

 *    from arrival.

 *

 * An event that fails verification is not projected. A chain whose

 * supersession does not resolve is dropped whole rather than partly applied:

 * half a correction is worse than none, because it reads as fact.

 */

export const PROJECTION_SCHEMA_ID = "openagents.engram_projection.v1" as const;

/** One live slug: the surviving value and where it came from. */

export const ProjectedEntry = S.Struct({

  slug: S.String,

  value: S.String,

  entityId: S.String,

  /** How many events stand behind this value, corrections included. */

  revisions: S.Number,

  /** The event id of the newest engram in the chain. */

  head: S.String.check(S.isPattern(/^[0-9a-f]{64}$/)),

  /** Seconds since the epoch, from the surviving engram. */

  updatedAt: S.Number,

  derivedFromSlugs: S.Array(S.String),

});

export type ProjectedEntry = typeof ProjectedEntry.Type;

/** One entity gathered from the slugs that name it. */

export const ProjectedEntity = S.Struct({

  entityId: S.String,

  slugs: S.Array(S.String),

});

export type ProjectedEntity = typeof ProjectedEntity.Type;

/** One derivation edge: a slug and something it was distilled from. */

export const ProjectedRelation = S.Struct({

  from: S.String,

  to: S.String,

  type: S.String,

});

export type ProjectedRelation = typeof ProjectedRelation.Type;

export const Projection = S.Struct({

  schema: S.Literal(PROJECTION_SCHEMA_ID),

  entries: S.Array(ProjectedEntry),

  entities: S.Array(ProjectedEntity),

  relations: S.Array(ProjectedRelation),

  /** Slugs whose surviving engram is a tombstone. Named, not silently gone. */

  tombstoned: S.Array(S.String),

  /** Events the projection refused, by reason, so a gap is countable. */

  rejected: S.Struct({

    unverified: S.Number,

    unresolvedChain: S.Number,

    malformed: S.Number,

  }),

  /** The digest of everything above: two equal logs give one digest. */

  digest: S.String.check(S.isPattern(/^sha256:[0-9a-f]{64}$/)),

});

export type Projection = typeof Projection.Type;

const dTagOf = (event: EngramEvent): string | undefined =>

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

const bodyOf = (event: EngramEvent): EngramBody | undefined => {

  try {

    return JSON.parse(event.content) as EngramBody;

  } catch {

    return undefined;

  }

};

/**

 * Order one slug's events into a chain, oldest first.

 *

 * The `supersedes` links are the authority — `created_at` only breaks ties

 * among roots, because a clock is a claim and a reference is a fact. A chain

 * that does not resolve into a single line (a fork, a cycle, a missing link)

 * is refused whole.

 */

const resolveChain = (

  events: ReadonlyArray<EngramEvent>,

): ReadonlyArray<EngramEvent> | undefined => {

  if (events.length === 0) return undefined;

  const byId = new Map(events.map((event) => [event.id, event]));

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

  const roots: Array<EngramEvent> = [];

  for (const event of events) {

    const body = bodyOf(event);

    if (body === undefined) return undefined;

    const prior = body.openagents.supersedes;

    if (prior === undefined) {

      roots.push(event);

      continue;

    }

    if (!byId.has(prior)) return undefined;

    // Two events superseding the same prior is a fork, not a chain.

    if (supersededBy.has(prior)) return undefined;

    supersededBy.set(prior, event);

  }

  if (roots.length !== 1) return undefined;

  const chain: Array<EngramEvent> = [];

  const seen = new Set<string>();

  let current: EngramEvent | undefined = roots[0];

  while (current !== undefined) {

    if (seen.has(current.id)) return undefined;

    seen.add(current.id);

    chain.push(current);

    current = supersededBy.get(current.id);

  }

  // Every event must be on the one line; a stray is an unresolved chain.

  return chain.length === events.length ? chain : undefined;

};

/**

 * Build the projection for a log.

 *

 * Pass every engram known for the scope. Order does not matter.

 */

export const project = (events: ReadonlyArray<EngramEvent>): Projection => {

  let unverified = 0;

  let malformed = 0;

  let unresolvedChain = 0;

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

  for (const event of events) {

    if (event.id !== computeEngramEventId(event)) {

      unverified += 1;

      continue;

    }

    const slug = dTagOf(event);

    if (slug === undefined || bodyOf(event) === undefined) {

      malformed += 1;

      continue;

    }

    const chain = bySlug.get(slug) ?? [];

    chain.push(event);

    bySlug.set(slug, chain);

  }

  const entries: Array<ProjectedEntry> = [];

  const tombstoned: Array<string> = [];

  const relations: Array<ProjectedRelation> = [];

  const entityToSlugs = new Map<string, Set<string>>();

  for (const [slug, slugEvents] of bySlug) {

    const ordered = [...slugEvents].sort((left, right) =>

      left.created_at !== right.created_at

        ? left.created_at - right.created_at

        : left.id.localeCompare(right.id),

    );

    const chain = resolveChain(ordered);

    if (chain === undefined) {

      unresolvedChain += slugEvents.length;

      continue;

    }

    const head = chain[chain.length - 1];

    if (head === undefined) continue;

    const body = bodyOf(head);

    if (body === undefined) {

      malformed += 1;

      continue;

    }

    if (body.value === null) {

      tombstoned.push(slug);

      continue;

    }

    entries.push({

      slug,

      value: body.value,

      entityId: body.openagents.entityId,

      revisions: chain.length,

      head: head.id,

      updatedAt: head.created_at,

      derivedFromSlugs: [...body.openagents.derivedFromSlugs].sort(),

    });

    const slugs = entityToSlugs.get(body.openagents.entityId) ?? new Set<string>();

    slugs.add(slug);

    entityToSlugs.set(body.openagents.entityId, slugs);

    for (const source of body.openagents.derivedFromSlugs) {

      relations.push({ from: slug, to: source, type: "derived_from" });

    }

    for (const relation of body.openagents.relations) {

      relations.push({ from: slug, to: relation.targetSlug, type: relation.type });

    }

  }

  entries.sort((left, right) => left.slug.localeCompare(right.slug));

  tombstoned.sort();

  relations.sort(

    (left, right) =>

      left.from.localeCompare(right.from) ||

      left.to.localeCompare(right.to) ||

      left.type.localeCompare(right.type),

  );

  const entities = [...entityToSlugs.entries()]

    .map(([entityId, slugs]) => ({ entityId, slugs: [...slugs].sort() }))

    .sort((left, right) => left.entityId.localeCompare(right.entityId));

  const withoutDigest = {

    schema: PROJECTION_SCHEMA_ID,

    entries,

    entities,

    relations,

    tombstoned,

    rejected: { unverified, unresolvedChain, malformed },

  } as const;

  return {

    ...withoutDigest,

    digest: `sha256:${sha256Hex(canonicalStringify(withoutDigest))}`,

  };

};

/**

 * Whether a projection still describes a log.

 *

 * The check is a rebuild: re-project and compare digests. There is no cheaper

 * honest answer, because a projection carries no authority of its own — if it

 * disagrees with the log, the log is right and the projection is discarded.

 */

export const projectionMatches = (

  projection: Projection,

  events: ReadonlyArray<EngramEvent>,

): boolean => project(events).digest === projection.digest;

/** The live value for one slug, or undefined when absent or tombstoned. */

export const projectedValue = (projection: Projection, slug: string): string | undefined =>

  projection.entries.find((entry) => entry.slug === slug)?.value;

      ["./internal/sha256.js", "./sha256.js"],

    ],

  ],

  [

    "agent-experience-memory/src/projection.ts",

    "projection.ts",

    [

      ["./internal/canonical.js", "./canonical.js"],

      ["./internal/sha256.js", "./sha256.js"],

    ],

  ],

  [

    "agent-experience-memory/src/consolidation.ts",

    "consolidation.ts",

export * from "./engram.js";

export * from "./consolidation.js";

export * from "./subagent-memory.js";

export * from "./projection.js";

`;

export const writeAll = () => {

  ledgerEntriesAsHeuristics,

  promoteHeuristicToPattern,

  signSupersedingEngram,

  project,

  projectedValue,

  projectionMatches,

  verifyEngramEventId,

  verifySupersessionChain,

  COMPANION_SCHEMA_ID,

  HarvestedLedgerEntry,

  type EngramEvent,

  type EngramBody,

  type ParentHeuristic,

  type Projection,

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

import { Schema as S } from "effect";

  private readonly now: () => number;

  private readonly dreamThreshold: number;

  private key: Buffer | undefined;

  private cachedProjection: Projection | undefined;

  constructor(options: CoderMemoryOptions = {}) {

    this.directory = options.directory ?? join(homedir(), ".openagents", "memory");

      sign,

    );

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

    this.cachedProjection = undefined;

    return event;

  }

    return event;

  }

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

  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;

      try {

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

      } catch {

        continue;

      }

    }

    return events;

  }

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

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

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

  }

  private living(): ReadonlyArray<{ body: EngramBody; createdAtMs: number }> {

    const out: Array<{ body: EngramBody; createdAtMs: number }> = [];

    for (const chain of this.chains().values()) {

      if (!verifySupersessionChain(chain)) continue;

      const last = chain[chain.length - 1];

      if (last === undefined) continue;

      let body: EngramBody;

      try {

        body = JSON.parse(last.content) as EngramBody;

      } catch {

        continue;

      }

      if (body.value === null) continue;

      out.push({ body, createdAtMs: last.created_at * 1000 });

    const projection = this.projection();

    return projection.entries.map((entry) => ({

      body: {

        slug: entry.slug,

        value: entry.value,

        openagents: {

          schema: COMPANION_SCHEMA_ID,

          admission: "admitted",

          entityId: entry.entityId,

          contentDigest: engramContentDigest(entry.value),

          sourceEventRefs: [],

          relations: [],

          derivedFromSlugs: [...entry.derivedFromSlugs],

        },

      },

      createdAtMs: entry.updatedAt * 1000,

    }));

  }

  /**

   * The queryable view over the ledger (issue #223).

   *

   * Derived, never stored: the projection resolves each slug's supersession

   * chain, names tombstones rather than dropping them, refuses a forked or

   * broken chain whole, and counts what it refused. It is cached against the

   * log it was built from and rebuilt the moment they disagree, so a cold

   * start and a warm one are the same value.

   */

  projection(): Projection {

    const events = this.events();

    if (this.cachedProjection !== undefined && projectionMatches(this.cachedProjection, events)) {

      return this.cachedProjection;

    }

    return out;

    this.cachedProjection = project(events);

    return this.cachedProjection;

  }

  /** The live value for one slug, or undefined when absent or tombstoned. */

  recall(slug: string): string | undefined {

    return projectedValue(this.projection(), slug);

  }

  /**

export * from "./engram.js";

export * from "./consolidation.js";

export * from "./subagent-memory.js";

export * from "./projection.js";

// Vendored from packages/agent-experience-memory/src/projection.ts by scripts/vendor-memory.mjs — do not edit here.

// The drift guard (test/vendored-memory-drift.test.ts) fails when this copy

// no longer matches the canonical source.

import { Schema as S } from "effect";

import { canonicalStringify } from "./canonical.js";

import { sha256Hex } from "./sha256.js";

import { computeEngramEventId, EngramBody, type EngramEvent } from "./engram.js";

/**

 * The derived projection over an engram log (issue #223).

 *

 * The engram stream is the authority; this is a view of it. Nothing here is

 * stored anywhere that survives a process, and nothing here can be repaired in

 * place — a projection that disagrees with the log is discarded and rebuilt.

 * That is the whole design: an append-only signed log is the thing you can

 * trust, and a queryable index over it is a convenience that must never become

 * a second source of truth.

 *

 * Three properties the tests hold this to:

 *

 * 1. **Derived only.** `project` is a pure function of the events it is given.

 *    No clock, no randomness, no ambient state.

 * 2. **Idempotent.** Projecting the same log twice produces an identical

 *    value, digest included, so a cold-start rebuild is indistinguishable from

 *    a warm one.

 * 3. **Order-independent.** Events arriving in any order — a relay replaying

 *    out of sequence, two clients merging — project to the same value, because

 *    order is taken from `created_at` and the supersession chain rather than

 *    from arrival.

 *

 * An event that fails verification is not projected. A chain whose

 * supersession does not resolve is dropped whole rather than partly applied:

 * half a correction is worse than none, because it reads as fact.

 */

export const PROJECTION_SCHEMA_ID = "openagents.engram_projection.v1" as const;

/** One live slug: the surviving value and where it came from. */

export const ProjectedEntry = S.Struct({

  slug: S.String,

  value: S.String,

  entityId: S.String,

  /** How many events stand behind this value, corrections included. */

  revisions: S.Number,

  /** The event id of the newest engram in the chain. */

  head: S.String.check(S.isPattern(/^[0-9a-f]{64}$/)),

  /** Seconds since the epoch, from the surviving engram. */

  updatedAt: S.Number,

  derivedFromSlugs: S.Array(S.String),

});

export type ProjectedEntry = typeof ProjectedEntry.Type;

/** One entity gathered from the slugs that name it. */

export const ProjectedEntity = S.Struct({

  entityId: S.String,

  slugs: S.Array(S.String),

});

export type ProjectedEntity = typeof ProjectedEntity.Type;

/** One derivation edge: a slug and something it was distilled from. */

export const ProjectedRelation = S.Struct({

  from: S.String,

  to: S.String,

  type: S.String,

});

export type ProjectedRelation = typeof ProjectedRelation.Type;

export const Projection = S.Struct({

  schema: S.Literal(PROJECTION_SCHEMA_ID),

  entries: S.Array(ProjectedEntry),

  entities: S.Array(ProjectedEntity),

  relations: S.Array(ProjectedRelation),

  /** Slugs whose surviving engram is a tombstone. Named, not silently gone. */

  tombstoned: S.Array(S.String),

  /** Events the projection refused, by reason, so a gap is countable. */

  rejected: S.Struct({

    unverified: S.Number,

    unresolvedChain: S.Number,

    malformed: S.Number,

  }),

  /** The digest of everything above: two equal logs give one digest. */

  digest: S.String.check(S.isPattern(/^sha256:[0-9a-f]{64}$/)),

});

export type Projection = typeof Projection.Type;

const dTagOf = (event: EngramEvent): string | undefined =>

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

const bodyOf = (event: EngramEvent): EngramBody | undefined => {

  try {

    return JSON.parse(event.content) as EngramBody;

  } catch {

    return undefined;

  }

};

/**

 * Order one slug's events into a chain, oldest first.

 *

 * The `supersedes` links are the authority — `created_at` only breaks ties

 * among roots, because a clock is a claim and a reference is a fact. A chain

 * that does not resolve into a single line (a fork, a cycle, a missing link)

 * is refused whole.

 */

const resolveChain = (

  events: ReadonlyArray<EngramEvent>,

): ReadonlyArray<EngramEvent> | undefined => {

  if (events.length === 0) return undefined;

  const byId = new Map(events.map((event) => [event.id, event]));

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

  const roots: Array<EngramEvent> = [];

  for (const event of events) {

    const body = bodyOf(event);

    if (body === undefined) return undefined;

    const prior = body.openagents.supersedes;

    if (prior === undefined) {

      roots.push(event);

      continue;

    }

    if (!byId.has(prior)) return undefined;

    // Two events superseding the same prior is a fork, not a chain.

    if (supersededBy.has(prior)) return undefined;

    supersededBy.set(prior, event);

  }

  if (roots.length !== 1) return undefined;

  const chain: Array<EngramEvent> = [];

  const seen = new Set<string>();

  let current: EngramEvent | undefined = roots[0];

  while (current !== undefined) {

    if (seen.has(current.id)) return undefined;

    seen.add(current.id);

    chain.push(current);

    current = supersededBy.get(current.id);

  }

  // Every event must be on the one line; a stray is an unresolved chain.

  return chain.length === events.length ? chain : undefined;

};

/**

 * Build the projection for a log.

 *

 * Pass every engram known for the scope. Order does not matter.

 */

export const project = (events: ReadonlyArray<EngramEvent>): Projection => {

  let unverified = 0;

  let malformed = 0;

  let unresolvedChain = 0;

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

  for (const event of events) {

    if (event.id !== computeEngramEventId(event)) {

      unverified += 1;

      continue;

    }

    const slug = dTagOf(event);

    if (slug === undefined || bodyOf(event) === undefined) {

      malformed += 1;

      continue;

    }

    const chain = bySlug.get(slug) ?? [];

    chain.push(event);

    bySlug.set(slug, chain);

  }

  const entries: Array<ProjectedEntry> = [];

  const tombstoned: Array<string> = [];

  const relations: Array<ProjectedRelation> = [];

  const entityToSlugs = new Map<string, Set<string>>();

  for (const [slug, slugEvents] of bySlug) {

    const ordered = [...slugEvents].sort((left, right) =>

      left.created_at !== right.created_at

        ? left.created_at - right.created_at

        : left.id.localeCompare(right.id),

    );

    const chain = resolveChain(ordered);

    if (chain === undefined) {

      unresolvedChain += slugEvents.length;

      continue;

    }

    const head = chain[chain.length - 1];

    if (head === undefined) continue;

    const body = bodyOf(head);

    if (body === undefined) {

      malformed += 1;

      continue;

    }

    if (body.value === null) {

      tombstoned.push(slug);

      continue;

    }

    entries.push({

      slug,

      value: body.value,

      entityId: body.openagents.entityId,

      revisions: chain.length,

      head: head.id,

      updatedAt: head.created_at,

      derivedFromSlugs: [...body.openagents.derivedFromSlugs].sort(),

    });

    const slugs = entityToSlugs.get(body.openagents.entityId) ?? new Set<string>();

    slugs.add(slug);

    entityToSlugs.set(body.openagents.entityId, slugs);

    for (const source of body.openagents.derivedFromSlugs) {

      relations.push({ from: slug, to: source, type: "derived_from" });

    }

    for (const relation of body.openagents.relations) {

      relations.push({ from: slug, to: relation.targetSlug, type: relation.type });

    }

  }

  entries.sort((left, right) => left.slug.localeCompare(right.slug));

  tombstoned.sort();

  relations.sort(

    (left, right) =>

      left.from.localeCompare(right.from) ||

      left.to.localeCompare(right.to) ||

      left.type.localeCompare(right.type),

  );

  const entities = [...entityToSlugs.entries()]

    .map(([entityId, slugs]) => ({ entityId, slugs: [...slugs].sort() }))

    .sort((left, right) => left.entityId.localeCompare(right.entityId));

  const withoutDigest = {

    schema: PROJECTION_SCHEMA_ID,

    entries,

    entities,

    relations,

    tombstoned,

    rejected: { unverified, unresolvedChain, malformed },

  } as const;

  return {

    ...withoutDigest,

    digest: `sha256:${sha256Hex(canonicalStringify(withoutDigest))}`,

  };

};

/**

 * Whether a projection still describes a log.

 *

 * The check is a rebuild: re-project and compare digests. There is no cheaper

 * honest answer, because a projection carries no authority of its own — if it

 * disagrees with the log, the log is right and the projection is discarded.

 */

export const projectionMatches = (

  projection: Projection,

  events: ReadonlyArray<EngramEvent>,

): boolean => project(events).digest === projection.digest;

/** The live value for one slug, or undefined when absent or tombstoned. */

export const projectedValue = (projection: Projection, slug: string): string | undefined =>

  projection.entries.find((entry) => entry.slug === slug)?.value;