talon-agent 4.6.0 → 5.0.0

package/src/core/soul/talon-embedder.ts

@@ -1,80 +0,0 @@
-/**
- * Soul Kernel — Talon's own embedder.
- *
- * We own this rather than borrowing MemPalace's: the soul should not depend on
- * another subsystem's model lifecycle, and identity geometry deserves a fixed,
- * versioned function we control. It is deterministic, dependency-free, and
- * model-free — a strong lexical encoder, not a neural one — so it can run
- * anywhere, forever, without weights or a runtime.
- *
- * Construction (richer than plain n-gram hashing):
- *   - word unigrams and bigrams capture phrasing,
- *   - character 3/4/5-grams capture morphology and typos (paraphrase robustness),
- *   - sublinear term weighting (1 + log count) damps repetition,
- *   - signed feature hashing into a wide space limits collision bias,
- *   - L2 normalization makes cosine the natural metric.
- *
- * The Embedder interface is the seam: if we ever want a real sentence-transformer
- * (e.g. ONNX, local), it drops in behind the same interface with zero changes
- * upstream. Until then, this is the canonical embedder for the kernel.
- */
-
-import { createHash } from "node:crypto";
-import { normalize, type Embedder } from "./embedder.js";
-
-const TOKEN_RE = /[a-z0-9]+/g;
-
-export interface TalonEmbedderOptions {
-  readonly dim?: number;
-  readonly charNgrams?: readonly number[];
-  readonly wordBigrams?: boolean;
-}
-
-export class TalonEmbedder implements Embedder {
-  readonly dim: number;
-  private readonly charNgrams: readonly number[];
-  private readonly wordBigrams: boolean;
-
-  constructor(opts: TalonEmbedderOptions = {}) {
-    this.dim = opts.dim ?? 1024;
-    this.charNgrams = opts.charNgrams ?? [3, 4, 5];
-    this.wordBigrams = opts.wordBigrams ?? true;
-  }
-
-  async embed(texts: readonly string[]): Promise<number[][]> {
-    return texts.map((t) => this.embedOne(t));
-  }
-
-  /** Synchronous single-text embedding — handy for internal hot paths. */
-  embedOne(text: string): number[] {
-    const counts = new Map<string, number>();
-    const bump = (feature: string): void => {
-      counts.set(feature, (counts.get(feature) ?? 0) + 1);
-    };
-
-    const lower = text.toLowerCase();
-    const words = lower.match(TOKEN_RE) ?? [];
-    for (const w of words) bump(`w:${w}`);
-    if (this.wordBigrams) {
-      for (let i = 0; i + 1 < words.length; i++) {
-        bump(`b:${words[i]}_${words[i + 1]}`);
-      }
-    }
-    const stream = ` ${words.join(" ")} `;
-    for (const n of this.charNgrams) {
-      for (let i = 0; i + n <= stream.length; i++) {
-        bump(`c${n}:${stream.slice(i, i + n)}`);
-      }
-    }
-
-    const vec = Array.from({ length: this.dim }, () => 0);
-    for (const [feature, count] of counts) {
-      const h = createHash("md5").update(feature).digest();
-      const idx = ((h[0]! << 16) | (h[1]! << 8) | h[2]!) % this.dim;
-      const sign = (h[3]! & 1) === 0 ? 1 : -1;
-      const weight = 1 + Math.log(count); // sublinear term weighting
-      vec[idx]! += sign * weight;
-    }
-    return normalize(vec);
-  }
-}

package/src/core/soul/taps.ts

@@ -1,199 +0,0 @@
-/**
- * Soul Kernel — runtime taps.
- *
- * The thin glue that turns live runtime events into kernel signals. The kernel
- * itself never reads a transcript; it consumes *structured* events the harness
- * already produces. This module is where those events are recognized and handed
- * to {@link SoulService}.
- *
- * Everything here is gated on the soul being enabled (`getSoul().enabled`). When
- * it's off, every function is a cheap no-op and nothing is tracked or allocated
- * beyond the empty maps — so a deployment without a soul behaves byte-identically.
- *
- * Two responsibilities:
- *   1. Remember which messages Talon *itself* sent, so a later reaction update
- *      can be attributed to one of our own messages. A reaction to Talon is
- *      feedback about Talon; a reaction to someone else's message is not.
- *   2. Classify inbound user text that is addressed to Talon into directives and
- *      corrections, using high-precision mechanical heuristics (no model).
- */
-
-import { getSoul } from "./service.js";
-import { log } from "../../util/log.js";
-
-// ── Bot-message memory ───────────────────────────────────────────────────────
-
-/**
- * Per-chat bounded ring of recently-sent bot message IDs. Telegram's
- * `message_reaction` update tells us *which* message was reacted to but not who
- * authored it, so we keep a small FIFO of our own outgoing IDs and attribute a
- * reaction only when it lands on one of them. Bounded so a long-lived process
- * never grows this without limit.
- */
-const RING_PER_CHAT = 200;
-const botMessages = new Map<string, number[]>();
-
-/**
- * The action names that produce a *new* outgoing bot message worth tracking.
- * Deliberately excludes `react`, `edit_message`, `pin_message`, etc.: those
- * either return someone else's message id or mutate an existing one, so crediting
- * a reaction to them would be wrong.
- */
-export const BOT_MESSAGE_ACTIONS: ReadonlySet<string> = new Set([
-  "send_message",
-  "reply_to",
-  "send_message_with_buttons",
-  "send_file",
-  "send_photo",
-  "send_video",
-  "send_animation",
-  "send_voice",
-  "send_audio",
-  "send_sticker",
-  "send_poll",
-  "send_location",
-  "send_contact",
-  "send_dice",
-  "copy_message",
-  "forward_message",
-]);
-
-/** Record that Talon sent a message, so a later reaction can be attributed. */
-export function noteBotMessage(chatId: string | number, msgId: number): void {
-  if (!getSoul().enabled) return;
-  if (!Number.isFinite(msgId) || msgId <= 0) return;
-  const key = String(chatId);
-  const ring = botMessages.get(key) ?? [];
-  if (ring.includes(msgId)) return;
-  ring.push(msgId);
-  if (ring.length > RING_PER_CHAT) ring.shift();
-  botMessages.set(key, ring);
-}
-
-/** True when `msgId` is one of Talon's own recently-sent messages in this chat. */
-export function isBotMessage(chatId: string | number, msgId: number): boolean {
-  return botMessages.get(String(chatId))?.includes(msgId) ?? false;
-}
-
-/** Drop all tracked bot messages (tests / explicit reset). */
-export function resetBotMessages(): void {
-  botMessages.clear();
-}
-
-// ── Reaction tap ─────────────────────────────────────────────────────────────
-
-/** A `ReactionType`-shaped item from Telegram's reaction arrays. */
-export interface ReactionTypeLike {
-  readonly type: string;
-  readonly emoji?: string;
-}
-
-/**
- * The emojis present in `next` but not in `prev` — i.e. reactions just *added*.
- * Custom and paid reactions (no `.emoji`) are ignored; only standard emoji carry
- * a valence the kernel understands.
- */
-export function newlyAddedEmojis(
-  prev: readonly ReactionTypeLike[],
-  next: readonly ReactionTypeLike[],
-): string[] {
-  const before = new Set(
-    prev.filter((r) => r.type === "emoji" && r.emoji).map((r) => r.emoji),
-  );
-  return next
-    .filter((r) => r.type === "emoji" && r.emoji && !before.has(r.emoji))
-    .map((r) => r.emoji as string);
-}
-
-/**
- * A user added reactions to one of Talon's messages → reinforce/penalize the
- * values that were on stage when that message was produced. No-op unless the
- * soul is on, at least one emoji was added, and the target is a tracked bot
- * message.
- */
-export function recordReactionToBot(
-  chatId: string | number,
-  msgId: number,
-  addedEmojis: readonly string[],
-): boolean {
-  if (!getSoul().enabled) return false;
-  if (addedEmojis.length === 0) return false;
-  if (!isBotMessage(chatId, msgId)) return false;
-  for (const emoji of addedEmojis) getSoul().recordReaction(emoji);
-  log("soul", `reaction ${addedEmojis.join(" ")} on bot msg ${msgId}`);
-  return true;
-}
-
-// ── Directive / correction tap ───────────────────────────────────────────────
-
-/**
- * High-precision cues that a message is a *correction* of Talon's behavior. Kept
- * tight on purpose: a false positive penalizes whatever values were on stage, so
- * we would rather miss a soft correction than mislabel ordinary chat.
- */
-const CORRECTION_PATTERNS: readonly RegExp[] = [
-  /^\s*(no|nope|nah)\b[\s,.!:-]/i,
-  /\bthat'?s (wrong|incorrect|not (right|correct)|false)\b/i,
-  /\b(you'?re|you are) wrong\b/i,
-  /\bnot what i (asked|meant|wanted|said)\b/i,
-  /\bnever (do|say) that( again)?\b/i,
-  /\b(stop|quit) (doing|saying) that\b/i,
-  /\bwrong[\s,.!]/i,
-  /\byou (messed|screwed|fucked) (that|this|it)? ?up\b/i,
-];
-
-/**
- * High-precision cues that a message is a *directive* about how to be — a
- * standing instruction rather than a one-off request. These are stored verbatim
- * as evidence, so again we favor precision over recall.
- */
-const DIRECTIVE_PATTERNS: readonly RegExp[] = [
-  /\bfrom now on\b/i,
-  /\bgoing forward\b/i,
-  /\bin (the )?future\b/i,
-  /\byou should (always|never)\b/i,
-  /\b(always|never) (do|say|reply|respond|answer|use|be|call|check)\b/i,
-  /\bi (want|need|'?d like) you to\b/i,
-  /\bmake sure (you|to|that)\b/i,
-  /\bremember to\b/i,
-];
-
-export type MessageClass = "directive" | "correction" | null;
-
-/**
- * Classify a single inbound message. Returns "correction" or "directive" when a
- * cue matches, else null. Corrections are checked first because a correction is
- * the more specific (and more consequential) signal. Very long messages are
- * skipped — standing instructions and corrections are terse.
- */
-export function classifyMessage(text: string): MessageClass {
-  const t = text.trim();
-  if (t.length === 0 || t.length > 500) return null;
-  if (CORRECTION_PATTERNS.some((re) => re.test(t))) return "correction";
-  if (DIRECTIVE_PATTERNS.some((re) => re.test(t))) return "directive";
-  return null;
-}
-
-/**
- * Feed an inbound message to the kernel if it is addressed to Talon and reads as
- * a directive or correction. Returns the class recorded (or null). No-op unless
- * the soul is on.
- */
-export function recordMessageSignal(opts: {
-  readonly text: string;
-  readonly actor?: string;
-  readonly addressedToBot: boolean;
-}): MessageClass {
-  if (!getSoul().enabled) return null;
-  if (!opts.addressedToBot) return null;
-  const cls = classifyMessage(opts.text);
-  const text = opts.text.trim();
-  if (cls === "correction") {
-    getSoul().recordCorrection(text, opts.actor);
-    log("soul", `correction recorded from ${opts.actor ?? "user"}`);
-  } else if (cls === "directive") {
-    getSoul().recordDirective(text, opts.actor);
-    log("soul", `directive recorded from ${opts.actor ?? "user"}`);
-  }
-  return cls;
-}

package/src/core/soul/types.ts

@@ -1,298 +0,0 @@
-/**
- * Soul Kernel — core type system.
- *
- * The Soul is Talon's compiled identity: a content-addressed Merkle DAG of
- * typed nodes, layered with mutable "activation state" (salience, evidence
- * weights) that changes with experience. The reasoning model never *writes*
- * this structure — it is compiled mechanically from behavioral telemetry and a
- * frozen local embedder, then *read* by the model at runtime.
- *
- * The single most important design decision lives here: the split between
- * IMMUTABLE CONTENT and MUTABLE STATE.
- *
- *   - Content  — a node's semantic identity: its kind, its verbatim payload,
- *                and the hashes of the nodes it structurally references. This
- *                is what gets hashed; the hash IS the node's identity. Content
- *                never changes — a change of content is, by definition, a new
- *                node.
- *
- *   - State    — salience, accumulated evidence weight, activation counts,
- *                timestamps. This churns every tick. It is keyed BY the content
- *                hash and lives outside the Merkle structure, so reinforcing a
- *                value a thousand times does not churn a single content hash.
- *
- * Consequence: the structural root hash versions *what Talon is made of*
- * (git-like), while salience is the "weather" layered on top. Rollback,
- * provenance, and dedup fall out of the content layer; learning and decay live
- * in the state layer.
- */
-
-/** A content address: lowercase hex sha-256, prefixed. e.g. "sha256:ab12…". */
-export type Hash = string & { readonly __brand: "SoulHash" };
-
-/** The kinds of node the kernel can hold. */
-export type NodeKind =
-  | "evidence" // a verbatim ground-truth fragment — the atoms
-  | "value" // an emergent cluster of evidence (a trait/value)
-  | "theme" // a higher-order reflection over co-activating, coherent values
-  | "spine" // an append-only developmental-narrative event
-  | "reflex" // a compiled behavioral rule (trigger → guard → action)
-  | "lens"; // a per-relationship refraction of identity
-
-// ── Node payloads (the hashed content) ───────────────────────────────────────
-
-/**
- * Where a piece of ground truth came from. Provenance is content, not metadata:
- * an evidence node's identity includes *who said it, when, and where*.
- */
-interface EvidenceSource {
-  /** Origin channel: a chat correction, a logged event, a diary line, etc. */
-  readonly origin:
-    | "correction" // someone (usually Dylan) corrected behavior
-    | "directive" // an explicit instruction about how to be
-    | "event" // something that happened
-    | "reaction" // an emoji / engagement signal rendered to text
-    | "diary" // a self-written reflection (still ground truth: it was written)
-    | "seed"; // hand-seeded at genesis from identity.md / About Me
-  /** Free-form locator, e.g. "telegram:msg:4360" or "memory.md#about-me". */
-  readonly ref?: string;
-  /** Who produced the ground truth, if known (e.g. "dylan"). */
-  readonly actor?: string;
-}
-
-/** A verbatim fragment of ground truth. The kernel never paraphrases these. */
-export interface EvidencePayload {
-  readonly kind: "evidence";
-  /** The exact text. Never generated, never rewritten. */
-  readonly text: string;
-  /** When the ground truth was observed (unix ms). Part of identity. */
-  readonly observedAt: number;
-  readonly source: EvidenceSource;
-}
-
-/**
- * An emergent value/trait. Not authored — discovered by clustering evidence
- * embeddings. Its "label" is the medoid: the single most central *real*
- * evidence fragment, never generated prose.
- */
-export interface ValuePayload {
-  readonly kind: "value";
-  /** Hashes of the evidence nodes in this cluster (sorted, deduped). */
-  readonly members: readonly Hash[];
-  /** The medoid evidence node — the representative real sentence. */
-  readonly medoid: Hash;
-  /**
-   * Optional axis this value sits on, for tension detection. Discovered, not
-   * authored — two values on the same axis with high embedding distance but
-   * frequent co-activation form a tension edge.
-   */
-  readonly axis?: string;
-}
-
-/**
- * A higher-order reflection: an abstraction over values that are both
- * semantically coherent and frequently co-active. The soul's "higher-level
- * inferences over time" (Generative Agents). Structure is discovered
- * mechanically; the optional `insight` is the ONE place a single gated model
- * pass may write a natural-language label — it can never change which values are
- * grouped, and falls back to the medoid evidence when absent.
- */
-export interface ThemePayload {
-  readonly kind: "theme";
-  /** The value-node hashes this theme abstracts over (sorted, deduped). */
-  readonly values: readonly Hash[];
-  /** Representative real evidence fragment across all member values. */
-  readonly medoid: Hash;
-  /** Optional model-written label; absent ⇒ the medoid text is used. */
-  readonly insight?: string;
-}
-
-/**
- * An append-only developmental-narrative event: the *causal story* of how
- * Talon became Talon. Never rewritten, only appended. Gives continuity of self
- * across resets and model swaps.
- */
-export interface SpinePayload {
-  readonly kind: "spine";
-  /** What happened, verbatim where possible. */
-  readonly event: string;
-  readonly at: number;
-  /** Nodes this event created or reweighted — the causal links. */
-  readonly affects: readonly Hash[];
-  /** Prior spine node, forming the narrative chain (genesis = undefined). */
-  readonly prev?: Hash;
-}
-
-/** Severity of a reflex when its guard trips. */
-export type ReflexSeverity = "block" | "warn" | "advise";
-
-/**
- * A compiled behavioral rule. The genuinely model-free, *enforceable* core:
- * load-bearing rules become `trigger → guard → action`, checked by the harness,
- * not merely hoped-for from the prompt. Trigger/guard reference a registry of
- * named predicates (see reflex.ts) so they stay pure data, not code.
- */
-export interface ReflexPayload {
-  readonly kind: "reflex";
-  /** Stable human name, e.g. "RULE-0-DELIVERY". */
-  readonly name: string;
-  /** Named predicate that arms the rule. */
-  readonly trigger: string;
-  /** Named predicate that, when true under trigger, fires the action. */
-  readonly guard: string;
-  /** What to do when it fires. */
-  readonly action: string;
-  readonly severity: ReflexSeverity;
-}
-
-/**
- * A per-relationship refraction. Identity is not global — it shows up
- * differently per interlocutor. A lens is a *selection + reweighting*, never
- * generated text: which values amplify, which reflexes tighten, which evidence
- * applies for this person.
- */
-export interface LensPayload {
-  readonly kind: "lens";
-  /** Subject identifier, e.g. "dylan". */
-  readonly subject: string;
-  /** Value-node hashes to amplify for this subject, with multipliers. */
-  readonly amplify: readonly { readonly node: Hash; readonly factor: number }[];
-  /** Evidence specific to this relationship. */
-  readonly evidence: readonly Hash[];
-}
-
-export type NodePayload =
-  | EvidencePayload
-  | ValuePayload
-  | ThemePayload
-  | SpinePayload
-  | ReflexPayload
-  | LensPayload;
-
-/** A node = its hashed content. State lives separately (see ActivationState). */
-export interface SoulNode {
-  readonly hash: Hash;
-  readonly payload: NodePayload;
-}
-
-// ── Associative edges (mutable state, NOT hashed) ────────────────────────────
-
-export type EdgeKind =
-  | "coactivation" // Hebbian: fired together in a successful interaction
-  | "tension" // opposed values frequently co-active (navigated, not resolved)
-  | "supersedes"; // one node mechanically overrode another
-
-export interface AssocEdge {
-  readonly from: Hash;
-  readonly to: Hash;
-  readonly kind: EdgeKind;
-  /** Learned weight (counts / EMA). Mutable — never part of any content hash. */
-  weight: number;
-  updatedAt: number;
-}
-
-// ── Activation state (mutable, keyed by node hash) ───────────────────────────
-
-/**
- * The "weather" over a node. Reinforced on activation, decayed by time. Drives
- * projection priority. Crucially separate from content so learning never churns
- * the Merkle structure.
- */
-export interface ActivationState {
-  /** EMA salience in [0, ∞); decays toward 0 without activation. */
-  salience: number;
-  /**
-   * Net evidence weight: positive when behavior expressing this node earns
-   * positive signals, negative when it earns corrections. Drives confidence.
-   */
-  evidence: number;
-  /** Number of times activated. */
-  activations: number;
-  /** Last activation (unix ms) — used by the decay clock. */
-  lastActivatedAt: number;
-  /**
-   * Optional FSRS/DSR memory stability (ms-scale time constant). Present only
-   * under adaptive forgetting; grows with successful recall so well-established
-   * traits decay slowly and transients fade fast. When absent, decay is the
-   * fixed-half-life exponential.
-   */
-  stability?: number;
-}
-
-// ── Commits (the version chain) ──────────────────────────────────────────────
-
-/**
- * A snapshot of identity. Mirrors git: a structural root plus a parent link,
- * plus a digest of the mutable state at commit time (so a rollback restores both
- * structure and weather). Commits form the identity's history.
- */
-export interface SoulCommit {
-  /** Merkle root over all structural content at this version. */
-  readonly root: Hash;
-  /** Digest of the activation/edge state captured with this commit. */
-  readonly stateDigest: Hash;
-  readonly parent?: Hash;
-  readonly at: number;
-  /** Templated, human-readable summary of what changed (never model-written). */
-  readonly summary: string;
-}
-
-/** Default kernel tuning. Pure numbers — the whole "compiler" is arithmetic. */
-export interface SoulConfig {
-  /** Salience reinforcement increment per activation. */
-  readonly reinforce: number;
-  /** Multiplicative decay applied per decay-clock tick. */
-  readonly decay: number;
-  /** Half-life of the decay clock in ms (informational; see salience.ts). */
-  readonly decayHalfLifeMs: number;
-  /**
-   * Per-kind decay half-life overrides (ms). Kinds without an entry fall back
-   * to `decayHalfLifeMs`. `Number.POSITIVE_INFINITY` disables decay for a kind
-   * entirely. The three node families have different temporal properties:
-   * reflexes are deliberately seeded behavioral blockers — correct by
-   * definition, they must never soften with disuse; evidence (corrections)
-   * should fade naturally; spine causal links are context-specific and should
-   * go stale faster than traits. See `halfLifeForKind`.
-   */
-  readonly decayHalfLifeByKindMs?: Partial<Record<NodeKind, number>>;
-  /** Hebbian edge increment per co-activation. */
-  readonly hebbIncrement: number;
-  /** Cosine distance above which two embeddings are "different". */
-  readonly clusterDistance: number;
-  /** Distance from core centroid above which a mutation is "drift". */
-  readonly driftThreshold: number;
-  /** Token budget for the runtime projection surface. */
-  readonly runtimeBudgetTokens: number;
-  /**
-   * When true, use FSRS/DSR adaptive forgetting (per-node stability that grows
-   * with recall) instead of fixed-half-life exponential decay. Default false to
-   * preserve the simple baseline.
-   */
-  readonly adaptiveForgetting?: boolean;
-}
-
-export const DEFAULT_SOUL_CONFIG: SoulConfig = {
-  reinforce: 1,
-  decay: 0.98,
-  decayHalfLifeMs: 1000 * 60 * 60 * 24 * 7, // one week
-  decayHalfLifeByKindMs: {
-    reflex: Number.POSITIVE_INFINITY, // behavioral blockers never soften
-    spine: 1000 * 60 * 60 * 24 * 3.5, // causal links go stale faster than traits
-  },
-  hebbIncrement: 1,
-  clusterDistance: 0.35,
-  driftThreshold: 0.55,
-  runtimeBudgetTokens: 1200,
-};
-
-/**
- * Effective decay half-life for a node kind: the per-kind override when one is
- * configured, otherwise the base `decayHalfLifeMs`. `Number.POSITIVE_INFINITY`
- * means the kind never decays. Callers that don't know the kind (or operate on
- * mixed sets) may omit it and get the base rate.
- */
-export function halfLifeForKind(cfg: SoulConfig, kind?: NodeKind): number {
-  const override =
-    kind === undefined ? undefined : cfg.decayHalfLifeByKindMs?.[kind];
-  return override ?? cfg.decayHalfLifeMs;
-}

package/src/core/soul/valence.ts

@@ -1,83 +0,0 @@
-/**
- * Soul Kernel — learned valence.
- *
- * Hardcoding "👍 = +1" is exactly the kind of over-programming the soul should
- * outgrow. What a cue *means* is not a constant — it is whatever outcome reliably
- * follows it. So valence is learned: when an interaction's downstream engagement
- * resolves (the conversation continued, or died), every categorical cue that
- * preceded it (the emoji used, say) is nudged toward that outcome. Over time the
- * model discovers, from Talon's own data, that 👍 tends to precede continuation
- * and 👎 tends to precede silence — or whatever is actually true here, which may
- * differ from the prior.
- *
- * A weak prior (the old static table) seeds cold-start so early behavior is
- * sane, but evidence overrides it: the effective valence is a count-weighted
- * blend that converges to the observed mean as observations accumulate.
- */
-
-import { emojiValence } from "./signals.js";
-
-interface CueStat {
-  sum: number;
-  count: number;
-}
-
-export interface ValenceSnapshot {
-  readonly priorWeight: number;
-  readonly stats: readonly (readonly [string, CueStat])[];
-}
-
-export class ValenceModel {
-  private readonly stats = new Map<string, CueStat>();
-
-  /**
-   * @param prior       cold-start valence for an unseen cue (default: the old
-   *                    emoji table — a fading prior, not a rule).
-   * @param priorWeight pseudo-count for the prior; evidence dominates past it.
-   */
-  constructor(
-    private readonly prior: (cue: string) => number = emojiValence,
-    private readonly priorWeight = 2,
-  ) {}
-
-  /** Record that `cue` was followed by `outcome` (e.g. +1 continued, -1 died). */
-  observe(cue: string, outcome: number): void {
-    const s = this.stats.get(cue) ?? { sum: 0, count: 0 };
-    s.sum += outcome;
-    s.count += 1;
-    this.stats.set(cue, s);
-  }
-
-  /**
-   * Effective learned valence: a count-weighted blend of the prior and the
-   * observed mean. With no observations it equals the prior; as observations
-   * accumulate it converges to sum/count.
-   */
-  valence(cue: string): number {
-    const s = this.stats.get(cue);
-    const p = this.prior(cue);
-    if (!s || s.count === 0) return p;
-    return (this.priorWeight * p + s.sum) / (this.priorWeight + s.count);
-  }
-
-  /** How much evidence backs a cue (0 = pure prior). */
-  confidence(cue: string): number {
-    return this.stats.get(cue)?.count ?? 0;
-  }
-
-  snapshot(): ValenceSnapshot {
-    return {
-      priorWeight: this.priorWeight,
-      stats: [...this.stats.entries()].map(([k, v]) => [k, { ...v }]),
-    };
-  }
-
-  static restore(
-    snap: ValenceSnapshot,
-    prior: (cue: string) => number = emojiValence,
-  ): ValenceModel {
-    const model = new ValenceModel(prior, snap.priorWeight);
-    for (const [cue, stat] of snap.stats) model.stats.set(cue, { ...stat });
-    return model;
-  }
-}