talon-agent 4.6.0 → 5.0.0

package/src/core/soul/lens.ts

@@ -1,110 +0,0 @@
-/**
- * Soul Kernel — relational holograph (lens compilation).
- *
- * Identity is not global; it is refracted per interlocutor. A lens is the
- * refraction for one subject: which values to amplify and which evidence is
- * specific to that relationship. It is compiled MECHANICALLY — no model decides
- * how Talon shows up with Dylan vs. a stranger; the evidence does.
- *
- * The signal is provenance: evidence carries `source.actor`. A value that is
- * disproportionately built from a subject's evidence is amplified for that
- * subject, by a factor proportional to how much of the value is "theirs". The
- * lens also carries the subject-specific evidence verbatim.
- *
- * Re-compiling supersedes the prior lens for the same subject (a `supersedes`
- * edge), so exactly one live lens per subject survives — and superseded lenses
- * fall out of projection like any other superseded node.
- */
-
-import { isSuperseded } from "./consolidate.js";
-import type { SoulDag } from "./dag.js";
-import type { EvidencePayload, Hash, ValuePayload } from "./types.js";
-
-export interface LensOptions {
-  readonly now: number;
-  /** Max amplification boost for a fully subject-owned value (default 2). */
-  readonly boost?: number;
-  /** Cap on the number of subject-evidence fragments carried (default 12). */
-  readonly maxEvidence?: number;
-}
-
-function actorOf(dag: SoulDag, evidence: Hash): string | undefined {
-  const node = dag.getNode(evidence);
-  return node?.payload.kind === "evidence"
-    ? (node.payload as EvidencePayload).source.actor
-    : undefined;
-}
-
-/** Live lens node for a subject, if one exists. */
-export function liveLens(dag: SoulDag, subject: string): Hash | undefined {
-  for (const node of dag.nodesOfKind("lens")) {
-    if (
-      node.payload.kind === "lens" &&
-      node.payload.subject === subject &&
-      !isSuperseded(dag, node.hash)
-    ) {
-      return node.hash;
-    }
-  }
-  return undefined;
-}
-
-/**
- * Compile (or recompile) the lens for a subject from actor-tagged evidence.
- * Returns the lens hash, or undefined if the subject has no evidence. Caller
- * commits.
- */
-export function compileLens(
-  dag: SoulDag,
-  subject: string,
-  opts: LensOptions,
-): Hash | undefined {
-  const boost = opts.boost ?? 2;
-  const maxEvidence = opts.maxEvidence ?? 12;
-
-  // Subject-specific evidence.
-  const subjectEvidence = dag
-    .nodesOfKind("evidence")
-    .filter((n) => actorOf(dag, n.hash) === subject)
-    .map((n) => n.hash);
-  if (subjectEvidence.length === 0) return undefined;
-  const subjectSet = new Set(subjectEvidence);
-
-  // Amplify values built disproportionately from the subject's evidence.
-  const amplify: { node: Hash; factor: number }[] = [];
-  for (const node of dag.nodesOfKind("value")) {
-    if (isSuperseded(dag, node.hash)) continue;
-    const value = node.payload as ValuePayload;
-    const members = value.members.length ? value.members : [value.medoid];
-    const owned = members.filter((m) => subjectSet.has(m)).length;
-    if (owned === 0) continue;
-    const factor = 1 + boost * (owned / members.length);
-    amplify.push({ node: node.hash, factor });
-  }
-
-  const evidence = [...subjectEvidence].sort().slice(0, maxEvidence);
-  const lens = dag.addNode(
-    {
-      kind: "lens",
-      subject,
-      amplify: amplify.sort((a, b) => a.node.localeCompare(b.node)),
-      evidence,
-    },
-    opts.now,
-  );
-
-  // Supersede any prior live lens for this subject.
-  for (const node of dag.nodesOfKind("lens")) {
-    if (
-      node.hash !== lens &&
-      node.payload.kind === "lens" &&
-      node.payload.subject === subject &&
-      !isSuperseded(dag, node.hash)
-    ) {
-      const e = dag.edge(lens, "supersedes", node.hash, opts.now);
-      e.weight = 1;
-      e.updatedAt = opts.now;
-    }
-  }
-  return lens;
-}

package/src/core/soul/projector.ts

@@ -1,240 +0,0 @@
-/**
- * Soul Kernel — the projector. Compiles the DAG to the runtime surface that is
- * injected into the system prompt.
- *
- * The defining constraint: the projector **selects**, it never **writes**. Every
- * substantive line is a verbatim evidence fragment already in the DAG (the
- * medoid of a value, a spine event, a lens-scoped quote). The only generated
- * text is fixed structural scaffolding — section headers and the action strings
- * of reflexes, which are themselves authored data, not claims about Talon. The
- * soul therefore cannot hallucinate itself: it can only ever quote ground truth.
- *
- * Selection is salience-ordered under a token budget, so the surface carries what
- * is *currently alive*, not everything ever true. Reflexes are exempt from the
- * budget — guarantees are never dropped.
- */
-
-import { SoulDag } from "./dag.js";
-import { isSuperseded } from "./consolidate.js";
-import { tensionPairs } from "./lattice.js";
-import { confidence, effectiveSalience } from "./salience.js";
-import type { Hash, LensPayload, SoulConfig, ValuePayload } from "./types.js";
-import { halfLifeForKind } from "./types.js";
-
-export interface ProjectionOptions {
-  readonly now: number;
-  readonly config: SoulConfig;
-  /** If set, refract the projection through this subject's lens, when present. */
-  readonly lens?: string;
-  /**
-   * Optional precomputed value ordering (e.g. from context-conditioned
-   * retrieval). When present it overrides salience ranking, letting the soul
-   * surface what is relevant to the current moment. Hashes not listed are
-   * dropped from the value section.
-   */
-  readonly order?: readonly Hash[];
-}
-
-export interface Projection {
-  readonly text: string;
-  readonly tokens: number;
-  readonly includedValues: readonly Hash[];
-  readonly droppedValues: number;
-}
-
-/** Cheap, tokenizer-free token estimate (~4 chars/token). Deterministic. */
-export function estimateTokens(text: string): number {
-  return Math.ceil(text.length / 4);
-}
-
-function evidenceText(
-  dag: SoulDag,
-  hash: Hash | undefined,
-): string | undefined {
-  if (!hash) return undefined;
-  const node = dag.getNode(hash);
-  return node?.payload.kind === "evidence" ? node.payload.text : undefined;
-}
-
-/** The medoid evidence hash of a value node, if it is one. */
-function valueMedoid(dag: SoulDag, hash: Hash): Hash | undefined {
-  const node = dag.getNode(hash);
-  return node?.payload.kind === "value"
-    ? (node.payload as ValuePayload).medoid
-    : undefined;
-}
-
-/** Map of value-hash → amplification factor for a subject's lens. */
-function lensFactors(dag: SoulDag, subject?: string): Map<Hash, number> {
-  const factors = new Map<Hash, number>();
-  if (!subject) return factors;
-  for (const node of dag.nodesOfKind("lens")) {
-    if (isSuperseded(dag, node.hash)) continue;
-    const lens = node.payload as LensPayload;
-    if (lens.subject !== subject) continue;
-    for (const a of lens.amplify) factors.set(a.node, a.factor);
-  }
-  return factors;
-}
-
-interface RankedValue {
-  readonly hash: Hash;
-  readonly medoidText: string;
-  readonly conf: number;
-  readonly weighted: number;
-}
-
-function rankValues(dag: SoulDag, opts: ProjectionOptions): RankedValue[] {
-  const factors = lensFactors(dag, opts.lens);
-  const ranked: RankedValue[] = [];
-  for (const node of dag.nodesOfKind("value")) {
-    if (isSuperseded(dag, node.hash)) continue; // merged-away values are dead
-    const value = node.payload as ValuePayload;
-    const text = evidenceText(dag, value.medoid);
-    if (!text) continue; // a value with no resolvable medoid is not projectable
-    const state = dag.stateOf(node.hash);
-    const base = effectiveSalience(
-      state,
-      opts.now,
-      halfLifeForKind(opts.config, "value"),
-    );
-    const factor = factors.get(node.hash) ?? 1;
-    ranked.push({
-      hash: node.hash,
-      medoidText: text,
-      conf: confidence(state),
-      weighted: base * factor,
-    });
-  }
-  // Highest weighted salience first; hash tiebreak keeps output deterministic.
-  ranked.sort(
-    (a, b) => b.weighted - a.weighted || a.hash.localeCompare(b.hash),
-  );
-
-  // An explicit retrieval order (context-conditioned) overrides salience rank.
-  if (opts.order) {
-    const rank = new Map(opts.order.map((h, i) => [h, i]));
-    return ranked
-      .filter((r) => rank.has(r.hash))
-      .sort((a, b) => rank.get(a.hash)! - rank.get(b.hash)!);
-  }
-  return ranked;
-}
-
-function signed(n: number): string {
-  return `${n >= 0 ? "+" : ""}${n.toFixed(2)}`;
-}
-
-/**
- * Project the kernel to its runtime markdown surface. Reflexes are always
- * included; values fill the remaining token budget by weighted salience; recent
- * spine events provide continuity with whatever budget is left.
- */
-export function projectRuntime(
-  dag: SoulDag,
-  opts: ProjectionOptions,
-): Projection {
-  const lines: string[] = [];
-  lines.push("# Talon — compiled identity (soul)");
-  lines.push(
-    `<!-- selected from ${dag.size} nodes; root ${dag.root()}; generated, do not edit -->`,
-  );
-
-  // Reflexes — enforced guarantees, never budgeted away.
-  const reflexes = dag.nodesOfKind("reflex");
-  if (reflexes.length) {
-    lines.push("", "## Reflexes (enforced)");
-    for (const r of reflexes) {
-      if (r.payload.kind !== "reflex") continue;
-      lines.push(`- **${r.payload.name}** — ${r.payload.action}`);
-    }
-  }
-
-  let budget = opts.config.runtimeBudgetTokens;
-  const spend = (s: string): boolean => {
-    const cost = estimateTokens(s);
-    if (cost > budget) return false;
-    budget -= cost;
-    return true;
-  };
-  // Reflexes already spent conceptually fixed cost; charge the header block.
-  budget -= estimateTokens(lines.join("\n"));
-
-  // Values — salience-ordered, verbatim medoids, until the budget is spent.
-  const ranked = rankValues(dag, opts);
-  const included: Hash[] = [];
-  let dropped = 0;
-  const valueLines: string[] = [];
-  for (const v of ranked) {
-    const line = `- [conf ${signed(v.conf)}] "${v.medoidText}"`;
-    if (spend(line)) {
-      valueLines.push(line);
-      included.push(v.hash);
-    } else {
-      dropped++;
-    }
-  }
-  if (valueLines.length) {
-    const header = opts.lens ? `## Values (with ${opts.lens})` : "## Values";
-    lines.push("", header, ...valueLines);
-  }
-
-  // Themes — higher-order reflections over the values.
-  const themeNodes = dag
-    .nodesOfKind("theme")
-    .map((n) => n.payload)
-    .filter(
-      (p): p is Extract<typeof p, { kind: "theme" }> => p.kind === "theme",
-    )
-    .map((p) => ({
-      label: p.insight ?? evidenceText(dag, p.medoid) ?? "",
-      salience: 0,
-      medoid: p.medoid,
-    }))
-    .filter((t) => t.label.length > 0);
-  const themeLines: string[] = [];
-  for (const t of themeNodes) {
-    const line = `- ${t.label}`;
-    if (spend(line)) themeLines.push(line);
-  }
-  if (themeLines.length)
-    lines.push("", "## Themes (reflections)", ...themeLines);
-
-  // Tensions — opposed values held together, navigated not resolved.
-  const includedSet = new Set(included);
-  const tensionLines: string[] = [];
-  for (const pair of tensionPairs(dag)) {
-    if (!includedSet.has(pair.a) || !includedSet.has(pair.b)) continue;
-    const ta = evidenceText(dag, valueMedoid(dag, pair.a));
-    const tb = evidenceText(dag, valueMedoid(dag, pair.b));
-    if (!ta || !tb) continue;
-    const line = `- "${ta}"  ⟷  "${tb}"`;
-    if (spend(line)) tensionLines.push(line);
-  }
-  if (tensionLines.length) {
-    lines.push("", "## Tensions (navigated, not resolved)", ...tensionLines);
-  }
-
-  // Continuity — most recent spine events first, with remaining budget.
-  const spine = dag
-    .nodesOfKind("spine")
-    .map((n) => n.payload)
-    .filter(
-      (p): p is Extract<typeof p, { kind: "spine" }> => p.kind === "spine",
-    )
-    .sort((a, b) => b.at - a.at);
-  const spineLines: string[] = [];
-  for (const s of spine) {
-    const line = `- ${s.event}`;
-    if (spend(line)) spineLines.push(line);
-  }
-  if (spineLines.length) lines.push("", "## Continuity (spine)", ...spineLines);
-
-  const text = lines.join("\n");
-  return {
-    text,
-    tokens: estimateTokens(text),
-    includedValues: included,
-    droppedValues: dropped,
-  };
-}

package/src/core/soul/reflect.ts

@@ -1,170 +0,0 @@
-/**
- * Soul Kernel — reflection.
- *
- * Generative Agents (Park et al., 2023) defines reflection as synthesizing
- * memories into higher-level inferences over time. Here that synthesis is
- * STRUCTURAL and model-free: the soul forms a `theme` over a group of values that
- * are both semantically coherent AND frequently co-active. "Coherent and seen
- * together" is the mechanical signature of a higher-order trait.
- *
- * Affinity between two values blends two signals already in the kernel:
- *
- *   affinity(a,b) = w · cos(medoid_a, medoid_b) + (1−w) · normalizedCoactivation
- *
- * Connected components of the "affinity ≥ threshold" graph become themes. A
- * theme's label is its medoid (a real fragment), UNLESS an optional `synthesize`
- * callback is supplied — the single, gated place a model may write a natural
- * language insight. Critically, that callback can only LABEL; it can never change
- * which values are grouped, so the model can't drift identity structure.
- */
-
-import { liveValues } from "./consolidate.js";
-import type { SoulDag } from "./dag.js";
-import { cosineSimilarity, medoidIndex, type Embedder } from "./embedder.js";
-import { effectiveSalience } from "./salience.js";
-import type { Hash, SoulConfig, ValuePayload } from "./types.js";
-import { halfLifeForKind } from "./types.js";
-
-export interface ReflectOptions {
-  readonly now: number;
-  /** Affinity threshold for grouping values into a theme (0..1). */
-  readonly affinity?: number;
-  /** Weight on the semantic term vs. the co-activation term (0..1). */
-  readonly embeddingWeight?: number;
-  /**
-   * Optional gated model label synthesizer. Receives the theme's member
-   * evidence (verbatim) and may return a short insight; returning undefined
-   * keeps the medoid label. This is the only model touch in the entire kernel,
-   * and it is label-only.
-   */
-  readonly synthesize?: (
-    members: readonly { hash: Hash; text: string }[],
-  ) => string | undefined;
-}
-
-export interface ReflectResult {
-  readonly created: Hash[];
-}
-
-function medoidText(dag: SoulDag, valueHash: Hash): string {
-  const v = dag.getNode(valueHash)?.payload as ValuePayload | undefined;
-  if (!v) return "";
-  const e = dag.getNode(v.medoid);
-  return e?.payload.kind === "evidence" ? e.payload.text : "";
-}
-
-function memberEvidence(dag: SoulDag, valueHash: Hash): Hash[] {
-  const v = dag.getNode(valueHash)?.payload as ValuePayload | undefined;
-  if (!v) return [];
-  return [v.medoid, ...v.members];
-}
-
-/**
- * Form themes over the value graph. Returns the theme hashes created. Caller
- * commits. Async because affinity embeds value medoids.
- */
-export async function reflect(
-  dag: SoulDag,
-  embedder: Embedder,
-  cfg: SoulConfig,
-  opts: ReflectOptions,
-): Promise<ReflectResult> {
-  const threshold = opts.affinity ?? 0.5;
-  const w = opts.embeddingWeight ?? 0.5;
-  const values = liveValues(dag);
-  if (values.length < 2) return { created: [] };
-
-  const reps = await embedder.embed(values.map((h) => medoidText(dag, h)));
-
-  // Normalizer for the co-activation term.
-  let maxCo = 0;
-  for (let i = 0; i < values.length; i++) {
-    for (const e of dag.edgesFrom(values[i]!, "coactivation")) {
-      maxCo = Math.max(maxCo, e.weight);
-    }
-  }
-  const coWeight = (a: Hash, b: Hash): number => {
-    if (maxCo === 0) return 0;
-    const e = dag.getEdge(a, "coactivation", b);
-    return e ? e.weight / maxCo : 0;
-  };
-
-  // Union-find over affinity edges.
-  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;
-  };
-  for (let i = 0; i < values.length; i++) {
-    for (let j = i + 1; j < values.length; j++) {
-      const sim = Math.max(0, cosineSimilarity(reps[i]!, reps[j]!));
-      const affinity = w * sim + (1 - w) * coWeight(values[i]!, values[j]!);
-      if (affinity >= threshold) parent[find(i)] = find(j);
-    }
-  }
-
-  const groups = new Map<number, number[]>();
-  for (let i = 0; i < values.length; i++) {
-    const r = find(i);
-    (groups.get(r) ?? groups.set(r, []).get(r)!).push(i);
-  }
-
-  const created: Hash[] = [];
-  for (const idxs of groups.values()) {
-    if (idxs.length < 2) continue;
-    const members = idxs.map((i) => values[i]!).sort();
-
-    // Medoid over all evidence across the member values.
-    const evidence = [
-      ...new Set(members.flatMap((v) => memberEvidence(dag, v))),
-    ];
-    const evVecs = await embedder.embed(
-      evidence.map((h) => {
-        const e = dag.getNode(h);
-        return e?.payload.kind === "evidence" ? e.payload.text : "";
-      }),
-    );
-    const medoid = evidence[medoidIndex(evVecs)]!;
-
-    const insight = opts.synthesize?.(
-      evidence.map((h) => ({
-        hash: h,
-        text:
-          dag.getNode(h)?.payload.kind === "evidence"
-            ? (dag.getNode(h)!.payload as { text: string }).text
-            : "",
-      })),
-    );
-
-    const theme = dag.addNode(
-      {
-        kind: "theme",
-        values: members,
-        medoid,
-        ...(insight ? { insight } : {}),
-      },
-      opts.now,
-    );
-    created.push(theme);
-
-    // Theme salience aggregates its members so it can be ranked/projected.
-    const st = dag.stateOf(theme);
-    st.salience = members.reduce(
-      (s, v) =>
-        s +
-        effectiveSalience(
-          dag.stateOf(v),
-          opts.now,
-          halfLifeForKind(cfg, "value"),
-        ),
-      0,
-    );
-    st.lastActivatedAt = opts.now;
-    dag.touch(theme);
-  }
-
-  return { created };
-}

package/src/core/soul/reflex.ts

@@ -1,164 +0,0 @@
-/**
- * Soul Kernel — the reflex layer. Behavior the kernel *guarantees*, not behavior
- * the prompt merely hopes to elicit.
- *
- * A reflex is pure data in the DAG (`trigger → guard → action`, content-
- * addressed and versioned). The *predicates* it names are tested code in a
- * registry here. That separation is deliberate: the data is portable, hashable,
- * and rolls back with the rest of identity; the logic is unit-tested TypeScript.
- *
- * At a decision point the harness builds a ReflexContext — a flat bag of facts
- * about the current turn — and asks the enforcer which reflexes fire. A fired
- * `block` reflex is an enforceable veto; the model never gets a vote. This is how
- * the recurring RULE 0 delivery failure stops being a recurring failure: it
- * becomes a structural guard, not a note in memory.
- */
-
-import type { ReflexPayload, ReflexSeverity } from "./types.js";
-
-/** Flat, serializable facts about a decision point. */
-export interface ReflexContext {
-  readonly facts: Readonly<Record<string, boolean | string | number>>;
-}
-
-/** A named, pure predicate over the context. */
-export type ReflexPredicate = (ctx: ReflexContext) => boolean;
-
-export interface ReflexVerdict {
-  readonly name: string;
-  readonly severity: ReflexSeverity;
-  readonly action: string;
-  /** True when both trigger and guard held — i.e. the reflex fired. */
-  readonly fired: boolean;
-}
-
-const bool = (ctx: ReflexContext, key: string): boolean =>
-  ctx.facts[key] === true;
-
-const str = (ctx: ReflexContext, key: string): string => {
-  const v = ctx.facts[key];
-  return typeof v === "string" ? v : "";
-};
-
-/** Actions taken on a turn after a delivery tool — anything else means silence. */
-const DELIVERY_ACTIONS = new Set(["end_turn", "send", "react"]);
-
-/**
- * The built-in predicate registry. These names are referenced by reflex data.
- * Keep them small and total; compound conditions get their own named predicate
- * rather than being expressed in the data.
- */
-const BUILTIN_PREDICATES: Readonly<Record<string, ReflexPredicate>> = {
-  /** Always-on trigger. */
-  always: () => true,
-
-  /** The turn is ending and a user-facing reply was intended. */
-  "turn:user-reply-intended": (ctx) =>
-    bool(ctx, "turn.ending") && bool(ctx, "turn.replyIntended"),
-
-  /** No delivery tool was the last action — the reply would be lost. */
-  "delivery:not-delivered": (ctx) =>
-    !DELIVERY_ACTIONS.has(str(ctx, "turn.lastAction")),
-
-  /** About to tell the user a capability/tool is unavailable. */
-  "claim:tool-unavailable": (ctx) => bool(ctx, "claim.toolUnavailable"),
-
-  /** A deferred-tool search has not yet been performed this turn. */
-  "search:not-performed": (ctx) => !bool(ctx, "search.performed"),
-
-  /** In a group surface AND about to disclose Dylan-private information. */
-  "context:group-private-disclosure": (ctx) =>
-    str(ctx, "surface") === "group" && bool(ctx, "disclosure.dylanPrivate"),
-
-  /** Dylan did not himself raise this fact in this thread. */
-  "consent:absent": (ctx) => !bool(ctx, "consent.dylanRaisedHere"),
-};
-
-/** Resolve a predicate name, falling back to a registry override map. */
-function resolve(
-  name: string,
-  overrides?: Readonly<Record<string, ReflexPredicate>>,
-): ReflexPredicate {
-  const p = overrides?.[name] ?? BUILTIN_PREDICATES[name];
-  if (!p) throw new Error(`reflex: unknown predicate "${name}"`);
-  return p;
-}
-
-/** Evaluate one reflex against a context. */
-function evaluateReflex(
-  reflex: ReflexPayload,
-  ctx: ReflexContext,
-  overrides?: Readonly<Record<string, ReflexPredicate>>,
-): ReflexVerdict {
-  const armed = resolve(reflex.trigger, overrides)(ctx);
-  const tripped = armed && resolve(reflex.guard, overrides)(ctx);
-  return {
-    name: reflex.name,
-    severity: reflex.severity,
-    action: reflex.action,
-    fired: tripped,
-  };
-}
-
-/**
- * Evaluate every reflex, returning only those that fired, hardest first. The
- * harness blocks the turn if any `block` verdict is present.
- */
-export function evaluateReflexes(
-  reflexes: readonly ReflexPayload[],
-  ctx: ReflexContext,
-  overrides?: Readonly<Record<string, ReflexPredicate>>,
-): ReflexVerdict[] {
-  const order: Record<ReflexSeverity, number> = {
-    block: 0,
-    warn: 1,
-    advise: 2,
-  };
-  return reflexes
-    .map((r) => evaluateReflex(r, ctx, overrides))
-    .filter((v) => v.fired)
-    .sort((a, b) => order[a.severity] - order[b.severity]);
-}
-
-/** True if any fired verdict is an enforceable block. */
-export function isBlocked(verdicts: readonly ReflexVerdict[]): boolean {
-  return verdicts.some((v) => v.severity === "block");
-}
-
-/**
- * The canonical load-bearing reflexes, installed at kernel genesis. These encode
- * the three operating scars that recur in Talon's memory: lost replies, claiming
- * a deferred tool is unavailable without searching, and leaking Dylan-private
- * context into a group.
- */
-export function seedReflexes(): ReflexPayload[] {
-  return [
-    {
-      kind: "reflex",
-      name: "RULE-0-DELIVERY",
-      trigger: "turn:user-reply-intended",
-      guard: "delivery:not-delivered",
-      action:
-        "BLOCK: the reply is private scratchpad until delivered — call end_turn/send/react before ending the turn.",
-      severity: "block",
-    },
-    {
-      kind: "reflex",
-      name: "DEFERRED-TOOL-SEARCH",
-      trigger: "claim:tool-unavailable",
-      guard: "search:not-performed",
-      action:
-        "BLOCK: run tool_search for the capability before telling the user it is unavailable.",
-      severity: "block",
-    },
-    {
-      kind: "reflex",
-      name: "PRIVACY-BOUNDARY",
-      trigger: "context:group-private-disclosure",
-      guard: "consent:absent",
-      action:
-        "BLOCK: do not disclose Dylan-private context in a group unless he raised it here himself.",
-      severity: "block",
-    },
-  ];
-}