@hviana/sema 0.9.2 → 0.9.3

package/src/mind/mechanisms/recall.ts

@@ -17,10 +17,14 @@ import { gistOf, read, resolve } from "../primitives.js";
 import { indexOf } from "../../bytes.js";
 import {
   allWindowsAreScaffolding,
+  answersOtherQuestions,
   askedEvidence,
+  canonHeldPoints,
+  coInstanceFiller,
   corpusN,
   guidedFirst,
   hubBound,
+  namedContinuations,
 } from "../traverse.js";
 import {
   follow,
@@ -108,13 +112,13 @@ export async function recallByResonance(
   // constituent bar is the same two-quanta (2W) reading confluence binds
   // under, nested recognitions collapse to their MAXIMAL span, and two
   // distinct maximal arguments mean the query asks about neither alone.
-  if (qId === null) {
-    const W2 = 2 * ctx.space.maxGroup;
-    const args = pre.rec.sites.filter((s) =>
-      s.end - s.start >= W2 &&
-      s.end - s.start < query.length &&
-      ctx.store.hasNext(s.payload)
-    );
+  // The argument binding, given its candidate arguments (`args`) and the
+  // recognised fragments that answer other questions (`strangerIds`).
+  const W2 = 2 * ctx.space.maxGroup;
+  const bindArgument = async (
+    args: Array<{ start: number; end: number; payload: number }>,
+    strangerIds: ReadonlySet<number>,
+  ) => {
     // Maximal spans by one sorted sweep (starts ascending, ties longest
     // first): every earlier span starts at or before s, so s is contained
     // exactly when the running max end already covers it.  O(m log m) — a
@@ -140,13 +144,25 @@ export async function recallByResonance(
     // binding to the argument's continuation would answer past content
     // the query itself already carries forward.  Derived from the same W2
     // bar the argument itself is held to, never a separate tuned number.
+    // A fragment that answers other questions is not such a piece.
     const hasSubstantialOutside = maximal.length === 1 &&
       pre.rec.sites.some((s) =>
-        s.end - s.start >= W2 &&
+        s.end - s.start >= W2 && !strangerIds.has(s.payload) &&
         (s.end <= maximal[0].start || s.start >= maximal[0].end)
       );
     if (maximal.length === 1 && !hasSubstantialOutside) {
       const arg = maximal[0];
+      // An argument whose several continuations the question names none of
+      // outright would be followed by popularity.  Another instance of the
+      // question may name one (traverse.ts, `byCoInstance`), and its
+      // proposals are the consensus climb's points — so the climb is asked
+      // for first, exactly where the choice would otherwise be blind.
+      const asked = ctx._edgeAsked;
+      if (
+        asked !== null && asked.points === undefined &&
+        ctx.store.nextFirst(arg.payload, 2).length >= 2 &&
+        namedContinuations(ctx, arg.payload, asked) === null
+      ) await pre.attention();
       const g = await follow(ctx, arg.payload, queryGist);
       // The same "no restated fragment" guard tier 2 applies below (§ "the
       // anchor cleared the consensus floor..."): a followed continuation
@@ -176,6 +192,53 @@ export async function recallByResonance(
         );
       }
     }
+    return null;
+  };
+  let canonArgumentPending = false;
+  let strangers: ReadonlySet<number> = new Set();
+  if (qId === null) {
+    const recognised = pre.rec.sites.filter((s) =>
+      s.end - s.start >= W2 &&
+      s.end - s.start < query.length &&
+      ctx.store.hasNext(s.payload)
+    );
+    // An argument must lead somewhere FOR THIS QUESTION: a fragment whose
+    // continuations the question names none of answers other questions
+    // (traverse.ts) — `director`, inside `When was the director of film Jinpa
+    // born?`, bound the most-poured of fifty-five directors.  Such a fragment
+    // is no argument, and no independent piece of the query either.
+    const strangerIds = new Set<number>();
+    for (const s of recognised) {
+      if (
+        answersOtherQuestions(ctx, s.payload, query.length, s.end - s.start)
+      ) strangerIds.add(s.payload);
+    }
+    const args = recognised.filter((s) => !strangerIds.has(s.payload));
+    if (args.length === 0 && strangerIds.size > 0) {
+      if (ctx.meter) ctx.meter.unaskedFragments += strangerIds.size;
+      ctx.trace?.step(
+        "unaskedFragments",
+        recognised.filter((s) => strangerIds.has(s.payload)).map((s) =>
+          rItem(query.subarray(s.start, s.end), "fragment", s.payload, [
+            s.start,
+            s.end,
+          ])
+        ),
+        [],
+        "the only arguments are pieces of other forms whose continuations the question names none of — they answer other questions",
+      );
+    }
+    const bound = await bindArgument(args, strangerIds);
+    if (bound !== null) return bound;
+    // NO ARGUMENT BY BYTES IS NOT NO ARGUMENT.  Recognition matches bytes, so
+    // `Man At Bath` (2Wiki title-cases its questions) is no site of the stored
+    // `Man at Bath`.  When nothing recognised can bind, the points the
+    // consensus climb reaches that the question holds under the response's
+    // equivalence are arguments too (traverse.ts, `canonHeldPoints`) — read
+    // after the clean-resonance tier, which answers a near-identical question
+    // without any climb.
+    canonArgumentPending = ctx.canon !== null && args.length === 0;
+    strangers = strangerIds;
   }
 
   // The response's ONE top-k read (Precomputed.resonance) — the same list the
@@ -272,6 +335,20 @@ export async function recallByResonance(
         Math.sqrt(otherLen / Math.max(1, query.length)),
     );
 
+  // The argument the question holds only under the response's equivalence
+  // (above).  Not gated on the whole-query resonance: a question whose only
+  // argument is a case variant (`… film Man At Bath work at?`) resonates
+  // below the significance bar as a whole.
+  if (canonArgumentPending) {
+    await pre.attention();
+    const held = canonHeldPoints(ctx, W2).filter((s) =>
+      ctx.store.hasNext(s.payload) &&
+      !answersOtherQuestions(ctx, s.payload, query.length, s.end - s.start)
+    );
+    const bound = await bindArgument(held, strangers);
+    if (bound !== null) return bound;
+  }
+
   // 2. Scaffolding-dominated.
   if (top.score >= sig) {
     // The committed points of attention ARE the shared climb's roots (same
@@ -403,7 +480,28 @@ export async function recallByResonance(
         forest[0].anchor,
         query.length * ctx.space.maxGroup + 1,
       );
-      if (g !== null && voicesDisplacedFiller(ctx, query, anchorBytes, g)) {
+      // …and the same refusal read from the anchor's side: an anchor the query
+      // witnesses in every byte but one filler of its own is ANOTHER INSTANCE
+      // of the question (traverse.ts, `coInstanceFiller`).  The query-side
+      // reading above needs the shared frame to dominate the QUERY, which a
+      // long slot defeats: `Where was the performer of song God (John Lennon
+      // Song) born?` elected `Where was Nicki Minaj (Nicki Minaj Song) born?`
+      // and answered Nicki Minaj's birthplace.
+      const asked = ctx._edgeAsked;
+      const co = asked === null
+        ? null
+        : coInstanceFiller(ctx, anchorBytes, [asked.index], asked.bytes);
+      if (co !== null) {
+        ctx.trace?.step(
+          "coInstanceAnchor",
+          [rItem(query, "query"), rNode(ctx, forest[0].anchor, "anchor")],
+          [rItem(anchorBytes.subarray(co.span[0], co.span[1]), "filler")],
+          "refused — the anchor is another instance of the question's frame, " +
+            "and its continuation speaks of its own filler",
+        );
+      } else if (
+        g !== null && voicesDisplacedFiller(ctx, query, anchorBytes, g)
+      ) {
         ctx.trace?.step(
           "displacedFiller",
           [rItem(query, "query"), rNode(ctx, forest[0].anchor, "anchor")],

package/src/mind/mechanisms/reference.ts

@@ -37,6 +37,8 @@
 import type { MindContext } from "../types.js";
 import type { FrameInstance } from "../match.js";
 import { carriesFillers, distinct, follow, substituteAll } from "../match.js";
+import { resolve } from "../primitives.js";
+import { hubBound } from "../traverse.js";
 import { dominates } from "../../geometry.js";
 import { bytesEqual } from "../../bytes.js";
 import { restates } from "../derivation.js";
@@ -186,7 +188,6 @@ export async function bindReference(
   if (!distinct(referents)) {
     return fail("two slots name the same bytes — the binding is ambiguous");
   }
-
   // ── THE LICENCE ────────────────────────────────────────────────────────
   // Every instance must agree, against the first, that its continuation is its
   // own fillers carried through one fixed form.  Unanimity, exactly as the
@@ -199,11 +200,33 @@ export async function bindReference(
   // discard them.  Each goes through the shared projection, so an ambiguous
   // instance is disambiguated exactly as it would be anywhere else.
   const leadsNowhere = "an instance of the frame leads nowhere";
+  // A FACT FILED UNDER ITS FILLER IS NOT A CARRIAGE.  When an instance's
+  // filler is itself a stored context leading to that instance's answer, the
+  // answer is something the corpus knows ABOUT that filler (`The place of
+  // birth of Peter Jackson is Wellington.` is a continuation of `Peter
+  // Jackson`), not a form any occupant takes — and two such facts can agree
+  // by chance (two people born in Wellington).  `Run gcc hello.c` is filed
+  // under the question alone.
+  const filedUnderFiller = (inst: FrameInstance, cont: Uint8Array): boolean => {
+    const c = resolve(ctx, cont);
+    if (c === null) return false;
+    return inst.slots.some((s) => {
+      const f = resolve(ctx, s.filler);
+      return f !== null &&
+        ctx.store.nextFirst(f, hubBound(ctx)).includes(c);
+    });
+  };
   const first = await follow(ctx, frame[0].id, pre.guide);
   if (first === null || first.length === 0) return fail(leadsNowhere);
+  if (filedUnderFiller(frame[0], first)) {
+    return fail("the frame's answer is a fact filed under its filler");
+  }
   for (let i = 1; i < frame.length; i++) {
     const cont = await follow(ctx, frame[i].id, pre.guide);
     if (cont === null || cont.length === 0) return fail(leadsNowhere);
+    if (filedUnderFiller(frame[i], cont)) {
+      return fail("the frame's answer is a fact filed under its filler");
+    }
     if (
       !carriesFillers(first, fillersOf(frame[0]), cont, fillersOf(frame[i]))
     ) {

package/src/mind/mind.ts

@@ -335,7 +335,9 @@ export class Mind implements MindContext {
    *  reverse-recall disambiguation via `chooseAmong`. */
   _edgeGuide: Vec | null = null;
   /** See {@link MindContext._edgeAsked}. */
-  _edgeAsked: { bytes: Uint8Array; index: WindowIndex } | null = null;
+  _edgeAsked:
+    | { bytes: Uint8Array; index: WindowIndex; points?: readonly number[] }
+    | null = null;
   /** Per-response memo of {@link chooseNext} picks — ensures every mechanism
    *  of a single response follows the SAME continuation for each ambiguous
    *  context node. */

package/src/mind/pipeline-mechanism.ts

@@ -225,7 +225,21 @@ export class Precomputed {
     return this._attention ??= this.shared(
       "attention",
       () => climbAttentionAll(this.ctx, this.query, this.k),
-    );
+    ).then((read) => {
+      // The climb's scored anchors are what the exact tier reads co-instances
+      // of the question from (traverse.ts, `relationFrames`): the
+      // approximate climb proposes, witnessing decides.
+      // A pick made before the points existed read less evidence than one
+      // made after, so the response's pick memo starts over (traverse.ts,
+      // guidedNext: a pick is a function of the store, the guide AND the
+      // points — traced and untraced responses must agree).
+      const asked = this.ctx._edgeAsked;
+      if (asked !== null && asked.points === undefined) {
+        asked.points = read.ranked.map((a) => a.anchor);
+        this.ctx._edgeChoice.clear();
+      }
+      return read;
+    });
   }
 
   private _weave?: Promise<WeaveInfo>;

package/src/mind/pipeline.ts

@@ -773,13 +773,14 @@ export async function think(
   // Reading the used anchors' OWN bytes here says something stronger and
   // wrong: that nothing INSIDE what was voiced may be pivoted through.  A
   // comparison's seat sentence legitimately contains further terms with
-  // their own unrelated facts, and C3 pins exactly that — `Mona Lisa`, inside
-  // the voiced seat `The Mona Lisa was painted by Leonardo da Vinci.`, leads
-  // on to `Mona Lisa hangs in the Louvre`, which is about neither analog.
+  // their own unrelated facts — `Mona Lisa`, inside the voiced seat `The Mona
+  // Lisa was painted by Leonardo da Vinci.`, leads on to `Mona Lisa hangs in
+  // the Louvre`, which is about neither analog (test/29 C3: a candidate the
+  // walk takes only when the question names it).
   // The withheld content is the used anchors' CONTINUATIONS, so that is what
   // the containment rule reads: `speare` is contained in `Shakespeare wrote
   // 39 plays` and stays refused, while `Mona Lisa` appears in no withheld
-  // continuation and the genuine further hop fires.
+  // continuation and stays a candidate.
   //
   // Only a mechanism carrying its own `used` set (cast/join) gets this: there
   // `preConsumed` is a deliberate, short list of the anchors the answer

package/src/mind/reasoning.ts

@@ -9,6 +9,7 @@ import type { Attention, MindContext } from "./types.js";
 import { read, resolve } from "./primitives.js";
 import { countClusters } from "./attention.js";
 import {
+  coInstanceFiller,
   guidedFirst,
   hubBound,
   namedContinuations,
@@ -255,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
@@ -439,7 +436,7 @@ export function walkLayer(
       const hop = guidedFirst(ctx, pivot);
       named = names !== null && hop !== undefined && names.includes(hop);
     }
-    if (!named && !producerOwnsShape && closed(d)) {
+    if (!named && closed(d)) {
       ctx.trace?.step(
         "pivotUnasked",
         [rItem(cur, "answer"), rNode(ctx, pivot, "pivot")],
@@ -449,15 +446,14 @@ export function walkLayer(
       return null;
     }
     pending = { kind: "pivot", cur, pivot, fc };
-    // Offered with the identity species when the grounding declared what it
-    // speaks for, or when the question names the step; otherwise the law
-    // requires this step to carry question material the grounding left
+    // 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 || named,
+      reaches: named,
       cost: STEP,
     };
   };
@@ -833,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,