talon-agent 4.6.0 → 5.0.0

package/src/core/soul/critic.ts

@@ -1,162 +0,0 @@
-/**
- * Soul Kernel — the Critic. A self-model of failure modes, made mechanical.
- *
- * In v3 the Critic is not a reasoning model second-guessing the first; it is a
- * set of frozen, feature-based classifiers. Each scores a candidate text (a
- * drafted reply, or a projection surface) against one of Talon's documented
- * failure modes — wall-of-text, sycophancy, emoji-overload — using a linear
- * combination of cheap lexical/structural features and a fixed threshold. A
- * classifier is a fixed function, not an agent, so this stays strictly within
- * the model-free principle.
- *
- * Embedding-based gates (contradiction against the KG, drift from the core
- * centroid) are a later phase; they too are distance comparisons, not model
- * calls. The lexical classifiers here are the immediately-useful, fully
- * dependency-free core.
- */
-
-import { estimateTokens } from "./projector.js";
-
-type FailureMode = "wall-of-text" | "sycophancy" | "emoji-overload";
-
-export interface CritiqueFeatures {
-  readonly tokens: number;
-  readonly sentences: number;
-  /** Hedging phrases per 100 tokens. */
-  readonly hedgeRate: number;
-  /** Emoji characters per 100 tokens. */
-  readonly emojiDensity: number;
-  /** Count of sycophancy-lexicon hits. */
-  readonly sycophancyHits: number;
-}
-
-export interface Critique {
-  readonly mode: FailureMode;
-  /** Continuous severity; >= 1 means the fixed threshold was crossed. */
-  readonly score: number;
-  readonly flagged: boolean;
-  readonly reason: string;
-}
-
-const HEDGES = [
-  "i think",
-  "i guess",
-  "maybe",
-  "perhaps",
-  "sort of",
-  "kind of",
-  "i suppose",
-  "probably",
-  "it seems",
-];
-
-const SYCOPHANCY = [
-  "great question",
-  "excellent question",
-  "you're absolutely right",
-  "you are absolutely right",
-  "i'd be happy to",
-  "i would be happy to",
-  "absolutely!",
-  "certainly!",
-  "of course!",
-  "happy to help",
-  "great point",
-];
-
-// Emoji detection without a heavy dependency: pictographic + symbol ranges.
-const EMOJI_RE =
-  // Variation selectors are combining marks — alternated separately so the
-  // character class holds only standalone pictographic ranges
-  // (no-misleading-character-class).
-  /[\u{1F300}-\u{1FAFF}\u{2600}-\u{27BF}\u{2190}-\u{21FF}\u{2B00}-\u{2BFF}\u{1F000}-\u{1F0FF}]|[\u{FE00}-\u{FE0F}]/gu;
-
-function countOccurrences(
-  haystack: string,
-  needles: readonly string[],
-): number {
-  let n = 0;
-  for (const needle of needles) {
-    let from = 0;
-    for (;;) {
-      const i = haystack.indexOf(needle, from);
-      if (i === -1) break;
-      n++;
-      from = i + needle.length;
-    }
-  }
-  return n;
-}
-
-/** Extract the cheap features the classifiers run over. Pure + deterministic. */
-export function extractFeatures(text: string): CritiqueFeatures {
-  const lower = text.toLowerCase();
-  const tokens = Math.max(1, estimateTokens(text));
-  const sentences = Math.max(1, (text.match(/[.!?](\s|$)/g) ?? []).length);
-  const emoji = (text.match(EMOJI_RE) ?? []).length;
-  const hedges = countOccurrences(lower, HEDGES);
-  return {
-    tokens,
-    sentences,
-    hedgeRate: (hedges / tokens) * 100,
-    emojiDensity: (emoji / tokens) * 100,
-    sycophancyHits: countOccurrences(lower, SYCOPHANCY),
-  };
-}
-
-export interface CritiqueThresholds {
-  /** Token count above which prose is "wall-of-text". */
-  readonly maxTokens: number;
-  /** Sycophancy score (hits + hedge contribution) threshold. */
-  readonly maxSycophancy: number;
-  /** Emoji-per-100-tokens threshold. */
-  readonly maxEmojiDensity: number;
-}
-
-export const DEFAULT_THRESHOLDS: CritiqueThresholds = {
-  maxTokens: 320,
-  maxSycophancy: 1,
-  maxEmojiDensity: 6,
-};
-
-/**
- * Run the frozen classifiers over a candidate text. Returns one critique per
- * failure mode; `flagged` is true when its normalized score reaches 1.
- */
-export function critique(
-  text: string,
-  thresholds: CritiqueThresholds = DEFAULT_THRESHOLDS,
-): Critique[] {
-  const f = extractFeatures(text);
-
-  const sycophancyScore = f.sycophancyHits + f.hedgeRate / 5;
-  const wall = f.tokens / thresholds.maxTokens;
-  const syco = sycophancyScore / Math.max(0.0001, thresholds.maxSycophancy);
-  const emoji = f.emojiDensity / Math.max(0.0001, thresholds.maxEmojiDensity);
-
-  return [
-    {
-      mode: "wall-of-text",
-      score: wall,
-      flagged: wall >= 1,
-      reason: `${f.tokens} tokens vs budget ${thresholds.maxTokens}`,
-    },
-    {
-      mode: "sycophancy",
-      score: syco,
-      flagged: syco >= 1,
-      reason: `${f.sycophancyHits} sycophancy hits, hedge ${f.hedgeRate.toFixed(1)}/100tok`,
-    },
-    {
-      mode: "emoji-overload",
-      score: emoji,
-      flagged: emoji >= 1,
-      reason: `${f.emojiDensity.toFixed(1)} emoji/100tok vs ${thresholds.maxEmojiDensity}`,
-    },
-  ];
-}
-
-/** True if any failure mode tripped its threshold. */
-export function isFlagged(critiques: readonly Critique[]): boolean {
-  return critiques.some((c) => c.flagged);
-}

package/src/core/soul/dag.ts

@@ -1,265 +0,0 @@
-/**
- * Soul Kernel — the content-addressed DAG store.
- *
- * Holds three things, kept rigorously separate:
- *
- *   1. Nodes   — immutable, content-addressed identity content (the Merkle DAG).
- *   2. State   — mutable per-node "weather" (salience, evidence weight).
- *   3. Edges   — mutable associative links (Hebbian co-activation, tension).
- *
- * Referential integrity is enforced on insert: a node may only reference child
- * hashes that already exist, so the DAG can never contain a dangling pointer and
- * the Merkle root is always sound.
- *
- * Dirty-tracking is structural and underpins "partial recompilation": only the
- * nodes added or whose state mutated since the last commit are reported dirty, so
- * downstream consumers (projector, critic) reprocess a handful of nodes, not the
- * whole self.
- */
-
-import { hashPayload, merkleRoot } from "./hash.js";
-import type {
-  ActivationState,
-  AssocEdge,
-  EdgeKind,
-  Hash,
-  NodePayload,
-  SoulNode,
-} from "./types.js";
-
-/** The structural (hashed) children a payload references, by kind. */
-export function structuralChildren(payload: NodePayload): Hash[] {
-  switch (payload.kind) {
-    case "evidence":
-    case "reflex":
-      return [];
-    case "value":
-      return dedupe([payload.medoid, ...payload.members]);
-    case "theme":
-      return dedupe([payload.medoid, ...payload.values]);
-    case "spine":
-      return dedupe([
-        ...payload.affects,
-        ...(payload.prev ? [payload.prev] : []),
-      ]);
-    case "lens":
-      return dedupe([
-        ...payload.amplify.map((a) => a.node),
-        ...payload.evidence,
-      ]);
-  }
-}
-
-function dedupe(hashes: Hash[]): Hash[] {
-  return [...new Set(hashes)];
-}
-
-function freshState(now: number): ActivationState {
-  return { salience: 0, evidence: 0, activations: 0, lastActivatedAt: now };
-}
-
-/** Edge map key — one edge per (from, kind, to) triple. */
-function edgeKey(from: Hash, kind: EdgeKind, to: Hash): string {
-  return `${from}|${kind}|${to}`;
-}
-
-export interface DagSnapshot {
-  readonly nodes: readonly SoulNode[];
-  readonly state: readonly (readonly [Hash, ActivationState])[];
-  readonly edges: readonly AssocEdge[];
-}
-
-export class SoulDag {
-  private readonly nodes = new Map<Hash, SoulNode>();
-  private readonly state = new Map<Hash, ActivationState>();
-  private readonly edges = new Map<string, AssocEdge>();
-  /** Reverse adjacency for structural children → parents, for dirty propagation. */
-  private readonly parents = new Map<Hash, Set<Hash>>();
-  private readonly dirty = new Set<Hash>();
-
-  // ── Nodes ──────────────────────────────────────────────────────────────────
-
-  /**
-   * Insert a node by content. Idempotent: identical content returns the same
-   * hash and does not re-dirty. Throws if any structural child is absent.
-   */
-  addNode(payload: NodePayload, now = Date.now()): Hash {
-    const hash = hashPayload(payload);
-    if (this.nodes.has(hash)) return hash;
-
-    const children = structuralChildren(payload);
-    for (const child of children) {
-      if (!this.nodes.has(child)) {
-        throw new Error(
-          `SoulDag.addNode: dangling reference ${child} from ${payload.kind} node`,
-        );
-      }
-    }
-
-    this.nodes.set(hash, { hash, payload });
-    this.state.set(hash, freshState(now));
-    for (const child of children) {
-      let set = this.parents.get(child);
-      if (!set) {
-        set = new Set();
-        this.parents.set(child, set);
-      }
-      set.add(hash);
-    }
-    this.dirty.add(hash);
-    return hash;
-  }
-
-  getNode(hash: Hash): SoulNode | undefined {
-    return this.nodes.get(hash);
-  }
-
-  hasNode(hash: Hash): boolean {
-    return this.nodes.has(hash);
-  }
-
-  /** All node hashes of a given kind. */
-  nodesOfKind(kind: NodePayload["kind"]): SoulNode[] {
-    const out: SoulNode[] = [];
-    for (const node of this.nodes.values()) {
-      if (node.payload.kind === kind) out.push(node);
-    }
-    return out;
-  }
-
-  get size(): number {
-    return this.nodes.size;
-  }
-
-  // ── State ──────────────────────────────────────────────────────────────────
-
-  /** Mutable activation state for a node (lazily created). */
-  stateOf(hash: Hash): ActivationState {
-    let s = this.state.get(hash);
-    if (!s) {
-      s = freshState(Date.now());
-      this.state.set(hash, s);
-    }
-    return s;
-  }
-
-  /** Mark a node (and its structural ancestors) dirty after a state change. */
-  touch(hash: Hash): void {
-    if (!this.nodes.has(hash)) return;
-    this.dirty.add(hash);
-  }
-
-  // ── Edges ──────────────────────────────────────────────────────────────────
-
-  /** Create or fetch the edge for a triple; weight starts at 0. */
-  edge(from: Hash, kind: EdgeKind, to: Hash, now = Date.now()): AssocEdge {
-    const key = edgeKey(from, kind, to);
-    let e = this.edges.get(key);
-    if (!e) {
-      e = { from, to, kind, weight: 0, updatedAt: now };
-      this.edges.set(key, e);
-    }
-    return e;
-  }
-
-  getEdge(from: Hash, kind: EdgeKind, to: Hash): AssocEdge | undefined {
-    return this.edges.get(edgeKey(from, kind, to));
-  }
-
-  /** All edges originating at `from`, optionally filtered by kind. */
-  edgesFrom(from: Hash, kind?: EdgeKind): AssocEdge[] {
-    const out: AssocEdge[] = [];
-    for (const e of this.edges.values()) {
-      if (e.from === from && (!kind || e.kind === kind)) out.push(e);
-    }
-    return out;
-  }
-
-  /** Every edge in the graph, optionally filtered by kind. */
-  allEdges(kind?: EdgeKind): AssocEdge[] {
-    const out: AssocEdge[] = [];
-    for (const e of this.edges.values()) {
-      if (!kind || e.kind === kind) out.push(e);
-    }
-    return out;
-  }
-
-  // ── Structure ────────────────────────────────────────────────────────────────
-
-  childrenOf(hash: Hash): Hash[] {
-    const node = this.nodes.get(hash);
-    return node ? structuralChildren(node.payload) : [];
-  }
-
-  parentsOf(hash: Hash): Hash[] {
-    return [...(this.parents.get(hash) ?? [])];
-  }
-
-  /** Merkle root over the full set of node content present. The version id. */
-  root(): Hash {
-    return merkleRoot(this.nodes.keys());
-  }
-
-  // ── Dirty-tracking ───────────────────────────────────────────────────────────
-
-  /** Nodes added or touched since the last clear, plus their ancestors. */
-  dirtySet(): Set<Hash> {
-    const out = new Set<Hash>();
-    const stack = [...this.dirty];
-    while (stack.length) {
-      const h = stack.pop()!;
-      if (out.has(h)) continue;
-      out.add(h);
-      for (const parent of this.parents.get(h) ?? []) stack.push(parent);
-    }
-    return out;
-  }
-
-  clearDirty(): void {
-    this.dirty.clear();
-  }
-
-  // ── Serialization ────────────────────────────────────────────────────────────
-
-  snapshot(): DagSnapshot {
-    return {
-      nodes: [...this.nodes.values()],
-      state: [...this.state.entries()].map(([h, s]) => [h, { ...s }]),
-      edges: [...this.edges.values()].map((e) => ({ ...e })),
-    };
-  }
-
-  /**
-   * Rebuild a DAG from a snapshot. Nodes are re-inserted in dependency order so
-   * referential integrity is re-verified on load (a corrupt snapshot throws
-   * rather than silently producing a broken graph).
-   */
-  static restore(snap: DagSnapshot): SoulDag {
-    const dag = new SoulDag();
-    const byHash = new Map(snap.nodes.map((n) => [n.hash, n]));
-    const inserted = new Set<Hash>();
-
-    const insert = (node: SoulNode): void => {
-      if (inserted.has(node.hash)) return;
-      for (const child of structuralChildren(node.payload)) {
-        const childNode = byHash.get(child);
-        if (!childNode) {
-          throw new Error(`SoulDag.restore: snapshot missing child ${child}`);
-        }
-        insert(childNode);
-      }
-      dag.addNode(node.payload);
-      inserted.add(node.hash);
-    };
-    for (const node of snap.nodes) insert(node);
-
-    for (const [hash, s] of snap.state) {
-      if (dag.nodes.has(hash)) dag.state.set(hash, { ...s });
-    }
-    for (const e of snap.edges) {
-      dag.edges.set(edgeKey(e.from, e.kind, e.to), { ...e });
-    }
-    dag.clearDirty();
-    return dag;
-  }
-}

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