talon-agent 4.6.1 → 5.0.1

package/src/core/soul/README.md

@@ -1,110 +0,0 @@
-# Soul Kernel
-
-Talon's compiled identity. Not a markdown prompt, not a JSON blob — a
-**content-addressed Merkle DAG** of typed identity nodes, learned **mechanically**
-from behavioral telemetry and projected into the system prompt by **selection**.
-
-> The model is the brain. Talon is the body. The Soul is the persistent identity
-> artifact that tells the brain how to be Talon.
-
-## The thesis: the model never writes its own soul
-
-There are two jobs — _being the self_ (the reasoning model reads the soul and
-acts) and _writing the self_ (turning experience into identity). If the reasoning
-model does the second, it can rationalize, flatter itself, and confabulate a
-coherent self-story that isn't true. So **writing the self is strictly
-model-free**: continuous, deterministic, evidence-grounded. The reasoning model is
-a _reader_ of the soul, never its author. That is the safety property, not just a
-cost saving.
-
-The only neural component anywhere is an optional **local embedder** (for
-clustering/dedup/contradiction-distance) — a frozen fixed function, not an agent.
-Everything else is counters, exponential decay, dot products, and selection.
-
-## The substrate
-
-A node's identity is the sha-256 of its canonical content. The single most
-important decision is the split between:
-
-- **Content** (hashed, immutable) — a node's semantic identity: kind + verbatim
-  payload + referenced child hashes. A change of content is a new node.
-- **State** (mutable, keyed by hash) — salience, evidence weight, activation
-  counts. Churns every tick; lives _outside_ the Merkle structure.
-
-So reinforcing a value a thousand times never churns a single content hash.
-Versioning, provenance, dedup, and partial recompilation fall out structurally;
-learning and decay live in the state layer.
-
-## The five structures
-
-| Structure | Node kind       | What it is                                                                                  |
-| --------- | --------------- | ------------------------------------------------------------------------------------------- |
-| Spine     | `spine`         | append-only causal narrative — _why_ Talon became Talon                                     |
-| Lattice   | `value` + edges | values as evidence clusters; tension/affinity edges self-organize via Hebbian co-activation |
-| Reflexes  | `reflex`        | `trigger → guard → action` rules the harness _enforces_                                     |
-| Holograph | `lens`          | identity refracted per interlocutor (selection + reweighting)                               |
-| Critic    | (classifiers)   | frozen feature-based gates over failure modes                                               |
-
-The atoms under all of it are `evidence` nodes — verbatim ground truth. The kernel
-never paraphrases; it only ever quotes.
-
-## The model-free pipeline
-
-```
-telemetry ──▶ signals ──▶ compiler ──▶ DAG (+ salience/Hebbian) ──▶ projector ──▶ runtime.md
-  (harness)   (structured)  (arithmetic)   (content + state)        (selection)   (injected)
-```
-
-- **Signals** (`signals.ts`) — structured harness events (reaction, engagement,
-  correction, reflex-fire). Interpretation already happened; no transcript reading.
-- **Compiler** (`compiler.ts`) — routes each signal to pure update rules. Outcome
-  signals reinforce/penalize the values that were live in that turn's projection
-  and Hebbian-coactivate them; corrections store verbatim evidence + a Spine event.
-- **Salience** (`salience.ts`) — lazy exponential decay, reinforcement, Hebbian
-  edges, predictive-coding delta rule. The whole "learning" is here, all arithmetic.
-- **Projector** (`projector.ts`) — selects verbatim evidence, salience-ordered
-  under a token budget. Reflexes are never budgeted away. The soul cannot
-  hallucinate itself.
-- **Critic** (`critic.ts`) — frozen classifiers for wall-of-text, sycophancy,
-  emoji-overload.
-- **Kernel** (`kernel.ts`) — orchestrator: genesis → ingest → commit → project,
-  with a git-like commit chain and JSON persistence.
-
-## File map
-
-```
-types.ts       node payloads, edges, activation state, commits, config
-hash.ts        canonical serialization + content addressing + Merkle root
-dag.ts         the DAG store: integrity, dirty propagation, snapshot/restore
-salience.ts    decay / reinforce / coactivate / prediction-error  (the math)
-reflex.ts      predicate registry + enforcer + the three seed reflexes
-signals.ts     structured telemetry types + emoji→valence
-compiler.ts    signal → arithmetic update routing  (writing the self)
-projector.ts   DAG → runtime surface by selection  (reading the self)
-critic.ts      frozen failure-mode classifiers
-kernel.ts      orchestrator: lifecycle, commits, persistence
-index.ts       public surface
-```
-
-## Status
-
-Implemented and tested (150+ tests, model-free end to end):
-
-- **Substrate** — content-addressed Merkle DAG, dirty-tracking, commits, persistence.
-- **Learning** — salience decay/reinforce, Hebbian edges, predictive-coding updates.
-- **Emergence** — value clustering (`crystallize`), self-reorganizing `consolidate`
-  ("dream") with adaptive thresholds + state migration, reflection into `theme`s.
-- **Embedding** — our own `TalonEmbedder` (model-free) behind a pluggable seam.
-- **Adaptation** — learned valence (meaning from outcomes), FSRS/DSR forgetting,
-  ADWIN drift → Spine epochs, emergent failure modes.
-- **Recall** — Generative-Agents context retrieval, PageRank centrality, modern
-  Hopfield associative recall, VSA/HDC compositional episodic memory.
-- **Refraction** — relational holograph lens compilation.
-- **Surfaces** — projector (selection), delta stream, mechanical Critic.
-- **Governance** — protected-node approval queue; runtime gate (off by default).
-
-See `RESEARCH.md` for the literature behind each mechanism.
-
-Remaining: **harness wiring** — telemetry taps (reactions/engagement/corrections →
-signals), prompt injection of the projected surface, and live reflex enforcement.
-This touches the live Talon runtime and is gated behind `TALON_SOUL_ENABLED`.

package/src/core/soul/RESEARCH.md

@@ -1,98 +0,0 @@
-# Soul Kernel — research grounding
-
-Every mechanism in the kernel is model-free, but few are invented. This maps the
-load-bearing ideas to the literature they come from, and notes where each lives.
-
-## Implemented
-
-### Content-addressed Merkle DAG — `hash.ts`, `dag.ts`
-
-- Merkle, "A Digital Signature Based on a Conventional Encryption Function" (1987);
-  the git object model (Torvalds/Hamano, 2005).
-- Why: content addressing makes dedup, provenance, versioning, and partial
-  recompilation structural rather than bolted on.
-
-### Hebbian association — `salience.coactivate`, `lattice.ts`
-
-- Hebb, _The Organization of Behavior_ (1949): "cells that fire together wire
-  together."
-- Why: the value lattice's affinity/tension edges self-organize from
-  co-activation counts; no model decides what relates.
-
-### Predictive-coding / free-energy updates — `salience.applyPredictionError`
-
-- Rao & Ballard (1999); Friston, free-energy principle (2010).
-- Why: the soul is a predictive model of its own behavior; a correction is a
-  large prediction error and updates salience proportionally.
-
-### Complementary Learning Systems / systems consolidation — `consolidate.ts`
-
-- McClelland, McNaughton & O'Reilly (1995); memory replay during sleep
-  (Wilson & McNaughton, 1994).
-- Why: fast intake (crystallize) vs. slow reorganization (the "dream" pass that
-  merges drifted-together values and migrates learned state) mirrors the
-  fast-hippocampal / slow-neocortical split.
-
-### Feature hashing embedder — `talon-embedder.ts`
-
-- Weinberger et al., "Feature Hashing for Large Scale Multitask Learning" (2009);
-  signed hashing to debias collisions.
-- Why: a deterministic, dependency-free, model-free encoder we own — robust to
-  typos via shared character n-grams; a real sentence encoder drops in behind the
-  same interface.
-
-### Generative-Agents retrieval — `retrieve.ts`
-
-- Park et al., "Generative Agents: Interactive Simulacra of Human Behavior" (2023).
-- Score = normalized(recency) + normalized(importance) + normalized(relevance),
-  each min-max'd to [0,1] before summation, exactly as in the paper. Makes the
-  projected soul _relevant to the current moment_, not just globally salient.
-
-### FSRS / DSR adaptive forgetting — `forgetting.ts`
-
-- Wozniak's DSR model; FSRS (open-spaced-repetition); power-law forgetting
-  (Wickelgren, 1974) which fits human retention better than an exponential.
-- Retrievability R(t) = (1 + FACTOR·t/S)^DECAY with R(S) ≈ 0.9; stability S grows
-  on spaced successful recall and shrinks on a lapse. Core traits become durable,
-  fads evaporate — emergently.
-
-### Modern Hopfield associative recall — `associative.ts`
-
-- Ramsauer et al., "Hopfield Networks is All You Need" (2020); Krotov & Hopfield
-  (2016, 2020). Continuous Hopfield retrieval is one softmax step — the same
-  operation as attention.
-- Recall from a cue = softmax over Hebbian edge weights, p ∝ exp(β·w); `prime`
-  applies the update to the lattice so the soul recalls in constellations.
-
-### Reflection — `reflect.ts`
-
-- Park et al. (2023): synthesize higher-level inferences over time. Done
-  structurally — themes form over values that are coherent AND co-active. The one
-  optional, gated model pass (a label-only `synthesize` hook) lives here and can
-  never change which values group.
-
-### Concept-drift detection — `drift.ts`
-
-- Bifet & Gavaldà, "Learning from Time-Changing Data with Adaptive Windowing"
-  (ADWIN, 2007). Detects shifts in interaction-outcome distribution and opens a
-  developmental epoch in the Spine.
-
-### Personalized PageRank centrality — `centrality.ts`
-
-- Page, Brin, Motwani & Winograd (1999). Structural importance over the
-  co-activation graph; personalizable to a context.
-
-### Hyperdimensional / Vector-Symbolic memory — `hdc.ts`
-
-- Kanerva, "Hyperdimensional Computing" (2009). bind/bundle/permute/cleanup over
-  high-dim bipolar vectors give a compositional, model-free episodic memory:
-  context⊗value bound and bundled, recalled by unbinding — "in a situation like
-  this, what do I do?"
-
-## Future directions (researched, not yet built)
-
-- **Holographic Reduced Representations** (Plate, 1995) as a circular-convolution
-  alternative to elementwise binding, for graceful capacity scaling.
-- **Sparse distributed memory** (Kanerva, 1988) as an alternative episodic store.
-- **Active-inference planning** (Friston et al.) atop the existing predictive-
-  coding updates, to _select_ behavior, not just learn from it.

package/src/core/soul/associative.ts

@@ -1,98 +0,0 @@
-/**
- * Soul Kernel — associative recall (modern Hopfield / attention).
- *
- * Grounded in Ramsauer et al., "Hopfield Networks is All You Need" (2020), which
- * showed that a continuous modern Hopfield network retrieves a stored pattern in
- * ONE update via a softmax over similarities — the very operation at the heart of
- * attention. We apply the same rule to the lattice: the Hebbian coactivation
- * edges are the stored associations, and recalling from a cue is a one-step
- * softmax over the edge weights.
- *
- *   p(neighbor) ∝ exp(β · w(cue → neighbor))
- *
- * `prime` then performs the Hopfield update against the lattice itself: it nudges
- * the salience of the associatively-bound partners. The behavioral effect is what
- * you would want from a self — thinking of one value brings its companions to
- * mind ("push back" primes "be direct"), so the soul recalls in coherent
- * constellations rather than isolated points. Still model-free: a softmax over
- * counts.
- */
-
-import type { SoulDag } from "./dag.js";
-import type { Hash } from "./types.js";
-
-export interface RecallResult {
-  readonly node: Hash;
-  /** Softmax weight in (0, 1]; the constellation sums to 1. */
-  readonly weight: number;
-}
-
-export interface RecallOptions {
-  /** Inverse temperature; higher β sharpens recall toward the strongest bond. */
-  readonly beta?: number;
-  /** Keep only the top-K partners (default: all). */
-  readonly topK?: number;
-}
-
-/**
- * One-step associative retrieval from one or more cue nodes. Aggregates
- * coactivation edge weights to each neighbor, then softmaxes. Cues are excluded
- * from their own recall.
- */
-export function associativeRecall(
-  dag: SoulDag,
-  cues: readonly Hash[],
-  opts: RecallOptions = {},
-): RecallResult[] {
-  const beta = opts.beta ?? 1;
-  const cueSet = new Set(cues);
-  const score = new Map<Hash, number>();
-  for (const cue of cues) {
-    for (const e of dag.edgesFrom(cue, "coactivation")) {
-      if (cueSet.has(e.to)) continue;
-      score.set(e.to, (score.get(e.to) ?? 0) + e.weight);
-    }
-  }
-  if (score.size === 0) return [];
-
-  // Numerically-stable softmax over β·score.
-  const entries = [...score.entries()];
-  const max = Math.max(...entries.map(([, w]) => w));
-  const exps = entries.map(
-    ([h, w]) => [h, Math.exp(beta * (w - max))] as const,
-  );
-  const z = exps.reduce((s, [, e]) => s + e, 0);
-
-  const out = exps
-    .map(([node, e]) => ({ node, weight: e / z }))
-    .sort((a, b) => b.weight - a.weight || a.node.localeCompare(b.node));
-  return opts.topK ? out.slice(0, opts.topK) : out;
-}
-
-export interface PrimeOptions extends RecallOptions {
-  readonly now: number;
-  /** Salience injected, distributed across the recalled constellation. */
-  readonly gain: number;
-}
-
-/**
- * The Hopfield update applied to the lattice: recall from the cues and add
- * salience to the bound partners in proportion to their recall weight. Returns
- * the primed nodes. Caller commits.
- */
-export function prime(
-  dag: SoulDag,
-  cues: readonly Hash[],
-  opts: PrimeOptions,
-): Hash[] {
-  const recalled = associativeRecall(dag, cues, opts);
-  const primed: Hash[] = [];
-  for (const { node, weight } of recalled) {
-    const s = dag.stateOf(node);
-    s.salience += opts.gain * weight;
-    s.lastActivatedAt = opts.now;
-    dag.touch(node);
-    primed.push(node);
-  }
-  return primed;
-}

package/src/core/soul/centrality.ts

@@ -1,98 +0,0 @@
-/**
- * Soul Kernel — graph centrality (Personalized PageRank).
- *
- * Degree centrality ("how many strong bonds does this value have") is a crude
- * importance signal. PageRank (Page, Brin, Motwani & Winograd, 1999) is the
- * principled one: a value is important if it is bonded to OTHER important values.
- * We run it over the Hebbian co-activation graph so structural importance
- * reflects the whole association network, not just local degree.
- *
- * The "personalized" variant biases the teleport distribution toward a set of
- * seed nodes, yielding importance *relative to a context* — central with respect
- * to whatever is currently active. Pure power iteration; model-free.
- */
-
-import type { SoulDag } from "./dag.js";
-import type { Hash } from "./types.js";
-
-export interface PageRankOptions {
-  readonly damping?: number;
-  readonly iterations?: number;
-  readonly epsilon?: number;
-  /**
-   * Optional personalization: teleport mass distribution over nodes. Values are
-   * normalized internally. Absent ⇒ uniform (classic PageRank).
-   */
-  readonly personalization?: ReadonlyMap<Hash, number>;
-}
-
-/**
- * Weighted Personalized PageRank over the value co-activation graph. Returns a
- * score per live value summing to 1. Dangling nodes (no outbound bonds)
- * redistribute their mass via the teleport vector, keeping it a proper
- * distribution.
- */
-export function pagerank(
-  dag: SoulDag,
-  opts: PageRankOptions = {},
-): Map<Hash, number> {
-  const damping = opts.damping ?? 0.85;
-  const iterations = opts.iterations ?? 100;
-  const epsilon = opts.epsilon ?? 1e-9;
-
-  const nodes = dag.nodesOfKind("value").map((n) => n.hash);
-  const n = nodes.length;
-  const out = new Map<Hash, number>();
-  if (n === 0) return out;
-
-  const idx = new Map(nodes.map((h, i) => [h, i]));
-
-  // Weighted out-adjacency over coactivation edges (only among value nodes).
-  const outWeight = Array.from({ length: n }, () => 0);
-  const edges: { from: number; to: number; w: number }[] = [];
-  for (const from of nodes) {
-    for (const e of dag.edgesFrom(from, "coactivation")) {
-      const j = idx.get(e.to);
-      if (j === undefined || e.weight <= 0) continue;
-      const i = idx.get(from)!;
-      edges.push({ from: i, to: j, w: e.weight });
-      outWeight[i]! += e.weight;
-    }
-  }
-
-  // Teleport / personalization vector.
-  const teleport = Array.from({ length: n }, () => 1 / n);
-  if (opts.personalization && opts.personalization.size > 0) {
-    let total = 0;
-    for (const [, w] of opts.personalization) total += Math.max(0, w);
-    if (total > 0) {
-      for (let i = 0; i < n; i++) teleport[i] = 0;
-      for (const [h, w] of opts.personalization) {
-        const i = idx.get(h);
-        if (i !== undefined) teleport[i]! += Math.max(0, w) / total;
-      }
-    }
-  }
-
-  let rank = Array.from({ length: n }, () => 1 / n);
-  for (let it = 0; it < iterations; it++) {
-    const next = teleport.map((t) => (1 - damping) * t);
-
-    // Dangling mass (nodes with no out-edges) flows to the teleport vector.
-    let dangling = 0;
-    for (let i = 0; i < n; i++) if (outWeight[i] === 0) dangling += rank[i]!;
-    for (let i = 0; i < n; i++) next[i]! += damping * dangling * teleport[i]!;
-
-    for (const e of edges) {
-      next[e.to]! += (damping * rank[e.from]! * e.w) / outWeight[e.from]!;
-    }
-
-    let delta = 0;
-    for (let i = 0; i < n; i++) delta += Math.abs(next[i]! - rank[i]!);
-    rank = next;
-    if (delta < epsilon) break;
-  }
-
-  for (let i = 0; i < n; i++) out.set(nodes[i]!, rank[i]!);
-  return out;
-}

package/src/core/soul/cluster.ts

@@ -1,83 +0,0 @@
-/**
- * Soul Kernel — emergent value clustering.
- *
- * This is where values *come from*: not authored, not seeded by a model, but
- * discovered as clusters of evidence embeddings. The model never names a value —
- * the cluster's medoid (its most central real fragment) is its label.
- *
- * The algorithm is single-pass leader/threshold clustering: each item joins the
- * nearest existing cluster if it is within `threshold` cosine distance of that
- * cluster's centroid, otherwise it founds a new cluster. Leader clustering is
- * order-sensitive, so items are processed in a stable hash order to keep the
- * output deterministic and reproducible across runs.
- */
-
-import { centroid, cosineDistance, medoidIndex } from "./embedder.js";
-import type { Hash } from "./types.js";
-
-export interface Embedded {
-  readonly hash: Hash;
-  readonly vector: readonly number[];
-}
-
-export interface EvidenceCluster {
-  /** Evidence hashes in the cluster, in stable order. */
-  readonly members: Hash[];
-  /** The medoid evidence hash — the value's verbatim label. */
-  readonly medoid: Hash;
-  /** Cluster centroid, for downstream distance comparisons. */
-  readonly centroid: number[];
-}
-
-interface MutableCluster {
-  members: Hash[];
-  vectors: number[][];
-  centroid: number[];
-}
-
-/**
- * Cluster embedded evidence into emergent groups. `threshold` is the maximum
- * cosine distance for an item to join a cluster (smaller = tighter, more
- * clusters). Processing order is stabilized by hash so results are deterministic.
- */
-export function clusterEvidence(
-  items: readonly Embedded[],
-  threshold: number,
-): EvidenceCluster[] {
-  const sorted = [...items].sort((a, b) => a.hash.localeCompare(b.hash));
-  const clusters: MutableCluster[] = [];
-
-  for (const item of sorted) {
-    let nearest = -1;
-    let nearestDist = Infinity;
-    for (let c = 0; c < clusters.length; c++) {
-      const d = cosineDistance(item.vector, clusters[c]!.centroid);
-      if (d < nearestDist) {
-        nearestDist = d;
-        nearest = c;
-      }
-    }
-
-    if (nearest >= 0 && nearestDist <= threshold) {
-      const cl = clusters[nearest]!;
-      cl.members.push(item.hash);
-      cl.vectors.push([...item.vector]);
-      cl.centroid = centroid(cl.vectors);
-    } else {
-      clusters.push({
-        members: [item.hash],
-        vectors: [[...item.vector]],
-        centroid: [...item.vector],
-      });
-    }
-  }
-
-  return clusters.map((cl) => {
-    const mi = medoidIndex(cl.vectors);
-    return {
-      members: cl.members,
-      medoid: cl.members[mi]!,
-      centroid: cl.centroid,
-    };
-  });
-}

package/src/core/soul/compiler.ts

@@ -1,207 +0,0 @@
-/**
- * Soul Kernel — the compiler. Maps structured signals to arithmetic updates.
- *
- * This is the "writing the self" process, and it contains no model call. Each
- * signal routes to the pure update rules in salience.ts:
- *
- *   reaction / engagement → reinforce or penalize the active values + Hebbian
- *                           co-activation of the set that fired together.
- *   correction            → store the verbatim text as evidence, append a Spine
- *                           event (corrections are formative), penalize whatever
- *                           values were live when it landed.
- *   directive             → store the verbatim instruction as evidence for later
- *                           clustering into a value (embedder phase).
- *   reflex-fire (block)   → record the near-miss in the Spine.
- *   activation            → co-activate the live set; a faint reinforcement.
- *
- * Evidence is always verbatim ground truth; the compiler never paraphrases.
- */
-
-import { SoulDag } from "./dag.js";
-import { coactivate, reinforce } from "./salience.js";
-import { reinforceFsrs } from "./forgetting.js";
-import { emojiValence } from "./signals.js";
-import type { CorrectionSignal, DirectiveSignal, Signal } from "./signals.js";
-import type { EvidencePayload, Hash, SoulConfig } from "./types.js";
-import { halfLifeForKind } from "./types.js";
-
-export interface IngestResult {
-  /** Evidence node created from a correction/directive, if any. */
-  readonly evidenceAdded?: Hash;
-  /** Spine event appended, if any. */
-  readonly spineAdded?: Hash;
-  /** Nodes whose state was touched. */
-  readonly touched: readonly Hash[];
-}
-
-/** Find the most recent spine node to chain a new event onto. */
-function latestSpine(dag: SoulDag): Hash | undefined {
-  let best: Hash | undefined;
-  let bestAt = -Infinity;
-  for (const node of dag.nodesOfKind("spine")) {
-    if (node.payload.kind === "spine" && node.payload.at > bestAt) {
-      bestAt = node.payload.at;
-      best = node.hash;
-    }
-  }
-  return best;
-}
-
-/** Append a developmental-narrative event, chained to the prior spine node. */
-export function appendSpine(
-  dag: SoulDag,
-  event: string,
-  at: number,
-  affects: readonly Hash[] = [],
-): Hash {
-  return dag.addNode({
-    kind: "spine",
-    event,
-    at,
-    affects: [...affects],
-    prev: latestSpine(dag),
-  });
-}
-
-function addEvidence(
-  dag: SoulDag,
-  text: string,
-  at: number,
-  origin: EvidencePayload["source"]["origin"],
-  actor?: string,
-  ref?: string,
-): Hash {
-  return dag.addNode({
-    kind: "evidence",
-    text,
-    observedAt: at,
-    source: { origin, ...(actor ? { actor } : {}), ...(ref ? { ref } : {}) },
-  });
-}
-
-function reinforceNode(
-  dag: SoulDag,
-  hash: Hash,
-  cfg: SoulConfig,
-  amount: number,
-  valence: number,
-  at: number,
-): void {
-  const kind = dag.getNode(hash)?.payload.kind;
-  if (cfg.adaptiveForgetting) {
-    reinforceFsrs(dag.stateOf(hash), {
-      now: at,
-      cfg,
-      amount,
-      valence,
-      ...(kind !== undefined ? { kind } : {}),
-    });
-    dag.touch(hash);
-    return;
-  }
-  reinforce(dag, hash, {
-    now: at,
-    halfLifeMs: halfLifeForKind(cfg, kind),
-    amount,
-    valence,
-  });
-}
-
-function ingestOutcome(
-  dag: SoulDag,
-  nodes: readonly Hash[],
-  valence: number,
-  cfg: SoulConfig,
-  at: number,
-): Hash[] {
-  const present = nodes.filter((h) => dag.hasNode(h));
-  for (const h of present) {
-    reinforceNode(dag, h, cfg, cfg.reinforce, valence, at);
-  }
-  if (present.length > 1) {
-    coactivate(dag, present, { now: at, increment: cfg.hebbIncrement });
-  }
-  return present;
-}
-
-function ingestCorrection(
-  dag: SoulDag,
-  sig: CorrectionSignal,
-  cfg: SoulConfig,
-): IngestResult {
-  const evidence = addEvidence(
-    dag,
-    sig.text,
-    sig.at,
-    "correction",
-    sig.actor,
-    sig.ref,
-  );
-  const spine = appendSpine(dag, `Correction: ${sig.text}`, sig.at, [evidence]);
-  // Penalize values that were live when the correction landed.
-  const penalized = ingestOutcome(dag, sig.activeNodes ?? [], -2, cfg, sig.at);
-  return { evidenceAdded: evidence, spineAdded: spine, touched: penalized };
-}
-
-function ingestDirective(dag: SoulDag, sig: DirectiveSignal): IngestResult {
-  const evidence = addEvidence(
-    dag,
-    sig.text,
-    sig.at,
-    "directive",
-    sig.actor,
-    sig.ref,
-  );
-  return { evidenceAdded: evidence, touched: [] };
-}
-
-/** Apply one signal to the kernel. Pure arithmetic + verbatim evidence.
- *
- * `valenceOf` resolves a cue's valence; pass a learned ValenceModel.valence to
- * let meaning come from data, or omit to use the static emoji prior. */
-export function ingest(
-  dag: SoulDag,
-  signal: Signal,
-  cfg: SoulConfig,
-  valenceOf: (cue: string) => number = emojiValence,
-): IngestResult {
-  switch (signal.kind) {
-    case "reaction": {
-      const v = valenceOf(signal.emoji);
-      const touched = ingestOutcome(dag, signal.activeNodes, v, cfg, signal.at);
-      return { touched };
-    }
-    case "engagement": {
-      const v = signal.continued ? 1 : -1;
-      const touched = ingestOutcome(dag, signal.activeNodes, v, cfg, signal.at);
-      return { touched };
-    }
-    case "correction":
-      return ingestCorrection(dag, signal, cfg);
-    case "directive":
-      return ingestDirective(dag, signal);
-    case "reflex-fire": {
-      if (signal.severity !== "block") return { touched: [] };
-      const spine = appendSpine(
-        dag,
-        `Reflex blocked a misstep: ${signal.name}`,
-        signal.at,
-      );
-      return { spineAdded: spine, touched: [] };
-    }
-    case "activation": {
-      const touched = ingestOutcome(dag, signal.activeNodes, 0, cfg, signal.at);
-      return { touched };
-    }
-  }
-}
-
-/** Apply a batch of signals in order. */
-export function ingestAll(
-  dag: SoulDag,
-  signals: readonly Signal[],
-  cfg: SoulConfig,
-  valenceOf: (cue: string) => number = emojiValence,
-): IngestResult[] {
-  return signals.map((s) => ingest(dag, s, cfg, valenceOf));
-}