@hviana/sema 0.1.3 → 0.1.5

package/dist/src/mind/rationale.js

@@ -22,37 +22,41 @@
 /** Decode bytes to text for display, dropping the NUL padding the encoder uses
  *  (the same cleanup {@link Mind.respondText} does for its result). */
 export function decodeText(bytes) {
-    return new TextDecoder().decode(bytes.filter((b) => b !== 0x00));
+  return new TextDecoder().decode(bytes.filter((b) => b !== 0x00));
 }
 /** The `[start, end)` gaps of `[0, queryLen)` NOT covered by `accounted` —
  *  the same union-of-spans reading think's grounding decider prices at PASS
  *  per byte, exposed here so a mechanism can turn it into a human label. */
 export function unexplainedSpans(queryLen, accounted) {
-    const sorted = accounted
-        .map(([s, e]) => [Math.max(0, s), Math.min(queryLen, e)])
-        .filter(([s, e]) => e > s)
-        .sort((a, b) => a[0] - b[0]);
-    const gaps = [];
-    let reach = 0;
-    for (const [s, e] of sorted) {
-        if (s > reach)
-            gaps.push([reach, s]);
-        if (e > reach)
-            reach = e;
+  const sorted = accounted
+    .map(([s, e]) => [Math.max(0, s), Math.min(queryLen, e)])
+    .filter(([s, e]) => e > s)
+    .sort((a, b) => a[0] - b[0]);
+  const gaps = [];
+  let reach = 0;
+  for (const [s, e] of sorted) {
+    if (s > reach) {
+      gaps.push([reach, s]);
     }
-    if (reach < queryLen)
-        gaps.push([reach, queryLen]);
-    return gaps;
+    if (e > reach) {
+      reach = e;
+    }
+  }
+  if (reach < queryLen) {
+    gaps.push([reach, queryLen]);
+  }
+  return gaps;
 }
 /** A human-readable label for the query bytes a mechanism's `accounted`
  *  spans leave unexplained — purely diagnostic (Task 2's negative evidence):
  *  it never changes a candidate's weight, only what the rationale trace
  *  says the mechanism left on the table. `""` when nothing is unexplained. */
 export function unexplainedLabel(query, accounted) {
-    const gaps = unexplainedSpans(query.length, accounted);
-    if (gaps.length === 0)
-        return "";
-    return gaps.map(([s, e]) => decodeText(query.subarray(s, e))).join(" … ");
+  const gaps = unexplainedSpans(query.length, accounted);
+  if (gaps.length === 0) {
+    return "";
+  }
+  return gaps.map(([s, e]) => decodeText(query.subarray(s, e))).join(" … ");
 }
 /** The live tracer: a stack of open mechanisms over one {@link Mind.respond}.
  *
@@ -63,100 +67,104 @@ export function unexplainedLabel(query, accounted) {
  *  sub-steps) is the two fused.  The tracer never branches the control flow; it
  *  only records it. */
 export class Rationale {
-    sink;
-    next = 0;
-    /** Open mechanisms, outermost first.  Each frame remembers the last child it
-     *  has spawned so the next sibling can default its data-flow edge to it. */
-    stack = [];
-    /** The most recent step index emitted under each mechanism name — the handle
-     *  a later step uses to name an EARLIER mechanism as its data-flow producer
-     *  (e.g. cover depends on the latest recognise / computeExtensions).  One tracer is
-     *  built per response and inference is sequential, so "most recent" is exactly
-     *  "the one that produced the inputs I am about to consume". */
-    lastByName = new Map();
-    constructor(sink) {
-        this.sink = sink;
-    }
-    /** The index of the most recent step with this mechanism name, or undefined if
-     *  none has run.  Used to wire an explicit producer edge into {@link
-     *  Scope.done} / {@link step}'s `deps`. */
-    lastIndex(name) {
-        return this.lastByName.get(name);
-    }
-    /** The mechanism names currently open, outermost → innermost. */
-    path(leaf) {
-        const p = this.stack.map((f) => f.name);
-        p.push(leaf);
-        return p;
-    }
-    /** The default data-flow edge for a step entering now: the previous sibling
-     *  inside the current mechanism, else the enclosing mechanism, else nothing
-     *  (the root).  An explicit `deps` overrides this. */
-    defaultDeps() {
-        const top = this.stack[this.stack.length - 1];
-        if (!top)
-            return [];
-        return [top.lastChild ?? top.index];
-    }
-    /** Reserve this step's index and register it as the current mechanism's most
-     *  recent child (so the NEXT sibling chains to it) and as the most recent step
-     *  of its own NAME (so a later mechanism can name it as a producer). */
-    reserve(name) {
-        const index = this.next++;
-        const top = this.stack[this.stack.length - 1];
-        if (top)
-            top.lastChild = index;
-        this.lastByName.set(name, index);
-        return index;
-    }
-    emit(index, mechanism, inputs, outputs, deps, note) {
-        this.sink({
-            index,
-            mechanism,
-            parent: this.stack.length > 0
-                ? this.stack[this.stack.length - 1].index
-                : -1,
-            dependsOn: deps ?? this.defaultDeps(),
-            inputs,
-            outputs,
-            note,
-        });
-    }
-    /** Enter a mechanism that has sub-steps.  Captures its inputs and the nesting
-     *  now; the matching {@link Scope.done} supplies the outputs when it finishes.
-     *  `deps` overrides the default data-flow edge (previous sibling / parent). */
-    enter(name, inputs, deps) {
-        const mechanism = this.path(name);
-        const resolvedDeps = deps ?? this.defaultDeps();
-        const index = this.reserve(name);
-        this.stack.push({ index, name, lastChild: null });
-        let closed = false;
-        const emit = this.emit.bind(this);
-        const pop = () => {
-            // Pop down to and including this frame — tolerant of a sub-mechanism that
-            // forgot to close, so one missed `done` cannot desync the whole stack.
-            const at = this.stack.findIndex((f) => f.index === index);
-            if (at >= 0)
-                this.stack.length = at;
-        };
-        return {
-            index,
-            done: (outputs, note) => {
-                if (closed)
-                    return;
-                closed = true;
-                pop();
-                emit(index, mechanism, inputs, outputs, resolvedDeps, note);
-            },
-        };
+  sink;
+  next = 0;
+  /** Open mechanisms, outermost first.  Each frame remembers the last child it
+   *  has spawned so the next sibling can default its data-flow edge to it. */
+  stack = [];
+  /** The most recent step index emitted under each mechanism name — the handle
+   *  a later step uses to name an EARLIER mechanism as its data-flow producer
+   *  (e.g. cover depends on the latest recognise / computeExtensions).  One tracer is
+   *  built per response and inference is sequential, so "most recent" is exactly
+   *  "the one that produced the inputs I am about to consume". */
+  lastByName = new Map();
+  constructor(sink) {
+    this.sink = sink;
+  }
+  /** The index of the most recent step with this mechanism name, or undefined if
+   *  none has run.  Used to wire an explicit producer edge into {@link
+   *  Scope.done} / {@link step}'s `deps`. */
+  lastIndex(name) {
+    return this.lastByName.get(name);
+  }
+  /** The mechanism names currently open, outermost → innermost. */
+  path(leaf) {
+    const p = this.stack.map((f) => f.name);
+    p.push(leaf);
+    return p;
+  }
+  /** The default data-flow edge for a step entering now: the previous sibling
+   *  inside the current mechanism, else the enclosing mechanism, else nothing
+   *  (the root).  An explicit `deps` overrides this. */
+  defaultDeps() {
+    const top = this.stack[this.stack.length - 1];
+    if (!top) {
+      return [];
     }
-    /** Record a mechanism that has no sub-steps — its inputs and outputs are both
-     *  known at the call site.  Returns its index, for a later step to depend on. */
-    step(name, inputs, outputs, note, deps) {
-        const mechanism = this.path(name);
-        const resolvedDeps = deps ?? this.defaultDeps();
-        const index = this.reserve(name);
-        this.emit(index, mechanism, inputs, outputs, resolvedDeps, note);
-        return index;
+    return [top.lastChild ?? top.index];
+  }
+  /** Reserve this step's index and register it as the current mechanism's most
+   *  recent child (so the NEXT sibling chains to it) and as the most recent step
+   *  of its own NAME (so a later mechanism can name it as a producer). */
+  reserve(name) {
+    const index = this.next++;
+    const top = this.stack[this.stack.length - 1];
+    if (top) {
+      top.lastChild = index;
     }
+    this.lastByName.set(name, index);
+    return index;
+  }
+  emit(index, mechanism, inputs, outputs, deps, note) {
+    this.sink({
+      index,
+      mechanism,
+      parent: this.stack.length > 0
+        ? this.stack[this.stack.length - 1].index
+        : -1,
+      dependsOn: deps ?? this.defaultDeps(),
+      inputs,
+      outputs,
+      note,
+    });
+  }
+  /** Enter a mechanism that has sub-steps.  Captures its inputs and the nesting
+   *  now; the matching {@link Scope.done} supplies the outputs when it finishes.
+   *  `deps` overrides the default data-flow edge (previous sibling / parent). */
+  enter(name, inputs, deps) {
+    const mechanism = this.path(name);
+    const resolvedDeps = deps ?? this.defaultDeps();
+    const index = this.reserve(name);
+    this.stack.push({ index, name, lastChild: null });
+    let closed = false;
+    const emit = this.emit.bind(this);
+    const pop = () => {
+      // Pop down to and including this frame — tolerant of a sub-mechanism that
+      // forgot to close, so one missed `done` cannot desync the whole stack.
+      const at = this.stack.findIndex((f) => f.index === index);
+      if (at >= 0) {
+        this.stack.length = at;
+      }
+    };
+    return {
+      index,
+      done: (outputs, note) => {
+        if (closed) {
+          return;
+        }
+        closed = true;
+        pop();
+        emit(index, mechanism, inputs, outputs, resolvedDeps, note);
+      },
+    };
+  }
+  /** Record a mechanism that has no sub-steps — its inputs and outputs are both
+   *  known at the call site.  Returns its index, for a later step to depend on. */
+  step(name, inputs, outputs, note, deps) {
+    const mechanism = this.path(name);
+    const resolvedDeps = deps ?? this.defaultDeps();
+    const index = this.reserve(name);
+    this.emit(index, mechanism, inputs, outputs, resolvedDeps, note);
+    return index;
+  }
 }

package/dist/src/mind/reasoning.d.ts

@@ -7,9 +7,20 @@ import type { Precomputed } from "./pipeline-mechanism.js";
  *  spoken for by the grounding stage (cover/extract/CAST).  `pre` is the
  *  response's shared pre-computation — the post-grounding stages read the
  *  same container the mechanisms did. */
-export declare function reason(ctx: MindContext, query: Uint8Array, answer: Uint8Array, preConsumed: ReadonlySet<number>, pre: Precomputed): Promise<Uint8Array>;
+export declare function reason(
+  ctx: MindContext,
+  query: Uint8Array,
+  answer: Uint8Array,
+  preConsumed: ReadonlySet<number>,
+  pre: Precomputed,
+): Promise<Uint8Array>;
 /** Fuse independent points of attention into one answer (multi-topic).
  *  When the consensus climb finds more than one dominant point, each
  *  independent point grounds its own answer; they are bridged together
  *  by any learnt connector the graph holds between them. */
-export declare function fuseAttention(ctx: MindContext, query: Uint8Array, primary: Uint8Array, pre: Precomputed): Promise<Uint8Array>;
+export declare function fuseAttention(
+  ctx: MindContext,
+  query: Uint8Array,
+  primary: Uint8Array,
+  pre: Precomputed,
+): Promise<Uint8Array>;

package/dist/src/mind/reasoning.js

@@ -16,146 +16,183 @@ import { joinWithBridge, pivotInto } from "./resonance.js";
  *  response's shared pre-computation — the post-grounding stages read the
  *  same container the mechanisms did. */
 export async function reason(ctx, query, answer, preConsumed, pre) {
-    // Echo guard: a query that is ITSELF a learnt continuation (some context's
-    // answer) is being asked back at the system — hopping forward from it would
-    // chain through the very fact that produced it and echo the conversation
-    // back.  The grounded answer alone is the honest read-out.  Deliberately a
-    // broad structural gate; pinned by test/31-audit.
-    const qId = pre.queryResolved;
-    if (qId !== null && ctx.store.prevCount(qId) > 0)
-        return answer;
-    const consumed = new Set();
-    // Consume a node and its neighbours for pivot-cycle prevention — CAPPED at
-    // the hub bound, via the store's LIMITed edge reads: a common continuation's
-    // reverse fan-in (and a hub context's forward fan-out) is corpus-sized, and
-    // no per-hop operation may grow with the corpus.  The cap follows the one
-    // convention every fan-out decision uses (first √N in the relation's own
-    // read order); a pivot suppressed only by a beyond-cap neighbour may now
-    // fire — the same visibility trade chooseNext documents.
-    const hubBound = Math.ceil(Math.sqrt(corpusN(ctx)));
-    const consumeNode = (id) => {
-        if (id === null)
-            return;
-        consumed.add(id);
-        for (const p of ctx.store.prevFirst(id, hubBound))
-            consumed.add(p);
-    };
-    const consumeAll = (id) => {
-        if (id === null)
-            return;
-        consumeNode(id);
-        for (const n of ctx.store.nextFirst(id, hubBound))
-            consumed.add(n);
-    };
-    // Pre-consume whatever the grounding stage already spoke for.  The halo
-    // sweep is one ANN query per node — cap it at haloQueryK sweeps (cover
-    // grounding can pre-consume one node per recognised site, O(query length));
-    // nodes past the cap are still consumed directly, they just skip the
-    // synonym expansion.
-    let haloSweeps = 0;
-    for (const id of preConsumed) {
-        consumeNode(id);
-        if (haloSweeps >= ctx.cfg.haloQueryK)
-            continue;
-        const h = ctx.store.halo(id);
-        if (!h)
-            continue;
-        haloSweeps++;
-        for (const sib of await haloSiblings(ctx, id, h))
-            consumeNode(sib.id);
+  // Echo guard: a query that is ITSELF a learnt continuation (some context's
+  // answer) is being asked back at the system — hopping forward from it would
+  // chain through the very fact that produced it and echo the conversation
+  // back.  The grounded answer alone is the honest read-out.  Deliberately a
+  // broad structural gate; pinned by test/31-audit.
+  const qId = pre.queryResolved;
+  if (qId !== null && ctx.store.prevCount(qId) > 0) {
+    return answer;
+  }
+  const consumed = new Set();
+  // Consume a node and its neighbours for pivot-cycle prevention — CAPPED at
+  // the hub bound, via the store's LIMITed edge reads: a common continuation's
+  // reverse fan-in (and a hub context's forward fan-out) is corpus-sized, and
+  // no per-hop operation may grow with the corpus.  The cap follows the one
+  // convention every fan-out decision uses (first √N in the relation's own
+  // read order); a pivot suppressed only by a beyond-cap neighbour may now
+  // fire — the same visibility trade chooseNext documents.
+  const hubBound = Math.ceil(Math.sqrt(corpusN(ctx)));
+  const consumeNode = (id) => {
+    if (id === null) {
+      return;
     }
-    let cur = answer;
-    const qv = pre.guide; // the response-wide guide IS the query's gist
-    let t;
-    const startedFrom = answer;
-    for (let hop = 0; hop < ctx.cfg.recallQueryK; hop++) {
-        const curId = resolve(ctx, cur);
-        consumeNode(curId);
-        // Forward-absorb: follow only UNCONSUMED continuations.  The gate below
-        // checks an unconsumed edge EXISTS, but follow()'s chooseNext knows
-        // nothing of `consumed` and may still walk to a consumed fixpoint —
-        // absorbing it would repeat content the grounding stage already spoke
-        // for, so a consumed fixpoint falls through to the pivot step instead.
-        if (curId !== null &&
-            ctx.store.nextFirst(curId, hubBound).some((n) => !consumed.has(n))) {
-            const fwd = await follow(ctx, curId, qv);
-            const fwdId = fwd !== null ? resolve(ctx, fwd) : null;
-            if (fwd !== null && !bytesEqual(fwd, cur) &&
-                (fwdId === null || !consumed.has(fwdId))) {
-                consumeAll(curId);
-                t ??= ctx.trace?.enter("reason", [
-                    rItem(startedFrom, "grounded"),
-                ]);
-                ctx.trace?.step("absorbForward", [rItem(cur, "answer", curId)], [rItem(fwd, "answer", resolve(ctx, fwd) ?? undefined)], "the answer is itself a learnt fact — follow its continuation to the fixpoint");
-                cur = fwd;
-                continue;
-            }
-        }
-        // Pivot: find the longest unconsumed learnt context the answer contains.
+    consumed.add(id);
+    for (const p of ctx.store.prevFirst(id, hubBound)) {
+      consumed.add(p);
+    }
+  };
+  const consumeAll = (id) => {
+    if (id === null) {
+      return;
+    }
+    consumeNode(id);
+    for (const n of ctx.store.nextFirst(id, hubBound)) {
+      consumed.add(n);
+    }
+  };
+  // Pre-consume whatever the grounding stage already spoke for.  The halo
+  // sweep is one ANN query per node — cap it at haloQueryK sweeps (cover
+  // grounding can pre-consume one node per recognised site, O(query length));
+  // nodes past the cap are still consumed directly, they just skip the
+  // synonym expansion.
+  let haloSweeps = 0;
+  for (const id of preConsumed) {
+    consumeNode(id);
+    if (haloSweeps >= ctx.cfg.haloQueryK) {
+      continue;
+    }
+    const h = ctx.store.halo(id);
+    if (!h) {
+      continue;
+    }
+    haloSweeps++;
+    for (const sib of await haloSiblings(ctx, id, h)) {
+      consumeNode(sib.id);
+    }
+  }
+  let cur = answer;
+  const qv = pre.guide; // the response-wide guide IS the query's gist
+  let t;
+  const startedFrom = answer;
+  for (let hop = 0; hop < ctx.cfg.recallQueryK; hop++) {
+    const curId = resolve(ctx, cur);
+    consumeNode(curId);
+    // Forward-absorb: follow only UNCONSUMED continuations.  The gate below
+    // checks an unconsumed edge EXISTS, but follow()'s chooseNext knows
+    // nothing of `consumed` and may still walk to a consumed fixpoint —
+    // absorbing it would repeat content the grounding stage already spoke
+    // for, so a consumed fixpoint falls through to the pivot step instead.
+    if (
+      curId !== null &&
+      ctx.store.nextFirst(curId, hubBound).some((n) => !consumed.has(n))
+    ) {
+      const fwd = await follow(ctx, curId, qv);
+      const fwdId = fwd !== null ? resolve(ctx, fwd) : null;
+      if (
+        fwd !== null && !bytesEqual(fwd, cur) &&
+        (fwdId === null || !consumed.has(fwdId))
+      ) {
         consumeAll(curId);
-        const pivot = await pivotInto(ctx, cur, consumed);
-        if (pivot === null)
-            break;
-        const fc = await follow(ctx, pivot, qv);
-        consumeAll(pivot);
-        if (fc === null || bytesEqual(fc, cur))
-            break;
-        t ??= ctx.trace?.enter("reason", [rItem(startedFrom, "grounded")]);
-        ctx.trace?.step("pivotStep", [rItem(cur, "answer"), rNode(ctx, pivot, "pivot")], [rItem(fc, "answer", resolve(ctx, fc) ?? undefined)], "pivot on the shared span this answer contains, then step forward across that fact");
-        cur = fc;
+        t ??= ctx.trace?.enter("reason", [
+          rItem(startedFrom, "grounded"),
+        ]);
+        ctx.trace?.step(
+          "absorbForward",
+          [rItem(cur, "answer", curId)],
+          [rItem(fwd, "answer", resolve(ctx, fwd) ?? undefined)],
+          "the answer is itself a learnt fact — follow its continuation to the fixpoint",
+        );
+        cur = fwd;
+        continue;
+      }
+    }
+    // Pivot: find the longest unconsumed learnt context the answer contains.
+    consumeAll(curId);
+    const pivot = await pivotInto(ctx, cur, consumed);
+    if (pivot === null) {
+      break;
     }
-    t?.done([rItem(cur, "answer", resolve(ctx, cur) ?? undefined)], "the multi-hop chain's fixpoint");
-    return cur;
+    const fc = await follow(ctx, pivot, qv);
+    consumeAll(pivot);
+    if (fc === null || bytesEqual(fc, cur)) {
+      break;
+    }
+    t ??= ctx.trace?.enter("reason", [rItem(startedFrom, "grounded")]);
+    ctx.trace?.step(
+      "pivotStep",
+      [rItem(cur, "answer"), rNode(ctx, pivot, "pivot")],
+      [rItem(fc, "answer", resolve(ctx, fc) ?? undefined)],
+      "pivot on the shared span this answer contains, then step forward across that fact",
+    );
+    cur = fc;
+  }
+  t?.done(
+    [rItem(cur, "answer", resolve(ctx, cur) ?? undefined)],
+    "the multi-hop chain's fixpoint",
+  );
+  return cur;
 }
 /** Fuse independent points of attention into one answer (multi-topic).
  *  When the consensus climb finds more than one dominant point, each
  *  independent point grounds its own answer; they are bridged together
  *  by any learnt connector the graph holds between them. */
 export async function fuseAttention(ctx, query, primary, pre) {
-    // When the answer is structurally drawn from the query itself
-    // (extraction), it already spans all the query's pieces — fusion
-    // would only add noise from unrelated stored contexts.  The gate is
-    // STRICT containment (resolved node in the query's tree, or a contiguous
-    // byte run): the old sparse-subsequence test was trivially satisfied by
-    // short answers over long queries, silently starving multi-topic queries
-    // of fusion.
-    if (containsSpan(ctx, query, primary))
-        return primary;
-    // The committed points of attention ARE the shared climb's roots (same
-    // query, same k, same DF mode) — read them from Precomputed instead of
-    // re-climbing, so even a traced response pays for the climb once.
-    const forest = (await pre.attention()).roots;
-    if (forest.length <= 1)
-        return primary;
-    const pieces = [
-        { start: forest[0].start, bytes: primary },
-    ];
-    const qv = pre.guide; // once, not per root
-    const t = ctx.trace?.enter("fuseAttention", [
-        rItem(primary, "primary"),
-        ...forest.slice(1).map((r) => rNode(ctx, r.anchor, "point", r.vote)),
-    ]);
-    for (const root of forest.slice(1)) {
-        const g = await project(ctx, root.anchor, qv);
-        if (g === null || g.length === 0)
-            continue;
-        if (pieces.some((p) => indexOf(p.bytes, g, 0) >= 0))
-            continue;
-        pieces.push({ start: root.start, bytes: g });
-    }
-    if (pieces.length === 1) {
-        t?.done([rItem(primary, "answer")], "no further independent point grounded");
-        return primary;
+  // When the answer is structurally drawn from the query itself
+  // (extraction), it already spans all the query's pieces — fusion
+  // would only add noise from unrelated stored contexts.  The gate is
+  // STRICT containment (resolved node in the query's tree, or a contiguous
+  // byte run): the old sparse-subsequence test was trivially satisfied by
+  // short answers over long queries, silently starving multi-topic queries
+  // of fusion.
+  if (containsSpan(ctx, query, primary)) {
+    return primary;
+  }
+  // The committed points of attention ARE the shared climb's roots (same
+  // query, same k, same DF mode) — read them from Precomputed instead of
+  // re-climbing, so even a traced response pays for the climb once.
+  const forest = (await pre.attention()).roots;
+  if (forest.length <= 1) {
+    return primary;
+  }
+  const pieces = [
+    { start: forest[0].start, bytes: primary },
+  ];
+  const qv = pre.guide; // once, not per root
+  const t = ctx.trace?.enter("fuseAttention", [
+    rItem(primary, "primary"),
+    ...forest.slice(1).map((r) => rNode(ctx, r.anchor, "point", r.vote)),
+  ]);
+  for (const root of forest.slice(1)) {
+    const g = await project(ctx, root.anchor, qv);
+    if (g === null || g.length === 0) {
+      continue;
     }
-    pieces.sort((a, b) => a.start - b.start);
-    let out = pieces[0].bytes;
-    for (let i = 1; i < pieces.length; i++) {
-        // An approximate-resonance miss (or a genuinely unlearnt junction) joins
-        // the pieces bare — joinWithBridge surfaces it as a bridgeMiss step.
-        out = await joinWithBridge(ctx, out, pieces[i].bytes);
+    if (pieces.some((p) => indexOf(p.bytes, g, 0) >= 0)) {
+      continue;
     }
-    t?.done([rItem(out, "answer", resolve(ctx, out) ?? undefined)], `fused ${pieces.length} independent points of attention into one answer`);
-    return out;
+    pieces.push({ start: root.start, bytes: g });
+  }
+  if (pieces.length === 1) {
+    t?.done(
+      [rItem(primary, "answer")],
+      "no further independent point grounded",
+    );
+    return primary;
+  }
+  pieces.sort((a, b) => a.start - b.start);
+  let out = pieces[0].bytes;
+  for (let i = 1; i < pieces.length; i++) {
+    // An approximate-resonance miss (or a genuinely unlearnt junction) joins
+    // the pieces bare — joinWithBridge surfaces it as a bridgeMiss step.
+    out = await joinWithBridge(ctx, out, pieces[i].bytes);
+  }
+  t?.done(
+    [rItem(out, "answer", resolve(ctx, out) ?? undefined)],
+    `fused ${pieces.length} independent points of attention into one answer`,
+  );
+  return out;
 }
 // (resonance.js is already a static dependency above — `bridge` — so the old
 // dynamic import of pivotInto guarded against a cycle that does not exist.)

package/dist/src/mind/recognition.d.ts

@@ -11,7 +11,10 @@ import type { MindContext, Recognition, Segment } from "./types.js";
  *     query's own cut cannot, and records sub-leaf boundaries as `splits`.
  *
  *  Both O(n · maxGroup) bounded O(1) probes — never a scan of the corpus. */
-export declare function recognise(ctx: MindContext, bytes: Uint8Array): Recognition;
+export declare function recognise(
+  ctx: MindContext,
+  bytes: Uint8Array,
+): Recognition;
 /** Segment bytes using the geometry's own groupings — leaf-parent
  *  nodes from the perceived tree, with consecutive bare leaves merged
  *  into one segment.  Each segment's gist is perceived from its bytes