talon-agent 4.6.0 → 5.0.0

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

package/src/core/soul/consolidate.ts

@@ -1,179 +0,0 @@
-/**
- * Soul Kernel — organic consolidation ("the dream").
- *
- * Crystallization clusters loose evidence once. Consolidation is what makes the
- * value graph *alive*: it periodically re-examines the whole lattice and lets it
- * reorganize as experience accumulates — values that have drifted together merge
- * into one, carrying their learned salience and evidence forward.
- *
- * Two principles keep it organic rather than over-programmed:
- *
- *   1. The merge threshold is ADAPTIVE — derived from the current distribution of
- *      nearest-neighbor distances among values, not a magic constant. The lattice
- *      decides its own granularity from its own shape, and that shape changes as
- *      it grows.
- *
- *   2. Learned state is MIGRATED, never lost. A merge supersedes the old values
- *      with a new content-addressed node, sums their salience/evidence into it,
- *      and records `supersedes` edges + a Spine event. Nothing is deleted — the
- *      old nodes simply fall out of projection (filtered as superseded) and decay.
- *
- * No model decides what merges. Geometry and accumulated weight do.
- */
-
-import type { SoulDag } from "./dag.js";
-import { cosineDistance, medoidIndex, type Embedder } from "./embedder.js";
-import { effectiveSalience } from "./salience.js";
-import type { Hash, SoulConfig, ValuePayload } from "./types.js";
-import { halfLifeForKind } from "./types.js";
-
-/** A value is dead once something supersedes it. */
-export function isSuperseded(dag: SoulDag, value: Hash): boolean {
-  return dag.allEdges("supersedes").some((e) => e.to === value);
-}
-
-/** Live (non-superseded) value nodes. */
-export function liveValues(dag: SoulDag): Hash[] {
-  return dag
-    .nodesOfKind("value")
-    .map((n) => n.hash)
-    .filter((h) => !isSuperseded(dag, h));
-}
-
-function evidenceText(dag: SoulDag, hash: Hash): string {
-  const node = dag.getNode(hash);
-  return node?.payload.kind === "evidence" ? node.payload.text : "";
-}
-
-function valueOf(dag: SoulDag, hash: Hash): ValuePayload {
-  return dag.getNode(hash)!.payload as ValuePayload;
-}
-
-/** Median of a numeric array (0 for empty). */
-function median(xs: number[]): number {
-  if (xs.length === 0) return 0;
-  const s = [...xs].sort((a, b) => a - b);
-  const mid = Math.floor(s.length / 2);
-  return s.length % 2 ? s[mid]! : (s[mid - 1]! + s[mid]!) / 2;
-}
-
-export interface ConsolidateOptions {
-  readonly now: number;
-  /** Override the adaptive threshold (mainly for tests). */
-  readonly mergeThreshold?: number;
-  /** Fraction of the median NN distance used as the adaptive threshold. */
-  readonly adaptiveFactor?: number;
-}
-
-export interface ConsolidateResult {
-  readonly created: Hash[];
-  readonly superseded: Hash[];
-  readonly groups: number;
-  readonly threshold: number;
-}
-
-/**
- * Run one consolidation pass. Returns what merged. Caller commits.
- */
-export async function consolidate(
-  dag: SoulDag,
-  embedder: Embedder,
-  cfg: SoulConfig,
-  opts: ConsolidateOptions,
-): Promise<ConsolidateResult> {
-  const values = liveValues(dag);
-  if (values.length < 2) {
-    return { created: [], superseded: [], groups: 0, threshold: 0 };
-  }
-
-  // Represent each value by its medoid embedding.
-  const repTexts = values.map((h) => evidenceText(dag, valueOf(dag, h).medoid));
-  const reps = await embedder.embed(repTexts);
-
-  // Adaptive threshold: how close is "unusually close" for THIS lattice right now.
-  const nn: number[] = [];
-  for (let i = 0; i < values.length; i++) {
-    let best = Infinity;
-    for (let j = 0; j < values.length; j++) {
-      if (i === j) continue;
-      best = Math.min(best, cosineDistance(reps[i]!, reps[j]!));
-    }
-    if (Number.isFinite(best)) nn.push(best);
-  }
-  const factor = opts.adaptiveFactor ?? 0.6;
-  const threshold = opts.mergeThreshold ?? median(nn) * factor;
-
-  // Connected components over the "close enough to merge" graph (union-find).
-  const parent = values.map((_, i) => i);
-  const find = (x: number): number => {
-    while (parent[x] !== x) {
-      parent[x] = parent[parent[x]!]!;
-      x = parent[x]!;
-    }
-    return x;
-  };
-  const union = (a: number, b: number): void => {
-    parent[find(a)] = find(b);
-  };
-  for (let i = 0; i < values.length; i++) {
-    for (let j = i + 1; j < values.length; j++) {
-      if (cosineDistance(reps[i]!, reps[j]!) <= threshold) union(i, j);
-    }
-  }
-
-  // Gather groups of size > 1.
-  const groups = new Map<number, number[]>();
-  for (let i = 0; i < values.length; i++) {
-    const root = find(i);
-    (groups.get(root) ?? groups.set(root, []).get(root)!).push(i);
-  }
-
-  const created: Hash[] = [];
-  const superseded: Hash[] = [];
-
-  for (const members of groups.values()) {
-    if (members.length < 2) continue;
-
-    const oldValues = members.map((i) => values[i]!);
-    // Union of all member evidence across the merging values.
-    const evidenceSet = new Set<Hash>();
-    for (const v of oldValues) {
-      const p = valueOf(dag, v);
-      evidenceSet.add(p.medoid);
-      for (const m of p.members) evidenceSet.add(m);
-    }
-    const evidence = [...evidenceSet].sort();
-
-    // Recompute the medoid over the merged evidence — its new label emerges.
-    const evTexts = evidence.map((h) => evidenceText(dag, h));
-    const evVecs = await embedder.embed(evTexts);
-    const medoid = evidence[medoidIndex(evVecs)]!;
-
-    const merged = dag.addNode(
-      { kind: "value", members: evidence, medoid },
-      opts.now,
-    );
-    created.push(merged);
-
-    // Migrate learned state forward: sum decayed salience + evidence + activations.
-    const target = dag.stateOf(merged);
-    for (const v of oldValues) {
-      const s = dag.stateOf(v);
-      target.salience += effectiveSalience(
-        s,
-        opts.now,
-        halfLifeForKind(cfg, "value"),
-      );
-      target.evidence += s.evidence;
-      target.activations += s.activations;
-      const e = dag.edge(merged, "supersedes", v, opts.now);
-      e.weight = 1;
-      e.updatedAt = opts.now;
-      if (v !== merged) superseded.push(v);
-    }
-    target.lastActivatedAt = opts.now;
-    dag.touch(merged);
-  }
-
-  return { created, superseded, groups: created.length, threshold };
-}