@hviana/sema 0.9.2 → 0.9.3

package/docs/architecture/evidence.md

@@ -2,8 +2,11 @@
 
 > **Law:** a stored form is identified by the material at hand when every one of
 > its bytes lies in a W-window that material holds — in any order, at any place,
-> and wherever each piece of the material came from. A step the question did not
-> name has to be paid for by material the question still owes.
+> and wherever each piece of the material came from. A form witnessed in every
+> byte but one contiguous span of content is ANOTHER INSTANCE of the same
+> question: it says what the question's relation is, never what it asks about. A
+> step the question did not name has to be paid for by material the question
+> still owes.
 
 ## The operation — `src/mind/evidence.ts`
 
@@ -13,7 +16,8 @@
 (which finds containers). It is exact, deterministic and linear: one index per
 source and one probe per window of the form. A window is credited to the LAST
 source that holds it, so source 0 (the question) is credited only with what
-nothing else at hand supplies. A form shorter than W is never witnessed.
+nothing else at hand supplies. A form shorter than W is never witnessed. The
+form's own unwitnessed bytes come back as its `residue`.
 
 ## Where the material comes from
 
@@ -35,15 +39,119 @@ question nor the first hop's fact, only by both. Measured over 5,236 held-out
 2WikiMultihopQA compositional questions, such a context is wholly witnessed by
 the question alone 69 times, and by the question plus the first hop 2,153 times.
 
+An establishing context is a DEPOSITED context: a predecessor with structural
+parents or containers is a span interned inside bigger forms, and it inherits
+their edges. Witnessing such a fragment named every fact it is a piece of (the
+fragment `born?` named nine strangers' birthplaces on the 2Wiki fixture with
+one-hop questions), so it never counts — the same structural predicate
+`pivotInto` reads.
+
+## Another instance of the question — `coInstanceFiller`, `byCoInstance`
+
+The question rarely spells the relation the way the corpus does.
+`When was the
+director of film Jinpa born?` reaches `Pema Tseden`, whose fact is
+established by `Pema Tseden date of birth`: no window joins `born` to
+`date of birth`, so nothing is witnessed. What joins them is another instance of
+the question.
+
+A **co-instance** is a stored context that shares the question's FRAME, its
+opening and its close byte for byte under the response's equivalence, around ONE
+different filler, and whose filler is a thing the corpus knows: a stored context
+with continuations of its own. `Where was Peter Jackson born?`, read against
+`Where was the director of film Beat Girl born?`, shares `Where was` and `born?`
+and leaves `Peter Jackson`. Three conditions make the reading exact, and each
+was measured necessary:
+
+- **Order.** A frame is not a bag of windows. Read order-free,
+  `Lyon is a city in France` passes for an instance of
+  `what if the capital of France were Lyon?`, which NAMES Lyon, and a
+  coincidental window inside a filler splits it.
+- **The filler is an entity.**
+  `Explain how photosynthesis converts sunlight
+  into chemical energy.` shares
+  a frame with `Explain how photosynthesis
+  works.`, but its slot holds a
+  description of the frame's own subject, and it answers the question. The
+  filler is the longest stored context opening where the slot opens (up to one
+  window earlier: the `T` of `Taika` can sit in the question's `as t`).
+- **The frame is unsaid.** Every frame window must be held by the material, so
+  on the walk a frame a product already said cannot name a second step.
+  `Who is the father of …?` names the second hop of
+  `Who is the father of the director of film Beat Girl?` and not the
+  grandfather. Scaffolding windows are exempt, because they are nobody's
+  evidence (`is` in `Which country Leo Mittler is from?`).
+
+The co-instance's continuation is established by other contexts too
+(`Peter Jackson place of birth`), and the one holding the filler spells the
+relation the corpus's way: a RELATION FRAME, `` · `place of birth`. A frame
+counts only where two co-instances spell it alike. One alignment agrees with
+nothing, which is the bar `reference` holds a frame to (`MIN_INSTANCES`). The
+exact tier's second reading (`byCoInstance`, run only when no establishing
+context is witnessed outright) puts the node the derivation stands on in each
+frame and looks the result up by content: `Edmond T. Gréville place of birth`
+exists, so its continuation is named. Neither the equivalence nor the frame is
+stored as a unit, and nothing is approximate.
+
+**The proposals are the consensus climb's.** The climb already scores the stored
+forms the question's regions reach, and the co-instances are among its points.
+Its scored anchors are published on the question when it runs, and the tier
+reads the `chainReach(W)` most corroborated of them. It climbs nothing of its
+own. A first version climbed every question window itself and cost the 116-query
+battery +16% climb visits for zero namings. Two consequences follow, both
+pinned:
+
+- A pick made before the climb read less evidence than one made after, so the
+  response's pick memo is cleared when the points arrive. Traced and untraced
+  responses agree.
+- Recall's argument binding, which runs before the climb, asks for it first when
+  the argument has several continuations and the question names none outright.
+  That is exactly where the choice would otherwise be blind.
+
+A question the corpus holds verbatim is its own instance and reads no frames.
+Frames are read once per question (and once per walk material), and every node
+pays only the exact lookups.
+
+The same reading refuses the co-instance as an ANSWER, because its own
+continuation speaks of its own filler. Recall's consensus-anchor tier does not
+ground it: `Where was the performer of song God (John Lennon Song) born?`
+elected `Where was Nicki Minaj (Nicki Minaj Song) born?`. Fusion does not fuse
+it as a further topic. A CAST comparison does not take it as its dominant: it
+set `Where was Shakira (Shakira Song) born?` against `John Lennon` and voiced
+Shakira's birthplace.
+
+## Arguments the question holds under the response's equivalence
+
+Recognition matches bytes and the query fold's own boundaries. 2Wiki title-cases
+its questions (`… of film Man At Bath work at?` for the stored `Man at Bath`),
+and a title inside a question lines up with none of the fold's cuts. When
+recall's argument binding finds no recognised argument, the stored forms the
+consensus climb reaches become candidates if the question holds them under the
+response's equivalence (`canonHeldPoints`: canonical containment,
+offset-preserving, so the span is the question's own). The approximate climb
+proposes and exact containment decides. This is read after the clean-resonance
+tier, so a near-identical question pays no climb for it. The canonical-form
+index it relies on is the one the trainer builds after training
+(`buildCanonIndex`, progress.ts).
+
+A fragment that answers other questions is no argument and no independent piece
+of the question either. It is set aside BEFORE the binding looks for one maximal
+argument, so `director` no longer cancels `Man at Bath`. The same predicate
+gates CAST's redirection: the substitute `ong)?`, the tail of every
+`… (… Song)?` question, voiced a stranger's birthplace.
+
 ## Its consumers
 
-| Where                             | What it decides                                                                                                                                                                                                                                                                                                                                              |
-| --------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| `chooseNext` (traverse.ts)        | **The exact tier.** It names the continuation one of whose establishing contexts (other than the node) is witnessed by the question plus the node, with the question supplying at least one window the node does not. It ranks first among the readings; the distributional ladder decides only when nothing is named, or among continuations named equally. |
-| `askedEvidence` (traverse.ts)     | The question spans that named a pick. A mechanism projecting through the pick accounts for them, because evidence travels (mechanism-market.md). Recall's argument binding uses this.                                                                                                                                                                        |
-| `preConsumed` (pipeline.ts)       | When a grounding does not declare `used`, what it spoke for is the forms inside its answer that the question already holds. The entity the answer added stays pivotable.                                                                                                                                                                                     |
-| The walk (reasoning.ts)           | A pivot is NAMED when one of its continuation's establishing contexts is witnessed by what of the question no product has said yet, plus the pivot. A named pivot MOVES. An unnamed one is offered only while the derivation still owes something, and the law then decides by carrying.                                                                     |
-| Cover sites (mechanisms/cover.ts) | A FRAGMENT is a form that sits inside other forms, has several continuations, and leaves at least one window of the question beyond it. It answers other questions, so it leads somewhere for this question only when the question names one of its continuations.                                                                                           |
+| Where                                                                             | What it decides                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
+| --------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `chooseNext` (traverse.ts)                                                        | **The exact tier.** It names the continuation one of whose establishing contexts (other than the node) is witnessed by the question plus the node, with the question supplying at least one window the node does not. It ranks first among the readings; the distributional ladder decides only when nothing is named, or among continuations named equally.                                                                                                                     |
+| `askedEvidence` (traverse.ts)                                                     | The question spans that named a pick. A mechanism projecting through the pick accounts for them, because evidence travels (mechanism-market.md). Recall's argument binding uses this.                                                                                                                                                                                                                                                                                            |
+| `preConsumed` (pipeline.ts)                                                       | When a grounding does not declare `used`, what it spoke for is the forms inside its answer that the question already holds. The entity the answer added stays pivotable.                                                                                                                                                                                                                                                                                                         |
+| The walk (reasoning.ts)                                                           | A pivot is NAMED when one of its continuation's establishing contexts is witnessed by what of the question no product has said yet, plus the pivot. A named pivot MOVES. An unnamed one is offered only while the derivation still owes something, and the law then decides by carrying. No grounding owns the next step: a CAST grounding used to move through any term inside its answer, unasked (`Who is the director of The Jerk?` walked on to Carl Reiner's citizenship). |
+| `answersOtherQuestions` (traverse.ts) — cover sites and recall's argument binding | A FRAGMENT is a form that sits inside other forms, has several continuations, and leaves at least one window of the question beyond it. It answers other questions, so it leads somewhere for this question only when the question names one of its continuations. Recall's binding read the same fragment (`director`) and voiced the most-poured stranger's fact.                                                                                                              |
+| `byCoInstance` (traverse.ts)                                                      | The exact tier's second reading: the relation read off another instance of the question, transferred to the node by an exact substitution.                                                                                                                                                                                                                                                                                                                                       |
+| Recall's consensus anchor, fusion roots                                           | A co-instance of the question is never voiced as its answer, nor fused as a further topic.                                                                                                                                                                                                                                                                                                                                                                                       |
+| CAST comparison (mechanisms/cast.ts)                                              | A comparison voices two structures, so the question must evidence the analog with a window of its own: neither inside the dominant's runs nor scaffolding. `father of Frederick II?` evidenced `Peter III of Aragon father` only with `father` and `of`, and the comparison glued that bare question onto the answer.                                                                                                                                                            |
 
 A cover span made of nothing but scaffolding (every window a hub,
 `scaffoldSpans`) is not accounted. The form recognised there, such as the song
@@ -85,24 +193,44 @@ memoized per node per question.
 
 ## Measured
 
-| Measure                                                                                | Before | After  |
-| -------------------------------------------------------------------------------------- | ------ | ------ |
-| 2Wiki held-out fixture (300 rows, deposited as `wiki2.ts` does), compositional correct | 13/133 | 47/133 |
-| Same fixture, pivot steps                                                              | 3      | 90+    |
-| Same fixture, inference correct                                                        | 8/37   | 6/37   |
-
-The inference drop is real. Two hops of `father` from a question that says
-`father` once, as in `paternal grandfather`, used to be reached by
-over-extension and are no longer. The store holds no evidence that `grandfather`
-composes `father` twice.
-
-On the 31.7M-node store's 116-query battery, two answers became correct
-(`What country is Jerry Bock a citizen of?` and
-`What is the country of citizenship of Frederick II?`), two lost a junk
-composition, three changed between wrong answers, and no correct answer was
-lost. CPU was 150 s against two baseline runs of 139 s and 166 s, inside the
-noise. The deterministic read counters rose about 20% (`bytesRead`,
-`nodeRecords`), with ANN queries unchanged.
+2Wiki held-out fixture: the evidence triples of 300 validation rows, deposited
+as `wiki2.ts` does, with the canonical-form index built as the trainer builds
+it, and asked the rows' own composed questions. Same evidence "plus instances":
+261 one-hop questions about OTHER entities, built from other validation rows by
+replacing the first hop's phrase with its referent
+(`Where was the director of film X born?` → `Where was Óskar Jónasson born?`)
+and answered with the second hop's fact. No test entity has one.
+
+| Compositional correct (of 133) | Witnessing only (655b192) | Final |
+| ------------------------------ | ------------------------- | ----- |
+| Fixture                        | 52                        | 56    |
+| Plus instances                 | 41                        | 89    |
+
+The first hop is now right on 114 and 109 of the 133. Of the first hops still
+wrong, most name the entity differently from the corpus (`Clara Novello` for
+`Clara Anastasia Novello`). That is an alias, which no byte reading recovers.
+
+Removing CAST's unasked step cost six right answers on the fixture without
+instances: second hops that were right paraphrases taken without evidence
+(`work at`, `is from`, `When was … born`). The same licence produced the Carl
+Reiner extension on the trained store. Without an instance, nothing names those
+relations, and the chain stops at the first hop. The answers gained plus
+instances are those relations: `born` → place of birth, `Why did … die` → cause
+of death, `study`/`graduate from` → educated at, `work at` → employer, `is from`
+→ country of citizenship.
+
+The inference count stays low. Two hops of `father` from a question that says
+`father` once, as in `paternal grandfather`, are not composed: the store holds
+no evidence that `grandfather` composes `father` twice.
+
+On the 31.7M-node store's 116-query battery, two dialogue answers changed
+(neither was correct before). The deterministic read counters rose about 4%
+(`bytesRead`, `ancestorVisits`, `edgeProbes`), with ANN queries up 1%. CPU on
+this workstation varies by ±15% between back-to-back runs of one build, and
+paired runs read 163 s against 152 s and 171 s, then 223 s against 203 s under
+outside load. The co-instance tier read 190 forms over the battery and named
+nothing there: on that store a frame's windows are scaffolding, and the one-hop
+questions it would need are not in the corpus.
 
 ## Pins
 
@@ -110,4 +238,19 @@ noise. The deterministic read counters rose about 20% (`bytesRead`,
   most-poured one. The second hop is named by the question plus the introduced
   entity, whatever grounded the first hop. A question that names no further step
   is not extended. A fragment voices none of its continuations unless the
-  question names one. Each assertion was verified by mutation.
+  question names one, in the cover and in recall's argument binding. A
+  comparison needs two things named. An argument held only under the response's
+  equivalence binds. Each assertion was verified by mutation.
+- `test/155` — the relation read off another instance of the frame; absent
+  without two instances that agree; refused for a partly shared frame; never
+  voiced as the answer; a frame a product already said names no further step; a
+  description in the slot is no other instance; traced and untraced responses
+  agree; fusion does not fuse a co-instance, nor does a comparison take one as
+  its dominant. Verified by mutation.
+- `test/76` — a fact the corpus files under an instance's filler is no carriage:
+  `reference` does not construct one for a new referent.
+- `test/29` C3 — a further hop inside a comparison's seat waits to be asked.
+- Unpinned, measured only at fixture scale. Excluding fragments from
+  establishing contexts is worth 16 answers on the fixture with one-hop
+  questions. Refusing a fragment as CAST's redirection substitute is worth four.
+  Fragments with inherited edges appear only at that scale.

package/jsr.json

@@ -1,6 +1,6 @@
 {
   "$schema": "https://jsr.io/schema/config-file.v1.json",
   "name": "@hviana/sema",
-  "version": "0.9.2",
+  "version": "0.9.3",
   "exports": "./src/index.ts"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hviana/sema",
-  "version": "0.9.2",
+  "version": "0.9.3",
   "description": "Sema: a non-parametric, instance-based reasoning system.",
   "repository": {
     "type": "git",

package/src/meter.ts

@@ -275,6 +275,12 @@ export class Meter {
    *  came back at the √N cap, or its predecessor budget ran out before every
    *  continuation was asked about — the distributional ladder decided. */
   askedReadsSaturated = 0;
+  /** Picks named by a CO-INSTANCE of the question — another instance of its
+   *  frame whose continuation carries the relation over to this node by an
+   *  exact substitution (traverse.ts, `byCoInstance`). */
+  coInstanceNamings = 0;
+  /** Proposed co-instances that tier read and witnessed. */
+  coInstanceReads = 0;
   /** Cover sites dropped as FRAGMENTS whose several continuations the question
    *  names none of (mechanisms/cover.ts). */
   unaskedFragments = 0;

package/src/mind/evidence.ts

@@ -63,6 +63,12 @@ export interface Witnessing {
   spans: Array<[number, number]>;
   /** Bytes of source 0 inside `spans`. */
   bytes: number;
+  /** The form's own bytes no source witnesses, as merged spans of the FORM —
+   *  empty exactly when `complete`.  ONE residue span is the shape of a
+   *  co-instance: the same frame around a different filler (`When was Peter
+   *  Jackson born?` read against `When was the director of film Jinpa
+   *  born?` leaves `Peter Jackson`). */
+  residue: Array<[number, number]>;
 }
 
 /** Witness `form` against `sources` (their window indexes, same order).  A
@@ -73,8 +79,14 @@ export function witness(
   indexes: ReadonlyArray<WindowIndex>,
   W: number,
 ): Witnessing {
-  const none: Witnessing = { complete: false, spans: [], bytes: 0 };
-  if (form.length < W || indexes.length === 0) return none;
+  if (form.length < W || indexes.length === 0) {
+    return {
+      complete: false,
+      spans: [],
+      bytes: 0,
+      residue: form.length > 0 ? [[0, form.length]] : [],
+    };
+  }
   const covered = new Uint8Array(form.length);
   const own: Array<[number, number]> = [];
   for (let o = 0; o + W <= form.length; o++) {
@@ -93,7 +105,13 @@ export function witness(
     covered.fill(1, o, o + W);
     if (from === 0) own.push([at, at + W]);
   }
-  for (let i = 0; i < form.length; i++) if (!covered[i]) return none;
+  const residue: Array<[number, number]> = [];
+  for (let i = 0; i < form.length; i++) {
+    if (covered[i]) continue;
+    const last = residue[residue.length - 1];
+    if (last !== undefined && last[1] === i) last[1] = i + 1;
+    else residue.push([i, i + 1]);
+  }
   own.sort((a, b) => a[0] - b[0]);
   const spans: Array<[number, number]> = [];
   for (const [s, e] of own) {
@@ -103,5 +121,5 @@ export function witness(
   }
   let bytes = 0;
   for (const [s, e] of spans) bytes += e - s;
-  return { complete: true, spans, bytes };
+  return { complete: residue.length === 0, spans, bytes, residue };
 }

package/src/mind/mechanisms/cast.ts

@@ -15,10 +15,14 @@ import type { MindContext } from "../types.js";
 import type { Vec } from "../../vec.js";
 import { read } from "../primitives.js";
 import {
+  answersOtherQuestions,
   argmaxBy,
+  coInstanceFiller,
   corpusN,
   edgeAncestors,
   hubBound,
+  hubWindows,
+  offsetCanon,
   sharedReachMemo,
 } from "../traverse.js";
 import {
@@ -31,7 +35,7 @@ import {
 } from "../match.js";
 import { joinWithBridge } from "../resonance.js";
 import { CONCEPT, STEP } from "../graph-search.js";
-import { indexOf } from "../../bytes.js";
+import { indexOf, latin1 } from "../../bytes.js";
 import { consensusFloor, dominates } from "../../geometry.js";
 import { restates, unexplainedSpans } from "../derivation.js";
 import { rItem, rNode } from "../trace.js";
@@ -116,7 +120,7 @@ export interface CastResult {
  *  painted by Leonardo da Vinci.") must be seated by that establishing
  *  sentence, NOT by its own biography fact — voicing the bio leaks exactly
  *  what a comparison must keep out, and loses the embedded "Mona Lisa"
- *  term C3 relies on for a further hop.
+ *  term C3's further-hop candidate lives in.
  *
  *  The distinguishing signal is content-addressed, not a count: a genuine
  *  establishing predecessor's bytes CONTAIN id's own bytes — it names or
@@ -693,9 +697,22 @@ export async function counterfactualTransfer(
   // its own fact — so the same bar applies.  The displaced structure is only
   // recognised as the slot being overridden and is never voiced, so it is
   // deliberately not gated here.
+  // …and the substitute must lead somewhere FOR THIS QUESTION: a fragment
+  // whose continuations the question names none of answers other questions
+  // (traverse.ts, `answersOtherQuestions`).  `ong)?`, the tail of every
+  // `… (… Song)?` question, was "named" by `What is the place of birth of the
+  // performer of song Heaven (Namie Amuro Song)?`, and redirection voiced
+  // its most-poured stranger's birthplace.
+  const stranger = last !== undefined &&
+    answersOtherQuestions(
+      ctx,
+      last.point.anchor,
+      query.length,
+      last.run.qe - last.run.qs,
+    );
   if (
     last !== undefined && last.point !== dominant && displaced &&
-    voiceable(last.point)
+    voiceable(last.point) && !stranger
   ) {
     const g = await project(ctx, last.point.anchor, qv);
     if (g !== null) {
@@ -1084,6 +1101,41 @@ export async function counterfactualTransfer(
     : [];
   const cmpGaps = unexplainedSpans(query.length, cmpAccounted);
   const cmpMaxGap = cmpGaps.reduce((n, [s, e]) => Math.max(n, e - s), 0);
+  // TWO THINGS NAMED.  A comparison voices two structures, so the question
+  // must evidence the second one with material of its own: a W-window of the
+  // question that the analog holds — on its aligned runs, or anywhere in its
+  // own form under the response's equivalence (the witness reading,
+  // evidence.md) — and that is neither inside the dominant's runs nor corpus
+  // scaffolding (`hubWindows`, the reading of "what the question owes").
+  // `father of Frederick II?` reached `Peter III of Aragon father` through
+  // ` father`, which the dominant `Frederick II father` already holds, and
+  // ` of `, which every fact holds — one structure named, and the comparison
+  // glued the analog's bare question onto the answer (`…is Peter III of
+  // Aragon.Peter III of Aragon father`).  `How is ice like steel?` names
+  // `Ice is cold` with `ice `, a window no byte-exact run aligns (the case
+  // differs) and the dominant `Steel is hard` lacks.
+  const analogOwnsEvidence = (): boolean => {
+    if (bestAnalog === null) return false;
+    const W = ctx.space.maxGroup;
+    const hub = hubWindows(ctx, query);
+    const mine = runSpans(dominant);
+    const owns = (o: number): boolean =>
+      !hub[o] && !mine.some(([ms, me]) => o >= ms && o + W <= me);
+    for (const [s, e] of runSpans(bestAnalog.point ?? bestAnalog.src)) {
+      for (let o = s; o + W <= e; o++) if (owns(o)) return true;
+    }
+    const asked = ctx._edgeAsked;
+    if (asked === null) return false;
+    const form = offsetCanon(
+      ctx,
+      read(ctx, bestAnalog.anchor, asked.bytes.length * W),
+    );
+    for (let o = 0; o + W <= form.length; o++) {
+      const at = asked.index.get(latin1(form.subarray(o, o + W)));
+      if (at !== undefined && owns(at)) return true;
+    }
+    return false;
+  };
   // An analog that is not itself a directly ALIGNED point (point !== null —
   // its own runs are query bytes, the query NAMED it) was only reached
   // through a continuation hop or the structural-hub fallback.  Voicing
@@ -1208,9 +1260,24 @@ export async function counterfactualTransfer(
   // supply were never the ones that test is about.
   const cmpDismisses = !bestHalo &&
     dismissedKnownContent(ctx, query, cmpAccounted);
+  // …and the dominant must be something the question is ABOUT.  A co-instance
+  // of the question (traverse.ts, `coInstanceFiller`) is its frame around
+  // another filler, and its seat is that filler's own answer: `Where was the
+  // performer of song God (Lennon Song) born?` compared `Where was Shakira
+  // (Shakira Song) born?` with `John Lennon` and voiced Shakira's birthplace.
+  const asked = ctx._edgeAsked;
+  const dominantOtherInstance = asked !== null &&
+    coInstanceFiller(
+        ctx,
+        read(ctx, dominant.anchor, 2 * query.length + 1),
+        [asked.index],
+        asked.bytes,
+      ) !== null;
   if (
     bestAnalog !== null &&
     (bestHalo || analogNamed || rootTrusted) &&
+    analogOwnsEvidence() &&
+    !dominantOtherInstance &&
     !cmpDismisses &&
     queryScale(dominant.ctx.length) &&
     roots.length <= 1 &&
@@ -1346,6 +1413,13 @@ export async function counterfactualTransfer(
         ? `the best analog carries no halo-tier company evidence, was never ` +
           `named by the query, and no committed root's consensus vote ` +
           `clears the floor, so comparison refuses to voice it`
+        : dominantOtherInstance
+        ? `the dominant is another instance of the question's frame — its ` +
+          `seat is another filler's answer, not what the question asks about`
+        : !analogOwnsEvidence()
+        ? `the question evidences the analog only with windows the dominant ` +
+          `already holds or the corpus' scaffolding — it names one structure, ` +
+          `not two, so there is nothing to compare`
         : cmpDismisses
         ? `a frame-tier analog under an untrusted root dismisses stored ` +
           `query content its alignment never accounted for — comparison ` +

package/src/mind/mechanisms/cover.ts

@@ -19,9 +19,9 @@ import type {
 } from "../graph-search.js";
 import { read, resolve } from "../primitives.js";
 import {
+  answersOtherQuestions,
   guidedFirst,
   hubBound,
-  namedContinuations,
   scaffoldSpans,
 } from "../traverse.js";
 import { conceptHop } from "../match.js";
@@ -259,27 +259,11 @@ export const coverMechanism: PipelineMechanism = {
       );
     }
 
-    // A FRAGMENT ANSWERS OTHER QUESTIONS.  A recognised form that sits inside
-    // other forms (it has structural parents or containers) holds continuations
-    // because the forms it is a piece of were asked — suffix inheritance gives
-    // `f death` the answer of every `… place of death` question.  Choosing one of
-    // several such continuations by popularity voices some other question's
-    // answer, and the cover used to account the fragment's bytes as explained by
-    // it.  A fragment with several continuations leads somewhere FOR THIS
-    // QUESTION only when the question names one (traverse.ts, the exact tier).
-    // A form that is (nearly) the whole question is not a piece of it: the
-    // question says nothing beyond it, so its continuations answer THIS question.
-    const asked = ctx._edgeAsked;
-    const W0 = ctx.space.maxGroup;
-    const leading = asked === null
-      ? sites
-      : sites.filter((s) =>
-        query.length - (s.end - s.start) < W0 ||
-        !(ctx.store.hasParents(s.payload) ||
-          ctx.store.hasContainers(s.payload)) ||
-        ctx.store.nextFirst(s.payload, 2).length < 2 ||
-        namedContinuations(ctx, s.payload, asked) !== null
-      );
+    // A FRAGMENT ANSWERS OTHER QUESTIONS (traverse.ts) — and the cover used to
+    // account the fragment's bytes as explained by the stranger's answer.
+    const leading = sites.filter((s) =>
+      !answersOtherQuestions(ctx, s.payload, query.length, s.end - s.start)
+    );
     if (leading.length < sites.length) {
       if (ctx.meter) {
         ctx.meter.unaskedFragments += sites.length - leading.length;