talon-agent 4.6.1 → 5.0.1

package/src/core/soul/delta.ts

@@ -1,123 +0,0 @@
-/**
- * Soul Kernel — the delta stream ("what changed in me, and why").
- *
- * One of the kernel's projection targets is a human-readable account of how the
- * soul changed between two versions. It is computed by diffing two DAG snapshots
- * and TEMPLATED from the structural difference — never model-written — so the
- * change log is as auditable as the identity itself. The kernel uses it to give
- * each commit a meaningful summary and to power a `/soul` introspection view.
- */
-
-import type { DagSnapshot } from "./dag.js";
-import type {
-  Hash,
-  NodePayload,
-  SpinePayload,
-  ThemePayload,
-  ValuePayload,
-} from "./types.js";
-
-export interface SoulDelta {
-  readonly addedValues: string[];
-  readonly addedThemes: string[];
-  readonly addedSpine: string[];
-  readonly addedReflexes: string[];
-  readonly addedLenses: string[];
-  readonly supersededCount: number;
-  readonly newTensions: number;
-}
-
-function payloadMap(snap: DagSnapshot): Map<Hash, NodePayload> {
-  return new Map(snap.nodes.map((n) => [n.hash, n.payload]));
-}
-
-function evidenceText(map: Map<Hash, NodePayload>, hash: Hash): string {
-  const p = map.get(hash);
-  return p?.kind === "evidence" ? p.text : "";
-}
-
-function countEdges(snap: DagSnapshot, kind: string): number {
-  return snap.edges.filter((e) => e.kind === kind).length;
-}
-
-/** Diff two snapshots into a structural delta. Append-only ⇒ only additions. */
-export function diffSnapshots(prev: DagSnapshot, curr: DagSnapshot): SoulDelta {
-  const prevHashes = new Set(prev.nodes.map((n) => n.hash));
-  const map = payloadMap(curr);
-
-  const addedValues: string[] = [];
-  const addedThemes: string[] = [];
-  const addedSpine: string[] = [];
-  const addedReflexes: string[] = [];
-  const addedLenses: string[] = [];
-
-  for (const node of curr.nodes) {
-    if (prevHashes.has(node.hash)) continue;
-    const p = node.payload;
-    switch (p.kind) {
-      case "value":
-        addedValues.push(evidenceText(map, (p as ValuePayload).medoid));
-        break;
-      case "theme":
-        addedThemes.push(
-          (p as ThemePayload).insight ??
-            evidenceText(map, (p as ThemePayload).medoid),
-        );
-        break;
-      case "spine":
-        addedSpine.push((p as SpinePayload).event);
-        break;
-      case "reflex":
-        addedReflexes.push(p.name);
-        break;
-      case "lens":
-        addedLenses.push(p.subject);
-        break;
-      default:
-        break;
-    }
-  }
-
-  return {
-    addedValues,
-    addedThemes,
-    addedSpine,
-    addedReflexes,
-    addedLenses,
-    supersededCount:
-      countEdges(curr, "supersedes") - countEdges(prev, "supersedes"),
-    newTensions: countEdges(curr, "tension") - countEdges(prev, "tension"),
-  };
-}
-
-/** Render a delta as a compact, templated one-paragraph summary. */
-export function renderDelta(delta: SoulDelta): string {
-  const parts: string[] = [];
-  if (delta.addedValues.length)
-    parts.push(`+${delta.addedValues.length} value(s)`);
-  if (delta.addedThemes.length)
-    parts.push(`+${delta.addedThemes.length} theme(s)`);
-  if (delta.supersededCount > 0) parts.push(`${delta.supersededCount} merged`);
-  if (delta.newTensions > 0) parts.push(`+${delta.newTensions} tension(s)`);
-  if (delta.addedReflexes.length)
-    parts.push(`+reflex ${delta.addedReflexes.join(", ")}`);
-  if (delta.addedLenses.length)
-    parts.push(`+lens ${delta.addedLenses.join(", ")}`);
-  if (delta.addedSpine.length) parts.push(`+${delta.addedSpine.length} spine`);
-  return parts.length ? parts.join(", ") : "no structural change";
-}
-
-/** A fuller multi-line introspection of the delta (for a `/soul` view). */
-export function explainDelta(delta: SoulDelta): string {
-  const lines: string[] = [];
-  for (const v of delta.addedValues) lines.push(`+ value: "${v}"`);
-  for (const t of delta.addedThemes) lines.push(`+ theme: ${t}`);
-  for (const s of delta.addedSpine) lines.push(`+ spine: ${s}`);
-  for (const r of delta.addedReflexes) lines.push(`+ reflex: ${r}`);
-  for (const l of delta.addedLenses) lines.push(`+ lens: ${l}`);
-  if (delta.supersededCount > 0)
-    lines.push(`~ ${delta.supersededCount} value(s) merged away`);
-  if (delta.newTensions > 0)
-    lines.push(`~ ${delta.newTensions} new tension(s)`);
-  return lines.length ? lines.join("\n") : "no structural change";
-}

package/src/core/soul/drift.ts

@@ -1,99 +0,0 @@
-/**
- * Soul Kernel — concept-drift detection (ADWIN).
- *
- * Bifet & Gavaldà, "Learning from Time-Changing Data with Adaptive Windowing"
- * (2007). ADWIN keeps a window of recent observations and, whenever the means of
- * an older and a newer sub-window differ beyond a variance-aware Hoeffding bound,
- * declares a change and forgets the stale older half. It needs no fixed window
- * size — the window adapts to how stationary the stream is.
- *
- * The soul feeds it the scalar outcome of interactions (the valence of what
- * happens). A detected change is a genuine shift in how Talon's behavior is
- * landing — a developmental inflection — which the kernel records as an epoch in
- * the Spine. Pure statistics; model-free.
- *
- * This is the readable ADWIN0 variant (exhaustive cut search over a flat window)
- * rather than the bucketed/exponential-histogram optimization, which is faithful
- * to the test and bound but O(n) per insert — fine at the soul's data rate.
- */
-
-export interface AdwinChange {
-  /** True on the insert that triggered a change. */
-  readonly changed: boolean;
-  /** Mean before the cut (the era being forgotten), when changed. */
-  readonly meanBefore?: number;
-  /** Mean after the cut (the new era), when changed. */
-  readonly meanAfter?: number;
-}
-
-export class Adwin {
-  private window: number[] = [];
-
-  /** @param delta confidence; smaller = fewer false alarms (default 0.002). */
-  constructor(private readonly delta = 0.002) {}
-
-  get width(): number {
-    return this.window.length;
-  }
-
-  get total(): number {
-    return this.window.reduce((s, x) => s + x, 0);
-  }
-
-  get mean(): number {
-    return this.window.length ? this.total / this.window.length : 0;
-  }
-
-  private static stats(xs: number[]): { mean: number; variance: number } {
-    const n = xs.length;
-    if (n === 0) return { mean: 0, variance: 0 };
-    const mean = xs.reduce((s, x) => s + x, 0) / n;
-    const variance = xs.reduce((s, x) => s + (x - mean) ** 2, 0) / n;
-    return { mean, variance };
-  }
-
-  /**
-   * Add an observation. Searches every split; if a split's sub-window means
-   * differ beyond the variance-aware Hoeffding bound, drops the older half and
-   * reports the change.
-   */
-  add(value: number): AdwinChange {
-    this.window.push(value);
-    const n = this.window.length;
-    if (n < 2) return { changed: false };
-
-    const wholeVar = Adwin.stats(this.window).variance;
-
-    for (let cut = 1; cut < n; cut++) {
-      const left = this.window.slice(0, cut);
-      const right = this.window.slice(cut);
-      const n0 = left.length;
-      const n1 = right.length;
-      const m0 = left.reduce((s, x) => s + x, 0) / n0;
-      const m1 = right.reduce((s, x) => s + x, 0) / n1;
-
-      // Harmonic window size and the ADWIN variance-aware bound.
-      const m = 1 / (1 / n0 + 1 / n1);
-      const deltaPrime = this.delta / n;
-      const eps =
-        Math.sqrt((2 / m) * wholeVar * Math.log(2 / deltaPrime)) +
-        (2 / (3 * m)) * Math.log(2 / deltaPrime);
-
-      if (Math.abs(m0 - m1) > eps) {
-        this.window = right; // forget the stale older era
-        return { changed: true, meanBefore: m0, meanAfter: m1 };
-      }
-    }
-    return { changed: false };
-  }
-
-  snapshot(): readonly number[] {
-    return [...this.window];
-  }
-
-  static restore(window: readonly number[], delta = 0.002): Adwin {
-    const a = new Adwin(delta);
-    a.window = [...window];
-    return a;
-  }
-}

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;
-  }
-}