@hviana/sema 0.1.3 → 0.1.5

package/dist/src/mind/mechanisms/cast.js

@@ -12,7 +12,7 @@
 // juxtapose.
 import { read } from "../primitives.js";
 import { argmaxBy, hubBound } from "../traverse.js";
-import { analogyStrength, follow, project, reverseContext, } from "../match.js";
+import { analogyStrength, follow, project, reverseContext } from "../match.js";
 import { joinWithBridge } from "../resonance.js";
 import { CONCEPT, STEP } from "../graph-search.js";
 import { concat2, indexOf } from "../../bytes.js";
@@ -70,378 +70,471 @@ const MIN_WEAVE = 2;
  *
  *  Returns the array of {@link CastResult}s that fired (possibly empty). */
 export async function counterfactualTransfer(ctx, query, pre) {
-    const quantum = ctx.space.maxGroup;
-    if (query.length < 2 * quantum || ctx.store.edgeSourceCount() === 0) {
-        return [];
+  const quantum = ctx.space.maxGroup;
+  if (query.length < 2 * quantum || ctx.store.edgeSourceCount() === 0) {
+    return [];
+  }
+  const { roots, ranked } = await pre.attention();
+  if (ranked.length < 2) {
+    return [];
+  }
+  const weave = await pre.weave();
+  const points = weave.points;
+  const depth = weave.depth;
+  const aligned = points.length;
+  if (aligned < 2) {
+    return [];
+  }
+  // ── Frame gate (half-dominance, weave-local) ─────────────────────────
+  // A byte is FRAME when more than MIN_WEAVE aligned structures cover it
+  // AND those structures are a majority of all aligned structures.
+  // Per-byte:  frame(i) ⇔ depth[i] > MIN_WEAVE ∧ dominates(depth[i], aligned)
+  // Per-run:   usable(r) ⇔ ¬dominates(framedCount, runLen)
+  const isFrame = (i) => depth[i] > MIN_WEAVE && dominates(depth[i], aligned);
+  const framedCount = (qs, qe) => {
+    let n = 0;
+    for (let i = qs; i < qe; i++) {
+      if (isFrame(i)) {
+        n++;
+      }
     }
-    const { roots, ranked } = await pre.attention();
-    if (ranked.length < 2)
-        return [];
-    const weave = await pre.weave();
-    const points = weave.points;
-    const depth = weave.depth;
-    const aligned = points.length;
-    if (aligned < 2)
-        return [];
-    // ── Frame gate (half-dominance, weave-local) ─────────────────────────
-    // A byte is FRAME when more than MIN_WEAVE aligned structures cover it
-    // AND those structures are a majority of all aligned structures.
-    // Per-byte:  frame(i) ⇔ depth[i] > MIN_WEAVE ∧ dominates(depth[i], aligned)
-    // Per-run:   usable(r) ⇔ ¬dominates(framedCount, runLen)
-    const isFrame = (i) => depth[i] > MIN_WEAVE && dominates(depth[i], aligned);
-    const framedCount = (qs, qe) => {
-        let n = 0;
-        for (let i = qs; i < qe; i++)
-            if (isFrame(i))
-                n++;
-        return n;
-    };
-    const usable = (qs, qe) => !dominates(framedCount(qs, qe), qe - qs);
-    // The weave's DOMINANT is its principal STRUCTURE — the aligned point
-    // explaining the most query bytes — not the climb's top-ranked TOPIC.
-    // The two used to coincide (approximate votes from a query's novel spans
-    // boosted whichever exemplar shared its frame), but the contrastive
-    // margin ranks the query's own exact site first, and CAST's schemas all
-    // orient around the frame-bearing structure: the substitution/redirection
-    // seat is displaced IN the dominant, and comparison seats the analogs by
-    // the contexts that establish their roles.  Coverage is weave-local and
-    // derived (sum of aligned run lengths); ties keep the ranked order.
-    let dominant = points[0];
-    let domCover = -1;
-    for (const p of points) {
-        let cover = 0;
-        for (const r of p.runs)
-            cover += r.qe - r.qs;
-        if (cover > domCover) {
-            domCover = cover;
-            dominant = p;
-        }
+    return n;
+  };
+  const usable = (qs, qe) => !dominates(framedCount(qs, qe), qe - qs);
+  // The weave's DOMINANT is its principal STRUCTURE — the aligned point
+  // explaining the most query bytes — not the climb's top-ranked TOPIC.
+  // The two used to coincide (approximate votes from a query's novel spans
+  // boosted whichever exemplar shared its frame), but the contrastive
+  // margin ranks the query's own exact site first, and CAST's schemas all
+  // orient around the frame-bearing structure: the substitution/redirection
+  // seat is displaced IN the dominant, and comparison seats the analogs by
+  // the contexts that establish their roles.  Coverage is weave-local and
+  // derived (sum of aligned run lengths); ties keep the ranked order.
+  let dominant = points[0];
+  let domCover = -1;
+  for (const p of points) {
+    let cover = 0;
+    for (const r of p.runs) {
+      cover += r.qe - r.qs;
     }
-    const isRoot = (id) => roots.some((r) => r.anchor === id);
-    // The weave must touch a COMMITTED point of attention: the dominant
-    // structure itself, or another aligned point the climb committed to.
-    if (!points.some((p) => isRoot(p.anchor)))
-        return [];
-    const woven = points.some((p) => p.runs.some((r) => !pre.rec.sites.some((s) => r.qs >= s.start && r.qe <= s.end)));
-    if (!woven)
-        return [];
-    const t = ctx.trace?.enter("counterfactual", [
-        rItem(query, "query"),
-    ]);
-    // Each schema tried below RECORDS its candidate (when it fires) rather than
-    // returning immediately — every schema that succeeds contributes its own
-    // candidate, and the grounding decider's own weight comparison (not CAST's
-    // former internal priority) picks among them.
-    //
-    // `accounted` is SCHEMA-SPECIFIC, not the whole weave's alignment: a
-    // schema only actually TRANSFERS BETWEEN the two points its own logic
-    // names (substitution: the filled subject + the displaced seat;
-    // redirection: the displaced seat + the named substitute; comparison:
-    // the dominant + its analog) — a THIRD point the weave happened to align
-    // but this schema never touched contributes nothing to what THIS answer
-    // explains.  Pricing every schema against the SAME "every kept point's
-    // every run" span would let the cheapest schema win on move-cost alone
-    // regardless of which one actually used more of the query; pricing it
-    // against only a fragment of even its OWN two points (e.g. one run
-    // instead of the point's full aligned evidence) is just as wrong the
-    // other way — it starves an otherwise-correct schema of credit for
-    // evidence it legitimately relied on.  Each call site below passes the
-    // full run set of exactly the points ITS OWN transfer used — no more,
-    // no less.
-    const runSpans = (p) => p.runs.map((r) => [r.qs, r.qe]);
-    const results = [];
-    const record = (answer, note, used, moves, accounted) => {
-        if (answer === null)
-            return;
-        ctx.trace?.step("castSchema", [rItem(query, "query")], [rItem(answer, "answer")], note);
-        results.push({
-            bytes: answer,
-            used: used ?? new Set(),
-            accounted,
-            moves,
-            unexplained: unexplainedLabel(query, accounted),
-        });
-    };
-    ctx.trace?.step("alignStructures", [rItem(query, "query")], points.map((p) => rNode(ctx, p.anchor, "structure", p.vote)), "the independent learnt structures the query weaves, by graded alignment");
-    const lastRun = (p) => p.runs[p.runs.length - 1];
-    const qv = pre.guide;
-    // ── SUBSTITUTION ──────────────────────────────────────────────────
-    const fillerOf = (s) => {
-        const r = s.runs[0];
-        return r.cs < quantum
-            ? s.ctx.subarray(0, r.cs + (r.qe - r.qs))
-            : query.subarray(r.qs, r.qe);
-    };
-    const beforeOf = (p, r) => argmaxBy(points.filter((s) => s !== p && lastRun(s).qe <= r.qs &&
+    if (cover > domCover) {
+      domCover = cover;
+      dominant = p;
+    }
+  }
+  const isRoot = (id) => roots.some((r) => r.anchor === id);
+  // The weave must touch a COMMITTED point of attention: the dominant
+  // structure itself, or another aligned point the climb committed to.
+  if (!points.some((p) => isRoot(p.anchor))) {
+    return [];
+  }
+  const woven = points.some((p) =>
+    p.runs.some((r) =>
+      !pre.rec.sites.some((s) => r.qs >= s.start && r.qe <= s.end)
+    )
+  );
+  if (!woven) {
+    return [];
+  }
+  const t = ctx.trace?.enter("counterfactual", [
+    rItem(query, "query"),
+  ]);
+  // Each schema tried below RECORDS its candidate (when it fires) rather than
+  // returning immediately — every schema that succeeds contributes its own
+  // candidate, and the grounding decider's own weight comparison (not CAST's
+  // former internal priority) picks among them.
+  //
+  // `accounted` is SCHEMA-SPECIFIC, not the whole weave's alignment: a
+  // schema only actually TRANSFERS BETWEEN the two points its own logic
+  // names (substitution: the filled subject + the displaced seat;
+  // redirection: the displaced seat + the named substitute; comparison:
+  // the dominant + its analog) — a THIRD point the weave happened to align
+  // but this schema never touched contributes nothing to what THIS answer
+  // explains.  Pricing every schema against the SAME "every kept point's
+  // every run" span would let the cheapest schema win on move-cost alone
+  // regardless of which one actually used more of the query; pricing it
+  // against only a fragment of even its OWN two points (e.g. one run
+  // instead of the point's full aligned evidence) is just as wrong the
+  // other way — it starves an otherwise-correct schema of credit for
+  // evidence it legitimately relied on.  Each call site below passes the
+  // full run set of exactly the points ITS OWN transfer used — no more,
+  // no less.
+  const runSpans = (p) => p.runs.map((r) => [r.qs, r.qe]);
+  const results = [];
+  const record = (answer, note, used, moves, accounted) => {
+    if (answer === null) {
+      return;
+    }
+    ctx.trace?.step("castSchema", [rItem(query, "query")], [
+      rItem(answer, "answer"),
+    ], note);
+    results.push({
+      bytes: answer,
+      used: used ?? new Set(),
+      accounted,
+      moves,
+      unexplained: unexplainedLabel(query, accounted),
+    });
+  };
+  ctx.trace?.step(
+    "alignStructures",
+    [rItem(query, "query")],
+    points.map((p) => rNode(ctx, p.anchor, "structure", p.vote)),
+    "the independent learnt structures the query weaves, by graded alignment",
+  );
+  const lastRun = (p) => p.runs[p.runs.length - 1];
+  const qv = pre.guide;
+  // ── SUBSTITUTION ──────────────────────────────────────────────────
+  const fillerOf = (s) => {
+    const r = s.runs[0];
+    return r.cs < quantum
+      ? s.ctx.subarray(0, r.cs + (r.qe - r.qs))
+      : query.subarray(r.qs, r.qe);
+  };
+  const beforeOf = (p, r) =>
+    argmaxBy(
+      points.filter((s) =>
+        s !== p && lastRun(s).qe <= r.qs &&
         s.runs[0].cs < quantum &&
-        usable(s.runs[0].qs, s.runs[0].qe)), (s) => lastRun(s).qs, -Infinity, true)?.item;
-    const displacement = points
-        .map((p) => {
-        const r = p.runs[0];
-        if (r.cs < quantum || !usable(r.qs, r.qe)) {
-            return null;
-        }
-        const before = beforeOf(p, r);
-        if (before === undefined)
-            return null;
-        if (r.cs > fillerOf(before).length + quantum)
-            return null;
-        return { p, before, depth: p.ctx.length - r.cs };
+        usable(s.runs[0].qs, s.runs[0].qe)
+      ),
+      (s) => lastRun(s).qs,
+      -Infinity,
+      true,
+    )?.item;
+  const displacement = points
+    .map((p) => {
+      const r = p.runs[0];
+      if (r.cs < quantum || !usable(r.qs, r.qe)) {
+        return null;
+      }
+      const before = beforeOf(p, r);
+      if (before === undefined) {
+        return null;
+      }
+      if (r.cs > fillerOf(before).length + quantum) {
+        return null;
+      }
+      return { p, before, depth: p.ctx.length - r.cs };
     })
-        .filter((c) => c !== null);
-    const picked = argmaxBy(displacement, (c) => c.depth, -Infinity, true);
-    const proj = picked?.item.p ?? null;
-    const subj = picked?.item.before ?? null;
-    if (proj !== null && subj !== null) {
-        const seat = proj.runs[0];
-        const filler = fillerOf(subj);
-        const tail = proj.ctx.subarray(seat.cs);
-        let answer = await joinWithBridge(ctx, filler, tail);
-        const fwd = await follow(ctx, proj.anchor, qv);
-        if (fwd !== null && indexOf(answer, fwd, 0) < 0) {
-            answer = concat2(answer, fwd);
-        }
-        ctx.trace?.step("projectCounterfactual", [
-            rItem(filler, "filler", subj.anchor),
-            rNode(ctx, proj.anchor, "displaced-structure"),
-        ], [rItem(answer, "projection")], "transfer the displaced structure onto the subject filler (seat substitution)");
-        record(answer, "counterfactual substitution — the subject fills the analog's seat", new Set([subj.anchor, proj.anchor]), 
-        // The acts performed: one seat INSERT projection + one edge FOLLOW.
-        STEP + STEP, 
-        // What substitution actually READ: the two points it transfers
-        // between — the subject filling the seat, and the displaced
-        // structure whose seat it fills — not every OTHER point the weave
-        // happened to align (a third, unrelated point in the same weave
-        // contributes nothing to what substitution itself explains).
-        [...runSpans(subj), ...runSpans(proj)]);
+    .filter((c) => c !== null);
+  const picked = argmaxBy(displacement, (c) => c.depth, -Infinity, true);
+  const proj = picked?.item.p ?? null;
+  const subj = picked?.item.before ?? null;
+  if (proj !== null && subj !== null) {
+    const seat = proj.runs[0];
+    const filler = fillerOf(subj);
+    const tail = proj.ctx.subarray(seat.cs);
+    let answer = await joinWithBridge(ctx, filler, tail);
+    const fwd = await follow(ctx, proj.anchor, qv);
+    if (fwd !== null && indexOf(answer, fwd, 0) < 0) {
+      answer = concat2(answer, fwd);
+    }
+    ctx.trace?.step(
+      "projectCounterfactual",
+      [
+        rItem(filler, "filler", subj.anchor),
+        rNode(ctx, proj.anchor, "displaced-structure"),
+      ],
+      [rItem(answer, "projection")],
+      "transfer the displaced structure onto the subject filler (seat substitution)",
+    );
+    record(
+      answer,
+      "counterfactual substitution — the subject fills the analog's seat",
+      new Set([subj.anchor, proj.anchor]),
+      // The acts performed: one seat INSERT projection + one edge FOLLOW.
+      STEP + STEP,
+      // What substitution actually READ: the two points it transfers
+      // between — the subject filling the seat, and the displaced
+      // structure whose seat it fills — not every OTHER point the weave
+      // happened to align (a third, unrelated point in the same weave
+      // contributes nothing to what substitution itself explains).
+      [...runSpans(subj), ...runSpans(proj)],
+    );
+  }
+  // ── REDIRECTION ────────────────────────────────────────────────────
+  const last = points.reduce((a, b) => lastRun(b).qs > lastRun(a).qs ? b : a);
+  // Displacement test, capped at the hub bound: a hub anchor can carry a
+  // corpus-sized fan-out, and each continuation costs a full byte
+  // reconstruction plus an O(|query|·|bytes|) scan.  The first √N edges (the
+  // same insertion-order convention chooseNext caps by) decide; past a hub's
+  // cap the test reads "none of the established continuations appears".
+  const domNext = ctx.store.nextFirst(dominant.anchor, hubBound(ctx));
+  const displaced = domNext
+    .every((n) => indexOf(query, read(ctx, n), 0) < 0);
+  if (
+    last !== dominant &&
+    last.runs[0].cs === 0 && displaced &&
+    usable(last.runs[0].qs, last.runs[0].qe)
+  ) {
+    const g = await project(ctx, last.anchor, qv);
+    if (g !== null) {
+      ctx.trace?.step(
+        "projectCounterfactual",
+        [
+          rNode(ctx, dominant.anchor, "displaced-structure"),
+          rNode(ctx, last.anchor, "substitute"),
+        ],
+        [rItem(g, "projection")],
+        "the substitute's own fact replaces the displaced structure's answer",
+      );
+      record(
+        g,
+        "counterfactual redirection — the named substitute's fact is followed",
+        new Set([dominant.anchor, last.anchor]),
+        // One forward projection across the substitute's own fact.
+        STEP,
+        // What redirection READ: the displaced structure's own recognized
+        // seat (still explained — this schema RECOGNIZES it as the slot
+        // being overridden, it just doesn't answer from it) plus the named
+        // substitute's own aligned run — not every OTHER point the weave
+        // happened to align.
+        [...runSpans(dominant), ...runSpans(last)],
+      );
     }
-    // ── REDIRECTION ────────────────────────────────────────────────────
-    const last = points.reduce((a, b) => lastRun(b).qs > lastRun(a).qs ? b : a);
-    // Displacement test, capped at the hub bound: a hub anchor can carry a
-    // corpus-sized fan-out, and each continuation costs a full byte
-    // reconstruction plus an O(|query|·|bytes|) scan.  The first √N edges (the
-    // same insertion-order convention chooseNext caps by) decide; past a hub's
-    // cap the test reads "none of the established continuations appears".
-    const domNext = ctx.store.nextFirst(dominant.anchor, hubBound(ctx));
-    const displaced = domNext
-        .every((n) => indexOf(query, read(ctx, n), 0) < 0);
-    if (last !== dominant &&
-        last.runs[0].cs === 0 && displaced &&
-        usable(last.runs[0].qs, last.runs[0].qe)) {
-        const g = await project(ctx, last.anchor, qv);
-        if (g !== null) {
-            ctx.trace?.step("projectCounterfactual", [
-                rNode(ctx, dominant.anchor, "displaced-structure"),
-                rNode(ctx, last.anchor, "substitute"),
-            ], [rItem(g, "projection")], "the substitute's own fact replaces the displaced structure's answer");
-            record(g, "counterfactual redirection — the named substitute's fact is followed", new Set([dominant.anchor, last.anchor]), 
-            // One forward projection across the substitute's own fact.
-            STEP, 
-            // What redirection READ: the displaced structure's own recognized
-            // seat (still explained — this schema RECOGNIZES it as the slot
-            // being overridden, it just doesn't answer from it) plus the named
-            // substitute's own aligned run — not every OTHER point the weave
-            // happened to align.
-            [...runSpans(dominant), ...runSpans(last)]);
-        }
+  }
+  // ── COMPARISON ─────────────────────────────────────────────────────
+  // Collect every qualifying non-dominant point as a candidate analog.
+  // When a point's own anchor is structurally at the wrong level
+  // (e.g. a long exemplar sentence whose halo does not resemble the
+  // dominant's), its nextOf targets often point to the right level — the
+  // person / concept the exemplar is about.  Trying both prevents a
+  // seed-dependent failure where the climb ranks an exemplar above a
+  // person node and the person node is excluded from points by run-
+  // overlap trimming.
+  // The seat that establishes a candidate's role: the REVERSE projection
+  // (the context it follows), voiced by the query gist — falling back to the
+  // candidate's own bytes when it follows nothing.  DELIBERATE STRENGTHENING
+  // over the pre-refactor code: reverseContext also returns null when the
+  // picked context READS EMPTY (a dangling id degrades to zero bytes), so a
+  // corrupted-store read now falls back here instead of voicing a hollow
+  // seat into the comparison — the same "empty bytes are no grounding"
+  // invariant project() has always enforced.
+  const seatOfNode = (id, fallback) => reverseContext(ctx, id, qv) ?? fallback;
+  const seatOf = (p) => seatOfNode(p.anchor, p.ctx);
+  const analogs = [];
+  for (const p of points) {
+    if (p === dominant) {
+      continue;
     }
-    // ── COMPARISON ─────────────────────────────────────────────────────
-    // Collect every qualifying non-dominant point as a candidate analog.
-    // When a point's own anchor is structurally at the wrong level
-    // (e.g. a long exemplar sentence whose halo does not resemble the
-    // dominant's), its nextOf targets often point to the right level — the
-    // person / concept the exemplar is about.  Trying both prevents a
-    // seed-dependent failure where the climb ranks an exemplar above a
-    // person node and the person node is excluded from points by run-
-    // overlap trimming.
-    // The seat that establishes a candidate's role: the REVERSE projection
-    // (the context it follows), voiced by the query gist — falling back to the
-    // candidate's own bytes when it follows nothing.  DELIBERATE STRENGTHENING
-    // over the pre-refactor code: reverseContext also returns null when the
-    // picked context READS EMPTY (a dangling id degrades to zero bytes), so a
-    // corrupted-store read now falls back here instead of voicing a hollow
-    // seat into the comparison — the same "empty bytes are no grounding"
-    // invariant project() has always enforced.
-    const seatOfNode = (id, fallback) => reverseContext(ctx, id, qv) ?? fallback;
-    const seatOf = (p) => seatOfNode(p.anchor, p.ctx);
-    const analogs = [];
-    for (const p of points) {
-        if (p === dominant)
-            continue;
-        // Push the point's own anchor only when its context fits within
-        // the query (the seat sentence must not dominate the comparison).
-        if (p.ctx.length <= query.length &&
-            indexOf(dominant.ctx, p.ctx, 0) < 0 &&
-            indexOf(p.ctx, dominant.ctx, 0) < 0 &&
-            indexOf(query, p.ctx, 0) < 0) {
-            analogs.push({ anchor: p.anchor, point: p });
-        }
-        // Reach through to the point's continuation targets regardless
-        // of the point's own context length: when the point is a leaf
-        // (exemplar sentence), its nextOf is the hub (person / concept)
-        // that makes a genuine cross-domain analog, and the hub's own
-        // (shorter) context will be the seat.
-        // Capped like every fan-out: a hub anchor's full continuation list is
-        // corpus-sized, and each candidate costs a read plus O(|query|·|bytes|)
-        // scans — only the first √N (insertion order, the same convention
-        // chooseNext caps by) are reachable as analogs.
-        for (const nid of ctx.store.nextFirst(p.anchor, hubBound(ctx))) {
-            const nctx = read(ctx, nid);
-            if (nctx.length > query.length ||
-                indexOf(dominant.ctx, nctx, 0) >= 0 ||
-                indexOf(nctx, dominant.ctx, 0) >= 0 ||
-                indexOf(query, nctx, 0) >= 0)
-                continue;
-            analogs.push({ anchor: nid, point: null });
-        }
+    // Push the point's own anchor only when its context fits within
+    // the query (the seat sentence must not dominate the comparison).
+    if (
+      p.ctx.length <= query.length &&
+      indexOf(dominant.ctx, p.ctx, 0) < 0 &&
+      indexOf(p.ctx, dominant.ctx, 0) < 0 &&
+      indexOf(query, p.ctx, 0) < 0
+    ) {
+      analogs.push({ anchor: p.anchor, point: p });
     }
-    let bestAnalog = null;
-    let bestSim = 0;
-    for (const c of analogs) {
-        const sim = await analogyStrength(ctx, dominant.anchor, c.anchor);
-        ctx.trace?.step("tryAnalog", [
-            rNode(ctx, dominant.anchor, "dominant"),
-            rNode(ctx, c.anchor, "candidate", sim),
-        ], [], `analogy strength ${sim.toFixed(4)}`);
-        if (sim > bestSim) {
-            bestSim = sim;
-            bestAnalog = c;
-        }
+    // Reach through to the point's continuation targets regardless
+    // of the point's own context length: when the point is a leaf
+    // (exemplar sentence), its nextOf is the hub (person / concept)
+    // that makes a genuine cross-domain analog, and the hub's own
+    // (shorter) context will be the seat.
+    // Capped like every fan-out: a hub anchor's full continuation list is
+    // corpus-sized, and each candidate costs a read plus O(|query|·|bytes|)
+    // scans — only the first √N (insertion order, the same convention
+    // chooseNext caps by) are reachable as analogs.
+    for (const nid of ctx.store.nextFirst(p.anchor, hubBound(ctx))) {
+      const nctx = read(ctx, nid);
+      if (
+        nctx.length > query.length ||
+        indexOf(dominant.ctx, nctx, 0) >= 0 ||
+        indexOf(nctx, dominant.ctx, 0) >= 0 ||
+        indexOf(query, nctx, 0) >= 0
+      ) {
+        continue;
+      }
+      analogs.push({ anchor: nid, point: null });
     }
-    // When every candidate fails the similarity gates (halo company — now
-    // deterministic signatures, see sema.ts — and the shared-frame tier),
-    // fall back to a candidate that is a genuine structural hub (edges in
-    // BOTH directions).  A hub node — a person, concept, or category — is
-    // the kind of thing that makes sense to compare across domains.  A leaf
-    // value (extracted span, terminal answer) has edges in at most one
-    // direction and comparing it would preempt the extraction pipeline,
-    // which is the right mechanism for those.  A fallback comparison carries
-    // NO similarity evidence — it stays honest only because the grounding
-    // decider weighs it against mechanisms that explain more of the query
-    // (extraction accounts its whole located envelope; see extraction.ts).
-    //
-    // WHICH hub: not the first in `analogs` order — that order flows from the
-    // vote ranking, which flows from approximate resonance, which is seed-
-    // dependent.  Pick by evidence instead: combined edge support (prevCount +
-    // fan-out), tie-broken by poured halo MASS (episode corroboration — the
-    // direct distributional evidence), then by LOWEST node id.  The id order
-    // is a property of the corpus, not of the seed — but note ids are SIGNED:
-    // byte leaves occupy −256…−1, so "lowest id" is creation order only among
-    // multi-byte nodes and byte-value order among leaves.  Either way it is
-    // deterministic, which is all the final tie-break must be.
-    if (bestAnalog === null && analogs.length > 0) {
-        let hubSupport = -1;
-        let hubMass = -1;
-        const fanClamp = hubBound(ctx) + 1;
-        for (const c of analogs) {
-            // Evidence clamped at the hub bound: beyond √N + 1 the exact fan-out
-            // no longer discriminates (every mega-hub ties at the clamp), and
-            // counting it exactly would require the corpus-sized read.
-            const fanOut = ctx.store.nextFirst(c.anchor, fanClamp).length;
-            if (fanOut === 0)
-                continue;
-            const support = ctx.store.prevCount(c.anchor);
-            if (support === 0)
-                continue;
-            const total = support + fanOut;
-            if (total < hubSupport)
-                continue;
-            const mass = ctx.store.haloMass(c.anchor);
-            if (total > hubSupport ||
-                mass > hubMass ||
-                (mass === hubMass && bestAnalog !== null &&
-                    c.anchor < bestAnalog.anchor)) {
-                hubSupport = total;
-                hubMass = mass;
-                bestAnalog = c;
-            }
-        }
-        if (bestAnalog !== null) {
-            ctx.trace?.step("tryAnalog", [], [rNode(ctx, bestAnalog.anchor, "fallback", hubSupport)], "no candidate passed the similarity gates — using the best-supported structural hub");
-        }
+  }
+  let bestAnalog = null;
+  let bestSim = 0;
+  for (const c of analogs) {
+    const sim = await analogyStrength(ctx, dominant.anchor, c.anchor);
+    ctx.trace?.step(
+      "tryAnalog",
+      [
+        rNode(ctx, dominant.anchor, "dominant"),
+        rNode(ctx, c.anchor, "candidate", sim),
+      ],
+      [],
+      `analogy strength ${sim.toFixed(4)}`,
+    );
+    if (sim > bestSim) {
+      bestSim = sim;
+      bestAnalog = c;
     }
-    ctx.trace?.step("tryAnalog", [], bestAnalog !== null ? [rNode(ctx, bestAnalog.anchor, "best", bestSim)] : [], bestAnalog !== null
-        ? `best analog with strength ${bestSim.toFixed(4)}`
-        : `no analog candidate passed (${analogs.length} checked)`);
-    // COMPARISON gate — analogical comparison seats the dominant against ONE
-    // analog, so it presupposes the query is ABOUT a single thing.  When the
-    // consensus climb instead committed to MULTIPLE independent points of
-    // attention (`roots.length > 1`), the query names independent topics to
-    // FUSE — the reasoner's fuseAttention already combines them — not analogs
-    // to compare.  Firing here would juxtapose two co-scaffolded but unrelated
-    // records (each sharing only the corpus preamble), out-accounting the
-    // honest thin multi-root grounding with a frame echo.  Derived from the
-    // climb's own forest, never tuned; substitution/redirection stay
-    // unaffected — they orient around a displaced seat, not a whole-topic
-    // analogy.
-    if (bestAnalog !== null &&
-        dominant.ctx.length <= query.length &&
-        roots.length <= 1) {
-        ctx.trace?.step("validateAnalogy", [
-            rNode(ctx, dominant.anchor, "analog", bestSim),
-            rNode(ctx, bestAnalog.anchor, "analog", bestSim),
-        ], [], "the two structures keep distributional company beyond chance — genuine analogs");
-        const a = seatOf(dominant);
-        const b = bestAnalog.point !== null
-            ? seatOf(bestAnalog.point)
-            : seatOfNode(bestAnalog.anchor, read(ctx, bestAnalog.anchor));
-        const answer = await joinWithBridge(ctx, a, b);
-        record(answer, "analogical comparison — each analog voiced by the context that establishes its role", new Set([dominant.anchor, bestAnalog.anchor]), 
-        // A halo-mediated act (the analogy gate) plus two seat projections.
-        CONCEPT + STEP + STEP, 
-        // What comparison READ: the dominant's own aligned runs, plus the
-        // analog's aligned runs when it was itself an aligned point (a nextOf
-        // descendant was never aligned to the query directly, so it
-        // contributes no accounted span — its seat is graph-reached, not
-        // query-matched).
-        [
-            ...runSpans(dominant),
-            ...(bestAnalog.point !== null ? runSpans(bestAnalog.point) : []),
-        ]);
+  }
+  // When every candidate fails the similarity gates (halo company — now
+  // deterministic signatures, see sema.ts — and the shared-frame tier),
+  // fall back to a candidate that is a genuine structural hub (edges in
+  // BOTH directions).  A hub node — a person, concept, or category — is
+  // the kind of thing that makes sense to compare across domains.  A leaf
+  // value (extracted span, terminal answer) has edges in at most one
+  // direction and comparing it would preempt the extraction pipeline,
+  // which is the right mechanism for those.  A fallback comparison carries
+  // NO similarity evidence — it stays honest only because the grounding
+  // decider weighs it against mechanisms that explain more of the query
+  // (extraction accounts its whole located envelope; see extraction.ts).
+  //
+  // WHICH hub: not the first in `analogs` order — that order flows from the
+  // vote ranking, which flows from approximate resonance, which is seed-
+  // dependent.  Pick by evidence instead: combined edge support (prevCount +
+  // fan-out), tie-broken by poured halo MASS (episode corroboration — the
+  // direct distributional evidence), then by LOWEST node id.  The id order
+  // is a property of the corpus, not of the seed — but note ids are SIGNED:
+  // byte leaves occupy −256…−1, so "lowest id" is creation order only among
+  // multi-byte nodes and byte-value order among leaves.  Either way it is
+  // deterministic, which is all the final tie-break must be.
+  if (bestAnalog === null && analogs.length > 0) {
+    let hubSupport = -1;
+    let hubMass = -1;
+    const fanClamp = hubBound(ctx) + 1;
+    for (const c of analogs) {
+      // Evidence clamped at the hub bound: beyond √N + 1 the exact fan-out
+      // no longer discriminates (every mega-hub ties at the clamp), and
+      // counting it exactly would require the corpus-sized read.
+      const fanOut = ctx.store.nextFirst(c.anchor, fanClamp).length;
+      if (fanOut === 0) {
+        continue;
+      }
+      const support = ctx.store.prevCount(c.anchor);
+      if (support === 0) {
+        continue;
+      }
+      const total = support + fanOut;
+      if (total < hubSupport) {
+        continue;
+      }
+      const mass = ctx.store.haloMass(c.anchor);
+      if (
+        total > hubSupport ||
+        mass > hubMass ||
+        (mass === hubMass && bestAnalog !== null &&
+          c.anchor < bestAnalog.anchor)
+      ) {
+        hubSupport = total;
+        hubMass = mass;
+        bestAnalog = c;
+      }
+    }
+    if (bestAnalog !== null) {
+      ctx.trace?.step(
+        "tryAnalog",
+        [],
+        [rNode(ctx, bestAnalog.anchor, "fallback", hubSupport)],
+        "no candidate passed the similarity gates — using the best-supported structural hub",
+      );
     }
-    t?.done(results.map((r) => rItem(r.bytes, "answer")), results.length > 0
-        ? `${results.length} counterfactual schema(s) fired — the grounding decider weighs them`
-        : "no counterfactual weave — the ordinary pipeline decides");
-    return results;
+  }
+  ctx.trace?.step(
+    "tryAnalog",
+    [],
+    bestAnalog !== null ? [rNode(ctx, bestAnalog.anchor, "best", bestSim)] : [],
+    bestAnalog !== null
+      ? `best analog with strength ${bestSim.toFixed(4)}`
+      : `no analog candidate passed (${analogs.length} checked)`,
+  );
+  // COMPARISON gate — analogical comparison seats the dominant against ONE
+  // analog, so it presupposes the query is ABOUT a single thing.  When the
+  // consensus climb instead committed to MULTIPLE independent points of
+  // attention (`roots.length > 1`), the query names independent topics to
+  // FUSE — the reasoner's fuseAttention already combines them — not analogs
+  // to compare.  Firing here would juxtapose two co-scaffolded but unrelated
+  // records (each sharing only the corpus preamble), out-accounting the
+  // honest thin multi-root grounding with a frame echo.  Derived from the
+  // climb's own forest, never tuned; substitution/redirection stay
+  // unaffected — they orient around a displaced seat, not a whole-topic
+  // analogy.
+  if (
+    bestAnalog !== null &&
+    dominant.ctx.length <= query.length &&
+    roots.length <= 1
+  ) {
+    ctx.trace?.step(
+      "validateAnalogy",
+      [
+        rNode(ctx, dominant.anchor, "analog", bestSim),
+        rNode(ctx, bestAnalog.anchor, "analog", bestSim),
+      ],
+      [],
+      "the two structures keep distributional company beyond chance — genuine analogs",
+    );
+    const a = seatOf(dominant);
+    const b = bestAnalog.point !== null
+      ? seatOf(bestAnalog.point)
+      : seatOfNode(bestAnalog.anchor, read(ctx, bestAnalog.anchor));
+    const answer = await joinWithBridge(ctx, a, b);
+    record(
+      answer,
+      "analogical comparison — each analog voiced by the context that establishes its role",
+      new Set([dominant.anchor, bestAnalog.anchor]),
+      // A halo-mediated act (the analogy gate) plus two seat projections.
+      CONCEPT + STEP + STEP,
+      // What comparison READ: the dominant's own aligned runs, plus the
+      // analog's aligned runs when it was itself an aligned point (a nextOf
+      // descendant was never aligned to the query directly, so it
+      // contributes no accounted span — its seat is graph-reached, not
+      // query-matched).
+      [
+        ...runSpans(dominant),
+        ...(bestAnalog.point !== null ? runSpans(bestAnalog.point) : []),
+      ],
+    );
+  }
+  t?.done(
+    results.map((r) => rItem(r.bytes, "answer")),
+    results.length > 0
+      ? `${results.length} counterfactual schema(s) fired — the grounding decider weighs them`
+      : "no counterfactual weave — the ordinary pipeline decides",
+  );
+  return results;
 }
 export const castMechanism = {
-    name: "cast",
-    provenance: "cast",
-    async floor(_ctx, query, pre, worthRunning) {
-        const W = _ctx.space.maxGroup;
-        // Cheap checks first — no pre-computation needed.
-        if (query.length < 2 * W || _ctx.store.edgeSourceCount() === 0)
-            return null;
-        // CAST's floor, when it exists, is ALWAYS exactly 2*STEP — the climb and
-        // the weave only decide whether it exists (2*STEP) or not (null), they
-        // never tighten the number itself.  So if 2*STEP already can't beat
-        // whatever incumbent has already won this response (cover runs first —
-        // see defaultMechanisms), no analysis can change the outcome: RETURN THE
-        // BOUND uninvested (still admissible) and let the pipeline's own check
-        // prune run() with the truthful "cannot beat incumbent" note.  This is
-        // the SAME admissible-floor economy worthRunning applies to run(),
-        // applied to floor()'s own investment — uniformly, whatever mechanism
-        // supplied the incumbent (an extension's computed result is not
-        // special-cased; any sufficiently cheap incumbent prunes the same way).
-        if (!worthRunning(2 * STEP))
-            return 2 * STEP;
-        // Now first-touch the shared analyses (climb, then the weave built on
-        // it).  If another mechanism already triggered either, this awaits the
-        // cached result; otherwise it's computed once here and reused in run().
-        if ((await pre.attention()).ranked.length < 2)
-            return null;
-        if ((await pre.weave()).points.length < 2)
-            return null;
-        return 2 * STEP;
-    },
-    async run(ctx, query, pre) {
-        const casts = await counterfactualTransfer(ctx, query, pre);
-        return casts.map((c) => ({
-            bytes: c.bytes,
-            accounted: c.accounted,
-            moves: c.moves,
-            used: c.used,
-            unexplained: c.unexplained,
-        }));
-    },
+  name: "cast",
+  provenance: "cast",
+  async floor(_ctx, query, pre, worthRunning) {
+    const W = _ctx.space.maxGroup;
+    // Cheap checks first — no pre-computation needed.
+    if (query.length < 2 * W || _ctx.store.edgeSourceCount() === 0) {
+      return null;
+    }
+    // CAST's floor, when it exists, is ALWAYS exactly 2*STEP — the climb and
+    // the weave only decide whether it exists (2*STEP) or not (null), they
+    // never tighten the number itself.  So if 2*STEP already can't beat
+    // whatever incumbent has already won this response (cover runs first —
+    // see defaultMechanisms), no analysis can change the outcome: RETURN THE
+    // BOUND uninvested (still admissible) and let the pipeline's own check
+    // prune run() with the truthful "cannot beat incumbent" note.  This is
+    // the SAME admissible-floor economy worthRunning applies to run(),
+    // applied to floor()'s own investment — uniformly, whatever mechanism
+    // supplied the incumbent (an extension's computed result is not
+    // special-cased; any sufficiently cheap incumbent prunes the same way).
+    if (!worthRunning(2 * STEP)) {
+      return 2 * STEP;
+    }
+    // Now first-touch the shared analyses (climb, then the weave built on
+    // it).  If another mechanism already triggered either, this awaits the
+    // cached result; otherwise it's computed once here and reused in run().
+    if ((await pre.attention()).ranked.length < 2) {
+      return null;
+    }
+    if ((await pre.weave()).points.length < 2) {
+      return null;
+    }
+    return 2 * STEP;
+  },
+  async run(ctx, query, pre) {
+    const casts = await counterfactualTransfer(ctx, query, pre);
+    return casts.map((c) => ({
+      bytes: c.bytes,
+      accounted: c.accounted,
+      moves: c.moves,
+      used: c.used,
+      unexplained: c.unexplained,
+    }));
+  },
 };