@hviana/sema 0.2.2 → 0.2.4

package/src/mind/attention.ts

@@ -57,8 +57,17 @@ export async function climbAttention(
 }
 
 /** Full read-out of one consensus climb: both the roots (dominant points of
- *  attention) and the entire ranked list.  Cached via ctx.climbMemo when
- *  ctx.trace is null. */
+ *  attention) and the entire ranked list.  Cached via ctx.climbMemo, ALWAYS —
+ *  see {@link recognise} for why this memo (and recognise()'s own) must
+ *  never be skipped while tracing: computeAttention's collectRegions walks
+ *  the query's perceived tree via the same foldTree whose subtree-resolution
+ *  fast path makes a second call on identical bytes non-idempotent once
+ *  ctx._resolvedSubtrees is warm (which a multi-turn conversation's shared
+ *  prefix subtrees guarantee by the second turn).  A cache hit still emits
+ *  a trace step — abbreviated, since the full per-sub-region voting detail
+ *  {@link traceAttention} builds isn't preserved by the cached read-out —
+ *  so a traced response is never silently blacked out for a repeated
+ *  query. */
 export async function climbAttentionAll(
   ctx: MindContext,
   query: Uint8Array,
@@ -66,8 +75,8 @@ export async function climbAttentionAll(
   mode: DFMode = "inverse",
 ): Promise<AttentionRead> {
   // Content-keyed memo — works for both single-turn respond() and multi-turn
-  // respondTurn().  Skipped while tracing.
-  if (ctx.climbMemo && !ctx.trace) {
+  // respondTurn().
+  if (ctx.climbMemo) {
     const contentKey = latin1Key(query);
     const modeKey = `${k}:${mode}`;
     let byRead = ctx.climbMemo.get(contentKey);
@@ -75,7 +84,16 @@ export async function climbAttentionAll(
       ctx.climbMemo.set(contentKey, byRead = new Map());
     }
     const hit = byRead.get(modeKey);
-    if (hit !== undefined) return hit;
+    if (hit !== undefined) {
+      ctx.trace?.step(
+        "climbConsensus",
+        [rItem(query, "query")],
+        hit.roots.map((r) => rNode(ctx, r.anchor, "anchor", r.vote)),
+        `(cached) consensus already computed for this query — ` +
+          `${hit.roots.length} point(s) of attention`,
+      );
+      return hit;
+    }
     const read = await computeAttention(ctx, query, k, mode);
     byRead.set(modeKey, read);
     return read;
@@ -417,6 +435,11 @@ export function poolVotes(
   votes: Map<number, number>;
   votesIdf: Map<number, number>;
   support: Map<number, { start: number; end: number; w: number }>;
+  /** Per-anchor SCALE-INVARIANT support: Σ RegionVote.absorbed over the
+   *  distinct contributing regions — see Attention.breadth. */
+  regionSupport: Map<number, number>;
+  /** Per-anchor contributing region spans — see Attention.clusters. */
+  regionSpans: Map<number, Array<[number, number]>>;
   steps: DerivationStep[];
 } {
   const eligible: number[] = [];
@@ -496,6 +519,8 @@ export function poolVotes(
     number,
     { start: number; end: number; w: number }
   >();
+  const regionSupport = new Map<number, number>();
+  const regionSpans = new Map<number, Array<[number, number]>>();
   const steps: DerivationStep[] = [];
   let order = 0;
   for (const pc of pool.values()) {
@@ -503,13 +528,19 @@ export function poolVotes(
       votes.set(pc.item.id, pc.cost);
       const premises: DerivationItem[] = [];
       const seenRi = new Set<number>();
+      let breadthSum = 0;
+      const spans: Array<[number, number]> = [];
       for (const c of pc.contributions) {
         const p0 = c.premises[0].item;
         if (p0.kind !== "region" || seenRi.has(p0.ri)) continue;
         seenRi.add(p0.ri);
         const rv = regionVotes[p0.ri];
+        breadthSum += rv.absorbed ?? 1;
         premises.push({ kind: "form", span: [rv.start, rv.end] });
+        spans.push([rv.start, rv.end]);
       }
+      regionSupport.set(pc.item.id, breadthSum);
+      regionSpans.set(pc.item.id, spans);
       steps.push({
         order: order++,
         move: "pool-vote",
@@ -536,7 +567,35 @@ export function poolVotes(
       }
     }
   }
-  return { votes, votesIdf, support, steps };
+  return { votes, votesIdf, support, regionSupport, regionSpans, steps };
+}
+
+/** The number of DISTINCT clusters a root's contributing regions form —
+ *  see Attention.clusters.  Two regions belong to the same cluster iff the
+ *  gap between them is strictly less than one river-fold quantum W: at
+ *  that distance there is no room for a genuinely separate, independently
+ *  perceivable unit of content between them (the same "smallest meaningful
+ *  distinction" quantum {@link reachThreshold}'s own doc invokes).  A gap
+ *  of a full quantum or more means real, separate structure could sit
+ *  between the two spans, so they count as independent corroboration.
+ *  Strict `<` (not `<=`): verified against gap 3.1's own "gender equality"
+ *  root, whose two genuine clusters sit EXACTLY W bytes apart — `<= W`
+ *  would wrongly merge them into one and break that pinned requirement. */
+function countClusters(spans: readonly [number, number][], W: number): number {
+  if (spans.length === 0) return 0;
+  const sorted = [...spans].sort((a, b) => a[0] - b[0]);
+  let clusters = 1;
+  let curEnd = sorted[0][1];
+  for (let i = 1; i < sorted.length; i++) {
+    const [s, e] = sorted[i];
+    if (s - curEnd < W) {
+      curEnd = Math.max(curEnd, e);
+    } else {
+      clusters++;
+      curEnd = e;
+    }
+  }
+  return clusters;
 }
 
 export function commitVotes(
@@ -545,6 +604,8 @@ export function commitVotes(
     votes: Map<number, number>;
     votesIdf: Map<number, number>;
     support: Map<number, { start: number; end: number; w: number }>;
+    regionSupport: Map<number, number>;
+    regionSpans: Map<number, Array<[number, number]>>;
     steps: DerivationStep[];
   },
   sat: SaturationInfo,
@@ -552,16 +613,32 @@ export function commitVotes(
   regionVoter: ReadonlyArray<{ id: number; score: number; w: number } | null>,
   N: number,
 ): AttentionRead {
-  const { votes, votesIdf, support, steps } = pooled;
+  const { votes, votesIdf, support, regionSupport, regionSpans, steps } =
+    pooled;
   if (votes.size === 0) {
     traceAttention(ctx, regions, regionVoter, [], steps);
     return { roots: [], ranked: [] };
   }
 
+  // SCALE-INVARIANT confidence — see Attention.breadth's doc.  regions.length
+  // is the query's OWN full candidate count (most never vote at all), the
+  // same denominator the "N of M sub-regions voted" rationale text already
+  // reports; regionSupport is that same accounting read PER ANCHOR.
+  const totalRegions = Math.max(1, regions.length);
   const ranked = [...votes.entries()]
     .map(([anchor, vote]) => {
       const s = support.get(anchor)!;
-      return { anchor, vote, start: s.start, end: s.end };
+      return {
+        anchor,
+        vote,
+        start: s.start,
+        end: s.end,
+        breadth: (regionSupport.get(anchor) ?? 0) / totalRegions,
+        clusters: countClusters(
+          regionSpans.get(anchor) ?? [],
+          ctx.space.maxGroup,
+        ),
+      };
     })
     .sort((a, b) => b.vote - a.vote);
 
@@ -1016,14 +1093,6 @@ async function crossRegionVotes(
         spanStart = Math.min(spanStart, regions[ei].start);
         spanEnd = Math.max(spanEnd, regions[ei].end);
       }
-      out.push({
-        start: spanStart,
-        end: spanEnd,
-        canonicalFailed: false, // content-addressed: never saturation-masked
-        roots: reach.roots,
-        w,
-        wFocus: w,
-      });
       consumed.add(cand[a]);
       consumed.add(cand[b]);
       for (const ei of bestExtras) consumed.add(ei);
@@ -1033,14 +1102,33 @@ async function crossRegionVotes(
       // vote's bytes are literally part of the learnt whole), and FULL root
       // disjointness is the disagreement test: a vote sharing even one root
       // with the junction corroborates it and keeps its say elsewhere.
+      // Counted BEFORE pushing the junction's own vote below: each ORIGINAL
+      // region this ascent explains away is evidence the junction speaks
+      // for, not evidence lost — `absorbed` (RegionVote's breadth-accounting
+      // field) must credit the junction with all of it, not just the ONE
+      // pooled axiom it collapses to.
       const containerBytes = cachedRead(ctx, cache, best.id, cap);
       const jointRoots = new Set(reach.roots);
+      let explainedAway = 0;
       for (const rv of rvs.votes) {
         if (rv.roots.some((r) => jointRoots.has(r))) continue;
         const bytes = query.subarray(rv.start, rv.end);
-        if (indexOf(containerBytes, bytes, 0) >= 0) superseded.add(rv);
+        if (indexOf(containerBytes, bytes, 0) >= 0 && !superseded.has(rv)) {
+          superseded.add(rv);
+          explainedAway++;
+        }
       }
 
+      out.push({
+        start: spanStart,
+        end: spanEnd,
+        canonicalFailed: false, // content-addressed: never saturation-masked
+        roots: reach.roots,
+        w,
+        wFocus: w,
+        absorbed: 1 + explainedAway,
+      });
+
       const label = [cand[a], cand[b], ...bestExtras]
         .sort((x, y) => regions[x].start - regions[y].start)
         .map((ri) => dec(query.subarray(regions[ri].start, regions[ri].end)))