talon-agent 4.6.0 → 5.0.0

package/src/core/soul/embedder.ts

@@ -1,129 +0,0 @@
-/**
- * Soul Kernel — the embedder boundary and the vector math.
- *
- * The embedder is the ONLY neural component the kernel may touch, and it is a
- * frozen fixed function, not a reasoning agent — so it stays inside the
- * model-free principle. It is injected: production wires MemPalace's local
- * embedding model; tests and offline operation use the deterministic
- * `HashingEmbedder` below.
- *
- * Everything the kernel does *with* embeddings — clustering evidence into values,
- * picking a medoid label, measuring contradiction/drift — is plain vector
- * arithmetic implemented here. No model decides what relates to what; geometry
- * does.
- */
-
-import { createHash } from "node:crypto";
-
-/** A pluggable text→vector function. Vectors should be L2-normalized. */
-export interface Embedder {
-  readonly dim: number;
-  embed(texts: readonly string[]): Promise<number[][]>;
-}
-
-// ── Vector math ──────────────────────────────────────────────────────────────
-
-function dot(a: readonly number[], b: readonly number[]): number {
-  let s = 0;
-  for (let i = 0; i < a.length; i++) s += a[i]! * b[i]!;
-  return s;
-}
-
-function norm(a: readonly number[]): number {
-  return Math.sqrt(dot(a, a));
-}
-
-/** L2-normalize a vector; a zero vector is returned unchanged. */
-export function normalize(a: readonly number[]): number[] {
-  const n = norm(a);
-  if (n === 0) return [...a];
-  return a.map((x) => x / n);
-}
-
-/** Cosine similarity in [-1, 1] (assumes finite inputs). */
-export function cosineSimilarity(
-  a: readonly number[],
-  b: readonly number[],
-): number {
-  const na = norm(a);
-  const nb = norm(b);
-  if (na === 0 || nb === 0) return 0;
-  return dot(a, b) / (na * nb);
-}
-
-/** Cosine distance in [0, 2]. 0 = identical direction. */
-export function cosineDistance(
-  a: readonly number[],
-  b: readonly number[],
-): number {
-  return 1 - cosineSimilarity(a, b);
-}
-
-/** Mean vector of a set, L2-normalized. The cluster centroid. */
-export function centroid(vectors: readonly (readonly number[])[]): number[] {
-  if (vectors.length === 0) return [];
-  const dim = vectors[0]!.length;
-  const acc = Array.from({ length: dim }, () => 0);
-  for (const v of vectors) {
-    for (let i = 0; i < dim; i++) acc[i]! += v[i]!;
-  }
-  for (let i = 0; i < dim; i++) acc[i]! /= vectors.length;
-  return normalize(acc);
-}
-
-/**
- * Index of the medoid: the member with minimum total cosine distance to all
- * others — the single most central *real* item. This is what labels a value:
- * never generated prose, always a genuine fragment.
- */
-export function medoidIndex(vectors: readonly (readonly number[])[]): number {
-  if (vectors.length === 0) return -1;
-  let best = 0;
-  let bestSum = Infinity;
-  for (let i = 0; i < vectors.length; i++) {
-    let sum = 0;
-    for (let j = 0; j < vectors.length; j++) {
-      if (i !== j) sum += cosineDistance(vectors[i]!, vectors[j]!);
-    }
-    if (sum < bestSum) {
-      bestSum = sum;
-      best = i;
-    }
-  }
-  return best;
-}
-
-// ── Deterministic offline embedder ───────────────────────────────────────────
-
-/**
- * A frozen, dependency-free embedder via feature hashing over character n-grams
- * and word tokens. Deterministic and model-free: similar strings share n-grams
- * and therefore land near each other in cosine space. Crude next to a real
- * sentence encoder, but it is a genuine fixed function — suitable for tests,
- * offline operation, and as a fallback when the local model is unavailable.
- */
-export class HashingEmbedder implements Embedder {
-  constructor(readonly dim = 256) {}
-
-  async embed(texts: readonly string[]): Promise<number[][]> {
-    return texts.map((t) => this.embedOne(t));
-  }
-
-  private embedOne(text: string): number[] {
-    const vec = Array.from({ length: this.dim }, () => 0);
-    const lower = text.toLowerCase();
-    const add = (feature: string): void => {
-      const h = createHash("md5").update(feature).digest();
-      const idx = ((h[0]! << 8) | h[1]!) % this.dim;
-      const sign = (h[2]! & 1) === 0 ? 1 : -1; // sign hashing reduces bias
-      vec[idx]! += sign;
-    };
-    // word tokens
-    for (const w of lower.split(/[^a-z0-9]+/).filter(Boolean)) add(`w:${w}`);
-    // character 3-grams over the normalized stream
-    const stream = lower.replace(/\s+/g, " ");
-    for (let i = 0; i + 3 <= stream.length; i++)
-      add(`g:${stream.slice(i, i + 3)}`);
-    return normalize(vec);
-  }
-}

package/src/core/soul/emergent-critic.ts

@@ -1,96 +0,0 @@
-/**
- * Soul Kernel — the emergent critic.
- *
- * The lexical Critic (critic.ts) hardcodes three failure modes and their word
- * lists. That is a useful bootstrap, but it is exactly the kind of "overly
- * programmed and specific" thing the soul should grow past. The emergent critic
- * derives failure modes from data: corrections carry negative valence, and
- * clusters of corrections ARE the failure modes — discovered, not declared.
- *
- * To assess a candidate reply, embed it and measure its proximity to those
- * correction clusters. If it lands near a cluster of past corrections, it is at
- * risk of repeating that mistake — and the warning is a real past correction
- * (the cluster's medoid), not an invented category. As Dylan corrects Talon, new
- * failure modes appear on their own; nothing here is hand-authored.
- */
-
-import { clusterEvidence } from "./cluster.js";
-import type { SoulDag } from "./dag.js";
-import { cosineDistance, type Embedder } from "./embedder.js";
-import type { EvidencePayload, Hash } from "./types.js";
-
-export interface EmergentFailureMode {
-  /** A real past correction representing the cluster — never generated. */
-  readonly label: string;
-  readonly medoid: Hash;
-  readonly centroid: readonly number[];
-  /** Number of corrections in this mode. */
-  readonly size: number;
-}
-
-export interface FailureRisk {
-  readonly label: string;
-  readonly distance: number;
-  readonly atRisk: boolean;
-}
-
-function correctionEvidence(dag: SoulDag): { hash: Hash; text: string }[] {
-  const out: { hash: Hash; text: string }[] = [];
-  for (const node of dag.nodesOfKind("evidence")) {
-    const p = node.payload as EvidencePayload;
-    if (p.source.origin === "correction")
-      out.push({ hash: node.hash, text: p.text });
-  }
-  return out;
-}
-
-/**
- * Derive failure modes by clustering Talon's actual corrections. `threshold` is
- * the cluster tightness; each resulting cluster is one emergent failure mode,
- * labeled by its medoid (a representative real correction).
- */
-export async function deriveFailureModes(
-  dag: SoulDag,
-  embedder: Embedder,
-  threshold: number,
-): Promise<EmergentFailureMode[]> {
-  const corrections = correctionEvidence(dag);
-  if (corrections.length === 0) return [];
-
-  const vectors = await embedder.embed(corrections.map((c) => c.text));
-  const embedded = corrections.map((c, i) => ({
-    hash: c.hash,
-    vector: vectors[i]!,
-  }));
-  const clusters = clusterEvidence(embedded, threshold);
-
-  const textByHash = new Map(corrections.map((c) => [c.hash, c.text]));
-  return clusters.map((cl) => ({
-    label: textByHash.get(cl.medoid) ?? "",
-    medoid: cl.medoid,
-    centroid: cl.centroid,
-    size: cl.members.length,
-  }));
-}
-
-/**
- * Assess a candidate reply against the emergent failure modes. Returns the risk
- * per mode (sorted nearest first); `atRisk` when the candidate sits within
- * `riskDistance` of a correction cluster — i.e. it resembles something Talon was
- * already corrected for.
- */
-export async function assessText(
-  text: string,
-  modes: readonly EmergentFailureMode[],
-  embedder: Embedder,
-  riskDistance: number,
-): Promise<FailureRisk[]> {
-  if (modes.length === 0) return [];
-  const [vec] = await embedder.embed([text]);
-  return modes
-    .map((m) => {
-      const distance = cosineDistance(vec!, m.centroid);
-      return { label: m.label, distance, atRisk: distance <= riskDistance };
-    })
-    .sort((a, b) => a.distance - b.distance);
-}

package/src/core/soul/forgetting.ts

@@ -1,131 +0,0 @@
-/**
- * Soul Kernel — adaptive forgetting (FSRS / DSR-inspired).
- *
- * Fixed-half-life exponential decay treats a trait recalled a hundred times the
- * same as one recalled once. Human memory does not work that way, and neither
- * should the soul. This module implements a Difficulty-Stability-Retrievability
- * style model (Wozniak's DSR; the basis of FSRS, the algorithm modern Anki uses),
- * adapted to continuous time:
- *
- *   - Each node carries a STABILITY S (a time constant). Retrievability follows a
- *     POWER LAW, R(t) = (1 + FACTOR·t/S)^DECAY, which fits human forgetting far
- *     better than an exponential (Wickelgren; FSRS). At t = S, R ≈ 0.9.
- *   - Successful recall GROWS stability, and grows it MORE when the recall
- *     happened at low retrievability (the spacing effect) — so a trait that keeps
- *     proving itself across time becomes durable. A correction (negative valence)
- *     SHRINKS stability, so a discredited trait becomes easy to forget.
- *
- * The effective strength used for projection is salience × retrievability. The
- * net effect: core identity persists, fads evaporate — emergently, from the
- * timing and outcome of activations, not a hand-set constant.
- */
-
-import type { ActivationState, NodeKind, SoulConfig } from "./types.js";
-import { halfLifeForKind } from "./types.js";
-
-// FSRS power-law constants: R = (1 + FACTOR·t/S)^DECAY, with R(S) ≈ 0.9.
-const DECAY = -0.5;
-const FACTOR = 19 / 81;
-
-const MIN_STABILITY = 1; // never let a node become un-forgettable-fast to 0
-const GROWTH = 2.0; // spacing-effect stability gain scale
-const LAPSE = 0.5; // stability multiplier on a correction
-
-/** Power-law retrievability in (0, 1]. */
-export function retrievability(elapsedMs: number, stability: number): number {
-  if (elapsedMs <= 0) return 1;
-  const s = Math.max(MIN_STABILITY, stability);
-  return Math.pow(1 + (FACTOR * elapsedMs) / s, DECAY);
-}
-
-/**
- * Initial stability for a node's first exposure, honoring the per-kind
- * half-life when the kind is known. No-decay kinds (infinite half-life) never
- * reach the FSRS path, but fall back to the base rate defensively so an
- * Infinity is never stored into state (it would not survive JSON persistence).
- */
-export function initialStability(cfg: SoulConfig, kind?: NodeKind): number {
-  const hl = halfLifeForKind(cfg, kind);
-  return Number.isFinite(hl) ? hl : cfg.decayHalfLifeMs;
-}
-
-/**
- * Stability after a recall. Positive valence grows it (more when retrievability
- * was low — the spacing effect); negative valence (a correction) shrinks it.
- */
-export function nextStability(
-  stability: number,
-  r: number,
-  valence: number,
-): number {
-  const s = Math.max(MIN_STABILITY, stability);
-  if (valence < 0) return Math.max(MIN_STABILITY, s * LAPSE);
-  // grow more when r is low (recall that "shouldn't" have succeeded teaches most)
-  const gain = 1 + GROWTH * (1 - r) * Math.max(0.25, Math.min(1, valence));
-  return s * gain;
-}
-
-/**
- * Salience after lazy power-law decay to `now`, using the node's stability when
- * present. Falls back to the caller's exponential decay when stability is unset.
- * A no-decay kind (infinite half-life, e.g. reflexes) returns the stored
- * salience untouched regardless of stability.
- */
-export function effectiveStrength(
-  state: ActivationState,
-  now: number,
-  cfg: SoulConfig,
-  kind?: NodeKind,
-): number {
-  const halfLifeMs = halfLifeForKind(cfg, kind);
-  if (!Number.isFinite(halfLifeMs)) return state.salience;
-  if (state.stability === undefined) {
-    // exponential fallback (mirrors salience.effectiveSalience)
-    const f = Math.pow(
-      0.5,
-      Math.max(0, now - state.lastActivatedAt) / halfLifeMs,
-    );
-    return state.salience * f;
-  }
-  return (
-    state.salience *
-    retrievability(now - state.lastActivatedAt, state.stability)
-  );
-}
-
-export interface FsrsReinforceOptions {
-  readonly now: number;
-  readonly cfg: SoulConfig;
-  readonly amount: number;
-  readonly valence: number;
-  /** Node kind, when known — selects the per-kind decay half-life. */
-  readonly kind?: NodeKind;
-}
-
-/**
- * Reinforcement under adaptive forgetting: decays salience by retrievability,
- * adds the increment, accumulates evidence, and updates stability per the
- * spacing/lapse rule. Mutates and returns the state. No-decay kinds (infinite
- * half-life) accumulate undecayed and skip stability bookkeeping entirely —
- * their strength is time-invariant by construction.
- */
-export function reinforceFsrs(
-  state: ActivationState,
-  opts: FsrsReinforceOptions,
-): ActivationState {
-  if (!Number.isFinite(halfLifeForKind(opts.cfg, opts.kind))) {
-    state.salience += opts.amount;
-    state.evidence += opts.valence;
-    state.activations += 1;
-    state.lastActivatedAt = opts.now;
-    return state;
-  }
-  const stability = state.stability ?? initialStability(opts.cfg, opts.kind);
-  const r = retrievability(opts.now - state.lastActivatedAt, stability);
-  state.salience = state.salience * r + opts.amount;
-  state.evidence += opts.valence;
-  state.stability = nextStability(stability, r, opts.valence);
-  state.activations += 1;
-  state.lastActivatedAt = opts.now;
-  return state;
-}

package/src/core/soul/governance.ts

@@ -1,93 +0,0 @@
-/**
- * Soul Kernel — governance (the protected-node approval queue).
- *
- * Most of the soul grows autonomously; that is the point. But some facets are
- * load-bearing enough that drift must never happen silently — the reflexes that
- * the harness enforces, and any change to core identity. The mechanical compiler
- * may *propose* such mutations, but they do not take effect until a human
- * approves them. This is the concrete machinery behind "identity cannot drift
- * behind your back".
- *
- * The queue is pure data (persisted with the kernel). Proposing enqueues a
- * payload + reason; approving returns the payload to the kernel to materialize;
- * rejecting drops it. Nothing here writes to the DAG — the kernel owns that — so
- * the queue stays a simple, auditable ledger.
- */
-
-import { randomUUID } from "node:crypto";
-import { hashPayload } from "./hash.js";
-import type { NodePayload } from "./types.js";
-
-type ProposalStatus = "pending" | "approved" | "rejected";
-
-export interface Proposal {
-  readonly id: string;
-  readonly at: number;
-  /** Content hash of the proposed node — stable identity for dedup. */
-  readonly target: string;
-  readonly payload: NodePayload;
-  /** Why the compiler proposed this (templated, never model-written). */
-  readonly reason: string;
-  status: ProposalStatus;
-  resolvedAt?: number;
-}
-
-export interface ApprovalSnapshot {
-  readonly proposals: readonly Proposal[];
-}
-
-export class ApprovalQueue {
-  private proposals: Proposal[] = [];
-
-  /**
-   * Enqueue a proposed protected mutation. Idempotent on payload content: a
-   * pending proposal for the same node is returned rather than duplicated.
-   */
-  propose(payload: NodePayload, reason: string, at: number): Proposal {
-    const target = hashPayload(payload);
-    const existing = this.proposals.find(
-      (p) => p.target === target && p.status === "pending",
-    );
-    if (existing) return existing;
-    const proposal: Proposal = {
-      id: randomUUID(),
-      at,
-      target,
-      payload,
-      reason,
-      status: "pending",
-    };
-    this.proposals.push(proposal);
-    return proposal;
-  }
-
-  pending(): Proposal[] {
-    return this.proposals.filter((p) => p.status === "pending");
-  }
-
-  get(id: string): Proposal | undefined {
-    return this.proposals.find((p) => p.id === id);
-  }
-
-  /**
-   * Resolve a pending proposal. Returns the payload to apply when approved, or
-   * undefined otherwise (rejected, missing, or already resolved).
-   */
-  resolve(id: string, approved: boolean, at: number): NodePayload | undefined {
-    const p = this.proposals.find((x) => x.id === id && x.status === "pending");
-    if (!p) return undefined;
-    p.status = approved ? "approved" : "rejected";
-    p.resolvedAt = at;
-    return approved ? p.payload : undefined;
-  }
-
-  snapshot(): ApprovalSnapshot {
-    return { proposals: this.proposals.map((p) => ({ ...p })) };
-  }
-
-  static restore(snap: ApprovalSnapshot): ApprovalQueue {
-    const q = new ApprovalQueue();
-    q.proposals = snap.proposals.map((p) => ({ ...p }));
-    return q;
-  }
-}

package/src/core/soul/hash.ts

@@ -1,97 +0,0 @@
-/**
- * Content addressing for the Soul kernel.
- *
- * A node's identity is the sha-256 of its *canonical* serialization. Canonical
- * means: deterministic key ordering, no whitespace, explicit rejection of
- * non-data values. Two nodes with semantically identical content therefore hash
- * identically — which is what makes dedup, provenance, and partial recompilation
- * structural rather than bolted-on.
- *
- * Only CONTENT is ever hashed here. Mutable state (salience, edge weights) is
- * deliberately excluded from node identity (see types.ts).
- */
-
-import { createHash } from "node:crypto";
-import type { Hash, NodePayload } from "./types.js";
-
-/**
- * Canonical JSON: object keys sorted lexicographically, arrays preserved in
- * order, no insignificant whitespace. Rejects `undefined`, functions, symbols,
- * NaN and ±Infinity so a hash can never depend on an unserializable value.
- *
- * This is intentionally stricter than JSON.stringify: we want a single
- * canonical byte string per logical value, and we want loud failure on anything
- * that could silently vary.
- */
-export function canonicalize(value: unknown): string {
-  return encode(value);
-}
-
-function encode(value: unknown): string {
-  if (value === null) return "null";
-
-  const t = typeof value;
-
-  if (t === "string") return JSON.stringify(value);
-
-  if (t === "number") {
-    if (!Number.isFinite(value as number)) {
-      throw new TypeError(`canonicalize: non-finite number ${String(value)}`);
-    }
-    return JSON.stringify(value);
-  }
-
-  if (t === "boolean") return value ? "true" : "false";
-
-  if (t === "bigint") {
-    throw new TypeError("canonicalize: bigint is not serializable");
-  }
-
-  if (Array.isArray(value)) {
-    return `[${value.map(encode).join(",")}]`;
-  }
-
-  if (t === "object") {
-    const obj = value as Record<string, unknown>;
-    const keys = Object.keys(obj).sort();
-    const parts: string[] = [];
-    for (const key of keys) {
-      const v = obj[key];
-      // Drop keys whose value is undefined, mirroring JSON semantics, but only
-      // for objects — undefined inside arrays is rejected below.
-      if (v === undefined) continue;
-      parts.push(`${JSON.stringify(key)}:${encode(v)}`);
-    }
-    return `{${parts.join(",")}}`;
-  }
-
-  // undefined, function, symbol
-  throw new TypeError(`canonicalize: cannot serialize ${t}`);
-}
-
-/** sha-256 of an arbitrary canonicalized value, prefixed "sha256:". */
-export function hashContent(value: unknown): Hash {
-  const canonical = canonicalize(value);
-  const digest = createHash("sha256").update(canonical, "utf8").digest("hex");
-  return `sha256:${digest}` as Hash;
-}
-
-/** The content address of a node payload. This is the node's identity. */
-export function hashPayload(payload: NodePayload): Hash {
-  return hashContent(payload);
-}
-
-/**
- * A Merkle root over a set of child hashes. Order-independent: the children are
- * sorted before hashing, so the root depends only on the *set* of content
- * present, not the order it was inserted. This is the structural version id.
- */
-export function merkleRoot(childHashes: Iterable<Hash>): Hash {
-  const sorted = [...childHashes].sort();
-  return hashContent({ merkle: sorted });
-}
-
-/** True when a string is a well-formed kernel content address. */
-export function isHash(value: unknown): value is Hash {
-  return typeof value === "string" && /^sha256:[0-9a-f]{64}$/.test(value);
-}

package/src/core/soul/hdc.ts

@@ -1,154 +0,0 @@
-/**
- * Soul Kernel — hyperdimensional computing (Vector-Symbolic Architecture).
- *
- * Kanerva, "Hyperdimensional Computing" (2009). High-dimensional bipolar vectors
- * (±1, here a few thousand dims) support a small algebra that is the basis of a
- * compositional, model-free associative memory:
- *
- *   - bind (⊗)   elementwise product. Combines two hypervectors into one
- *                DISSIMILAR to both, and is its own inverse (bind twice by the
- *                same key recovers the other operand). Used to pair a role with a
- *                filler: context ⊗ value.
- *   - bundle (+) elementwise majority. Superposes many hypervectors into one
- *                SIMILAR to all of them — a set, or a memory of many episodes.
- *   - permute (ρ) cyclic shift. Encodes order/role without collision.
- *   - cleanup     nearest stored item under cosine — denoises a recalled vector
- *                back to a known symbol.
- *
- * The soul uses this for episodic recall: bind the current context to the value
- * that worked, bundle those bindings into one memory hypervector, and later query
- * "in a context like this, what do I do?" by unbinding and cleaning up. It is a
- * genuinely compositional memory, and it is pure integer arithmetic — no model.
- */
-
-import { createHash } from "node:crypto";
-
-export type Hypervector = Int8Array;
-
-const DEFAULT_HD_DIM = 4096;
-
-/** Deterministic ±1 hypervector for a symbol — the same token always maps here. */
-export function symbolVector(token: string, dim = DEFAULT_HD_DIM): Hypervector {
-  const v = new Int8Array(dim);
-  // Seed a tiny xorshift PRNG from the token hash; fill with ±1.
-  const digest = createHash("sha256").update(token).digest();
-  let s0 = digest.readUInt32LE(0) || 1;
-  let s1 = digest.readUInt32LE(4) || 2;
-  for (let i = 0; i < dim; i++) {
-    // xorshift128-ish
-    let x = s0;
-    const y = s1;
-    s0 = y;
-    x ^= x << 23;
-    x ^= x >>> 17;
-    x ^= y ^ (y >>> 26);
-    s1 = x >>> 0;
-    v[i] = ((s1 >>> (i % 31)) & 1) === 0 ? 1 : -1;
-  }
-  return v;
-}
-
-/** Elementwise bind (product). Self-inverse for bipolar vectors. */
-export function bind(a: Hypervector, b: Hypervector): Hypervector {
-  const out = new Int8Array(a.length);
-  for (let i = 0; i < a.length; i++) out[i] = (a[i]! * b[i]!) as number;
-  return out;
-}
-
-/** Majority-rule bundle of several hypervectors; empty ⇒ zero vector. */
-export function bundle(vectors: readonly Hypervector[]): Hypervector {
-  const dim = vectors[0]?.length ?? DEFAULT_HD_DIM;
-  const acc = new Int32Array(dim);
-  for (const v of vectors) for (let i = 0; i < dim; i++) acc[i]! += v[i]!;
-  const out = new Int8Array(dim);
-  for (let i = 0; i < dim; i++) out[i] = acc[i]! >= 0 ? 1 : -1; // ties → +1
-  return out;
-}
-
-/** Cyclic shift by k (encodes role/order). */
-export function permute(v: Hypervector, k = 1): Hypervector {
-  const dim = v.length;
-  const out = new Int8Array(dim);
-  const shift = ((k % dim) + dim) % dim;
-  for (let i = 0; i < dim; i++) out[(i + shift) % dim] = v[i]!;
-  return out;
-}
-
-/** Cosine similarity of two bipolar vectors (= normalized dot). */
-export function hdCosine(a: Hypervector, b: Hypervector): number {
-  let dot = 0;
-  for (let i = 0; i < a.length; i++) dot += a[i]! * b[i]!;
-  return dot / a.length;
-}
-
-/** Nearest stored item to a (noisy) query, by cosine. */
-export function cleanup(
-  query: Hypervector,
-  items: ReadonlyMap<string, Hypervector>,
-): { token: string; score: number } | undefined {
-  let best: { token: string; score: number } | undefined;
-  for (const [token, v] of items) {
-    const score = hdCosine(query, v);
-    if (!best || score > best.score) best = { token, score };
-  }
-  return best;
-}
-
-/**
- * A compositional associative memory: a running superposition of role⊗filler
- * bindings. Querying with a role unbinds and returns a noisy filler to be cleaned
- * up against an item memory. Stored as an integer accumulator so many episodes
- * can be bundled without saturating.
- */
-export class CompositionalMemory {
-  private readonly acc: Int32Array;
-  private count = 0;
-
-  constructor(
-    readonly dim = DEFAULT_HD_DIM,
-    acc?: Int32Array,
-    count = 0,
-  ) {
-    this.acc = acc ?? new Int32Array(dim);
-    this.count = count;
-  }
-
-  /** Superpose one role⊗filler binding into the memory. */
-  add(role: Hypervector, filler: Hypervector): void {
-    const bound = bind(role, filler);
-    for (let i = 0; i < this.dim; i++) this.acc[i]! += bound[i]!;
-    this.count += 1;
-  }
-
-  /** The signed memory hypervector. */
-  vector(): Hypervector {
-    const out = new Int8Array(this.dim);
-    for (let i = 0; i < this.dim; i++) out[i] = this.acc[i]! >= 0 ? 1 : -1;
-    return out;
-  }
-
-  /** Unbind a role to recover the (noisy) filler it was paired with. */
-  query(role: Hypervector): Hypervector {
-    return bind(this.vector(), role);
-  }
-
-  get episodes(): number {
-    return this.count;
-  }
-
-  snapshot(): { dim: number; acc: number[]; count: number } {
-    return { dim: this.dim, acc: Array.from(this.acc), count: this.count };
-  }
-
-  static restore(snap: {
-    dim: number;
-    acc: number[];
-    count: number;
-  }): CompositionalMemory {
-    return new CompositionalMemory(
-      snap.dim,
-      Int32Array.from(snap.acc),
-      snap.count,
-    );
-  }
-}