@hviana/sema 0.9.1 → 0.9.3

package/src/mind/reasoning.ts

@@ -8,10 +8,18 @@ import { bytesEqual, indexOf, latin1 } from "../bytes.js";
 import type { Attention, MindContext } from "./types.js";
 import { read, resolve } from "./primitives.js";
 import { countClusters } from "./attention.js";
-import { hubBound } from "./traverse.js";
+import {
+  coInstanceFiller,
+  guidedFirst,
+  hubBound,
+  namedContinuations,
+  offsetCanon,
+} from "./traverse.js";
+import { unspoken, type WindowIndex, windowIndex } from "./evidence.js";
 import { containsSpan, follow, haloSiblings, project } from "./match.js";
 import { joinWithBridge, pivotInto } from "./resonance.js";
 import {
+  closed,
   closeOver,
   type ClosureLayer,
   type Continuation,
@@ -102,6 +110,12 @@ export function walkLayer(
   // fire — the same visibility trade chooseNext documents.
   const bound = hubBound(ctx);
   const consumed = new Set<number>();
+  /** The windows each product of this derivation holds — what of the question
+   *  the derivation has already restated, so a later step is NAMED only by
+   *  question material none of them said. */
+  const spoken: WindowIndex[] = [];
+  const speak = (product: Uint8Array) =>
+    spoken.push(windowIndex(offsetCanon(ctx, product), ctx.space.maxGroup));
   /** `prev` lets a caller hand in an already-read reverse-edge list — hop 0
    *  reuses the guard's, below, instead of re-reading it. */
   const consumeNode = (
@@ -122,6 +136,7 @@ export function walkLayer(
   const begin = async (d0: DerivationState): Promise<boolean> => {
     const answer = d0.product;
     startedFrom = answer;
+    speak(answer);
     // 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
@@ -241,16 +256,12 @@ export function walkLayer(
   // 30 s); and raising it from 12 to 200 changed neither the answer nor
   // `pivotSteps` on the chain fixtures.
   const qv = pre.guide; // the response-wide guide IS the query's gist
-  // WHOSE EXTENSION IS THIS?  `voiced` is what the mechanism WITHHELD (the
-  // pipeline sends the used anchors' CONTINUATIONS, not their bytes), so a
-  // non-empty `voiced` means exactly what that note says: the grounding came
-  // from a mechanism that carries its own short `used` set (cast/join) and
-  // therefore OWNS the shape of its answer.  The further terms inside such a
-  // seat are legitimately followable (test/29 C3's `Mona Lisa` lives inside the
-  // voiced seat and leads on to a fact about neither analog), which the law
-  // expresses as the identity species of progress — `moves` — declared by the
-  // reporter and never inferred from the mechanism's name.
-  const producerOwnsShape = voiced.length > 0;
+  // NO PRODUCER OWNS THE NEXT STEP.  A grounding that declared what it voiced
+  // (cast/join) used to MOVE through any further term inside its answer,
+  // unasked — `Who is the director of The Jerk?` grounded by CAST walked on to
+  // `The country of citizenship of Carl Reiner is American.`  What it voiced
+  // still bounds what may be pivoted through (`voiced`, pivotInto); whether a
+  // step is taken is the naming rule below, the same for every mechanism.
   let hop = 0;
   let t: ReturnType<Rationale["enter"]> | undefined;
   // WHAT THE OFFERED STEP WOULD BE.  The law decides, so the accepted step is
@@ -402,16 +413,47 @@ export function walkLayer(
       );
       return null;
     }
+    // THE STEP THE QUESTION ASKS FOR.  The hop `follow` took is NAMED when one
+    // of its establishing contexts is witnessed by what of the question no
+    // product has restated yet, plus the pivot itself (traverse.ts,
+    // `namedContinuations`): `Where was the place of death of the director of
+    // film Beat Girl?` names `Edmond T. Gréville place of death` once the first
+    // hop has restated `director` and `Beat Girl` — and `Who is the father of
+    // Frederick II?` names nothing past `Peter III of Aragon`, because `father`
+    // was restated by the hop that reached him.  A named step MOVES to structure
+    // the question asked for, so it is admitted on that ground; an unnamed one
+    // must carry the question's remainder as before, and from a CLOSED
+    // derivation — nothing left owed — it is not offered at all: the question
+    // asks for no further step, and the law would otherwise admit any.
+    const asked = ctx._edgeAsked;
+    let named = false;
+    if (asked !== null) {
+      const unsaid = {
+        bytes: asked.bytes,
+        index: unspoken(asked.index, spoken),
+      };
+      const names = namedContinuations(ctx, pivot, unsaid);
+      const hop = guidedFirst(ctx, pivot);
+      named = names !== null && hop !== undefined && names.includes(hop);
+    }
+    if (!named && closed(d)) {
+      ctx.trace?.step(
+        "pivotUnasked",
+        [rItem(cur, "answer"), rNode(ctx, pivot, "pivot")],
+        [rItem(fc, "withheld")],
+        "the derivation owes nothing and the question names no further step — not offered",
+      );
+      return null;
+    }
     pending = { kind: "pivot", cur, pivot, fc };
-    // Offered with the identity species ONLY when the grounding declared what it
-    // speaks for; otherwise the law requires this step to carry question
-    // material the grounding left unaccounted, which is the drift the extension
-    // tests pin — refused by the law's own measure, not by a private window
-    // test.
+    // Offered with the identity species when the question names the step;
+    // otherwise the law requires this step to carry question material the grounding left
+    // unaccounted, which is the drift the extension tests pin — refused by the
+    // law's own measure, not by a private window test.
     return {
       product: fc,
       contains: true,
-      reaches: producerOwnsShape,
+      reaches: named,
       cost: STEP,
     };
   };
@@ -422,6 +464,7 @@ export function walkLayer(
     witnesses: ReadonlyArray<Witness>,
   ): void => {
     meterTransition(ctx, before, after, witnesses);
+    speak(after.product);
     const p = pending;
     pending = null;
     if (p === null) return;
@@ -786,6 +829,28 @@ export function fusionLayer(
       // again would only restate it.  Deliberately NOT a magnitude measure:
       // it fires on exact content-addressed recurrence, not on how strongly
       // the root resonates.
+      // ANOTHER INSTANCE IS NOT ANOTHER TOPIC.  A root the question witnesses
+      // in every byte but one contiguous span is the question's own frame
+      // around a different filler (evidence.ts, `coInstanceFiller`): the climb
+      // committed `Where was Peter Jackson born?` as a second point of
+      // `Where was the director of film Beat Girl born?` on the frame windows
+      // alone, and fusing it voiced Peter Jackson's birthplace beside the
+      // answer.  Such a root says what the question's relation IS (traverse.ts,
+      // `byCoInstance`), never what it asks about.
+      const asked = ctx._edgeAsked;
+      if (asked !== null) {
+        const form = read(ctx, root.anchor, 2 * query.length);
+        const co = coInstanceFiller(ctx, form, [asked.index], asked.bytes);
+        if (co !== null) {
+          ctx.trace?.step(
+            "coInstanceRoot",
+            [rNode(ctx, root.anchor, "point", root.vote)],
+            [rItem(form.subarray(co.span[0], co.span[1]), "filler")],
+            "the question witnesses this point in every byte but one filler of its own — another instance of the question's frame, not a further topic",
+          );
+          continue;
+        }
+      }
       const cont = await follow(ctx, root.anchor, qv);
       if (
         cont !== null && cont.length > 0 &&

package/src/mind/resonance.ts

@@ -307,8 +307,9 @@ export async function joinWithBridge(
  *  Shakespeare" (id 676) and the pivot hopped through "speare" (id 606, not
  *  in `consumed`) straight into that analog's own biography, which is exactly
  *  what the comparison had refused to voice.  The rule is CONTAINMENT, not
- *  overlap, so C3's genuine further hop — "Mona Lisa", a term inside the seat
- *  sentence but part of NEITHER analog — still fires. */
+ *  overlap, so C3's further term — "Mona Lisa", inside the seat sentence but
+ *  part of NEITHER analog — stays a candidate; whether the walk steps through
+ *  it is the naming rule's decision (reasoning.ts, evidence.md). */
 export async function pivotInto(
   ctx: MindContext,
   answer: Uint8Array,