@hviana/sema 0.4.7 → 0.5.0

package/src/mind/mechanisms/cast.ts

@@ -1182,12 +1182,80 @@ export async function counterfactualTransfer(
     // [...] context will be the seat") — its own bytes ARE that seat
     // directly, with no predecessor to even check (it was found by a
     // forward edge, not matched in the query).
-    const b = seats !== undefined
+    let b = seats !== undefined
       ? seats[1]
       : bestAnalog.point !== null
       ? await seatOf(bestAnalog.point, false)
       : read(ctx, bestAnalog.anchor);
-    const answer = await joinWithBridge(ctx, a, b);
+    // AN ECHO IS NOT A VOICE.  `allowForward: false` above leaves seatOfNode
+    // with one last resort — the point's OWN BYTES — and when the aligned
+    // anchor is a QUESTION node those bytes are the question itself.  The
+    // comparison then hands the asker their own words back: "What is the
+    // capital of France? And what is the largest planet?" answered "The
+    // capital of France is Paris.What is the largest planet?", one topic
+    // answered and the other merely repeated.  (The same corpus answered BOTH
+    // when asked in the opposite order — the echo was never about the topic,
+    // only about whether the climb happened to land on the question node or
+    // the answer node.)
+    //
+    // The fix is NOT to allow the forward edge for every directly aligned
+    // analog.  "Directly aligned" does not mean "the query named it": a point
+    // can be aligned by HALO similarity with no literal overlap at all, and
+    // test/43 pins exactly that case — an analog whose own bytes are already a
+    // complete Q+A unit, cited structurally, whose forward edge is an
+    // unrelated next quiz question.  There, stopping at its own bytes is
+    // right, because those bytes are an answer and nothing was echoed.
+    //
+    // What separates the two is the RESTATEMENT, which is directly testable:
+    // a seat whose bytes already occur in the query says nothing the asker did
+    // not just say, so it cannot be this analog's contribution — and only then
+    // is the continuation the query literally asked for worth following.  Same
+    // `restatesQuery` primitive the substitution schema above already gates
+    // its own forward step on; no new constant and no new notion of "named".
+    // Read the restatement UNDER THE RESPONSE'S OWN EQUIVALENCE.  Byte-exact
+    // containment misses the case that actually occurs: the trained node is
+    // "What is the largest planet?" while the query asks "And what is the
+    // largest planet?" — the same words, one capital letter apart, so
+    // `indexOf` finds nothing and the echo sails through.  `ctx.canon` is the
+    // response's injected notion of "the same text" (case, width, whitespace);
+    // consulting it here is the same fallback `resolve` already makes when an
+    // exact content lookup misses, and it keeps this mechanism from carrying
+    // any idea of its own about what a character is.
+    const echoesQuery = (x: Uint8Array): boolean => {
+      if (restatesQuery(query, x)) return true;
+      const canon = ctx.canon;
+      if (canon === null) return false;
+      const cq = canon(query), cx = canon(x);
+      return cx.length < cq.length && indexOf(cq, cx, 0) >= 0;
+    };
+    if (echoesQuery(b)) {
+      const fwd = await follow(ctx, bestAnalog.anchor, qv);
+      if (fwd !== null && fwd.length > 0 && !echoesQuery(fwd)) b = fwd;
+    }
+    // VOICED IN THE ORDER THE QUERY POSED THEM.  `a` is the DOMINANT point
+    // and `b` the analog, which is a ranking by consensus strength — not by
+    // where either was asked about.  Reading the pair out in that ranking
+    // makes a two-topic answer's order depend on which topic resonated
+    // harder, so the same two questions asked in the opposite order produce
+    // the same sentence: measured on test/57, "What is the largest planet?
+    // And what is the capital of France?" answered "The capital of France is
+    // Paris.The largest planet is Jupiter." — both halves right, the order
+    // backwards, because France was the dominant point (accounted [[33,62],
+    // [0,27]] — the runs are literally in reverse query order).
+    //
+    // This is the SAME rule fuseAttention already applies one layer up ("a
+    // multi-topic answer should read in the order the question posed its
+    // topics"), applied to the pair a single comparison voices itself.  Each
+    // point's position is the earliest query byte its own aligned runs stand
+    // on — the same runs `cmpAccounted` prices the schema by, so order and
+    // cost read one source.
+    const earliest = (p: Point): number =>
+      runSpans(p).reduce((m, [s]) => Math.min(m, s), Infinity);
+    const analogPoint = bestAnalog.point ?? bestAnalog.src;
+    const swap = earliest(analogPoint) < earliest(dominant);
+    const answer = swap
+      ? await joinWithBridge(ctx, b, a)
+      : await joinWithBridge(ctx, a, b);
     record(
       answer,
       "analogical comparison — each analog voiced by the context that establishes its role",

package/src/mind/mechanisms/cover.ts

@@ -15,7 +15,7 @@ import { read, resolve } from "../primitives.js";
 import { guidedFirst, hubBound } from "../traverse.js";
 import { conceptHop } from "../match.js";
 import { bridge } from "../resonance.js";
-import { liftAnswer, segRestatesQuery } from "../types.js";
+import { liftAnswer, liftedScaffolding, segRestatesQuery } from "../types.js";
 import { decodeText, unexplainedLabel } from "../rationale.js";
 import { indexOf } from "../../bytes.js";
 import type { RationaleItem } from "../rationale.js";
@@ -308,6 +308,11 @@ export const coverMechanism: PipelineMechanism = {
       moves: 0,
       weight: solved!.cost, // A*LD derivation's g-value IS the weight
       unexplained: unexplainedLabel(query, accounted),
+      // How much of the composed answer is the asker's own unexplained words
+      // (the spans the liftAnswer trace above labels "scaffolding").  Cover is
+      // the mechanism that can carry them, because a PASS span still lands in
+      // the cover it returns.
+      scaffolding: liftedScaffolding(segs, query.length, query, W),
     }];
   },
 };

package/src/mind/mechanisms/extraction.ts

@@ -113,6 +113,33 @@ export async function extractBySkill(
       subQuantum++;
       continue;
     }
+    // AN UNANCHORED READ IS NOT AN EXTRACTION.  This function's contract (see
+    // the doc above) is that `accounted` carries "the located frames AND any
+    // read span BOUNDED by located frames on both sides", while an open-ended
+    // read "remains a guess about where the span stops — it stays unaccounted".
+    // EMPTY accounted is the degenerate case of that: NO frame of the exemplar
+    // was located in the query at all, so nothing ties the bytes just read to
+    // this question — the skill applied its exemplar's geometry to a query it
+    // never matched.
+    //
+    // The live case (analyze_training.ts F, the battery's ONLY wrong non-silent
+    // answer): "Which city is France's seat of government?" answered "Which ci"
+    // — a fragment of the query itself — from the exemplar "What is dll", with
+    // accounted=[] and pieces=1.  isSpanShaped is deliberately permissive (a
+    // sparse-subsequence check), so it accepts exemplars whose relation to the
+    // query is coincidental gap-matching; requiring at least one LOCATED frame
+    // is the structural evidence that permissiveness leaves out.
+    //
+    // Scoped to extraction ON PURPOSE.  The same test at the pipeline's
+    // post-grounding density check was tried and REVERTED: `accounted` is passed
+    // empty BY CONVENTION on recall's own tiers (recall.ts's ground(…, [], …)),
+    // so a density veto there refused six legitimate reverse-recall groundings.
+    // Here the field is this mechanism's own output and carries its documented
+    // meaning, so the test is sound exactly where the convention does not reach.
+    if (built.accounted.length === 0) {
+      subQuantum++;
+      continue;
+    }
     if (shapeMisses > 0 || subQuantum > 0) {
       ctx.trace?.step(
         "trySkillAnchors",

package/src/mind/mechanisms/recall.ts

@@ -8,6 +8,7 @@ import { cosine } from "../../vec.js";
 import {
   conceptThreshold,
   consensusFloor,
+  dominates,
   identityBar,
   reachThreshold,
   significanceBar,
@@ -15,13 +16,15 @@ import {
 import type { MindContext } from "../types.js";
 import { gistOf, read, resolve } from "../primitives.js";
 import { bytesEqual, indexOf } from "../../bytes.js";
-import { corpusN, hubBound } from "../traverse.js";
+import { allWindowsAreScaffolding, corpusN, hubBound } from "../traverse.js";
 import { follow, project, reverseContext } from "../match.js";
 import { CONCEPT, STEP } from "../graph-search.js";
 import { unexplainedLabel } from "../rationale.js";
 import type { PipelineMechanism, Precomputed } from "../pipeline-mechanism.js";
 import { rItem, rNode } from "../trace.js";
 import { substitutionBridge } from "../bridge.js";
+import { frameFillerSubstitution } from "../frame-filler.js";
+import { prefixCandidates, prefixCompletion } from "../prefix-completion.js";
 
 /** A recall result. */
 export interface RecallResult {
@@ -256,13 +259,94 @@ export async function recallByResonance(
 
   // 2. Scaffolding-dominated.
   if (top.score >= sig) {
-    const N = corpusN(ctx);
-    const minVote = consensusFloor(N);
     // 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 > 0 && forest[0].vote >= minVote) {
+    // TRUST THE ANCHOR ON ITS BREADTH, NOT ON ITS ABSOLUTE VOTE.
+    //
+    // This gate read `forest[0].vote >= consensusFloor(N)`.  Attention.breadth's
+    // own contract (types.ts) says why that is the wrong quantity: the IDF vote
+    // is "an absolute, ln(N)-scaled quantity that means 'strong' on a small
+    // store and 'weak' on a large one for the SAME degree of genuine
+    // consensus", while breadth is the SCALE-INVARIANT reading — "a point whose
+    // breadth clears `dominates` (> half the query's regions corroborate it) is
+    // real consensus; one that does not is a coincidental single-region echo".
+    // Attention.peak's contract makes the same point from the other side:
+    // comparing a POOLED SUM against a floor that prices ONE region's evidence
+    // is a dimensional error.
+    //
+    // Measured on the 15.7M-node store (N=325,615, so the old floor was 13.19).
+    // The absolute vote cannot separate right from wrong at this scale, and the
+    // proof is a probe that must stay SILENT:
+    //
+    //   anchor picked by the climb          vote   breadth  correct?
+    //   "What is the chemical formula …"   10.60    0.556   RIGHT
+    //   "Qual é a capital de França?"       8.19    0.667   RIGHT
+    //   "Who wrote the play Romeo …?"       8.25    0.833   RIGHT
+    //   "How do you say "good morning" …"  10.77    0.800   RIGHT
+    //   "What is the commercial capital …" 12.69    0.333   Zamunda — MUST be silent
+    //   "Menene sunan ginin mafi tsayi …"  12.79    0.214   wrong (Hausa)
+    //   "Today is the 5th of March …"      10.36    0.000   wrong
+    //
+    // Zamunda's junk attractor outvotes every correct anchor, so no vote
+    // threshold admits the right ones without admitting fabrication — while
+    // breadth > ½ admits exactly the four correct anchors and nothing else.
+    // The old floor was simply never cleared on a corpus this large: the tier
+    // was dead code here, which is why 12 probes fell through to silence.
+    //
+    // `dominates(breadth, 1)` is the SAME half-dominance predicate used
+    // throughout, applied to the fraction — no new constant, and the bar the
+    // breadth contract names.  COST: none; breadth is already computed and
+    // carried on every Attention the climb returns.
+    //
+    // The two readings are ALTERNATIVES, never a substitution.  REPLACING the
+    // vote test with the breadth test was tried and broke 7 tests: on a small
+    // store ln(N) is low, so the vote bar is the one that legitimately fires
+    // there, and — as Attention.clusters' own contract warns — "breadth starves
+    // a genuine, evenly-split multi-topic query, since no root in a real N-way
+    // split can exceed half the vote" (the two 3.1 two-topic fusion tests are
+    // exactly that shape).  Each reading is sufficient on its own evidence: a
+    // vote that clears the absolute floor is strong enough wherever the corpus
+    // is small enough for that to mean something, and a breadth past ½ is real
+    // consensus at any scale.  ORing them keeps every admission the floor
+    // already made and adds only the scale-invariant ones it could never see.
+    //
+    // BREADTH ALSO NEEDS DISCRIMINATIVENESS.  Breadth asks how much of the
+    // query corroborates the anchor, never whether the anchor SAYS anything: on
+    // a one-context store every region trivially corroborates the only anchor
+    // there is, so breadth is 1 while the anchor's IDF is 0 — and test/31 A2
+    // ("explain quantum chromodynamics" against a lone cat fact) answered the
+    // cat, which is fabrication.  A region's IDF contribution for an anchor
+    // reached through c of N contexts is ln(N/c), so requiring it to exceed
+    // ln 2 is requiring c·2 < N — the SAME half-dominance reading used
+    // everywhere, expressed in the IDF's own units rather than as a new bar.
+    // `peak` is that per-region contribution, and reading it here is what
+    // Attention.peak's contract asks of a consumer gating on this evidence.
+    //
+    // AND THE QUERY MUST SAY SOMETHING.  Both readings above price the
+    // ANCHOR's evidence; neither asks whether the QUERY discriminates
+    // anything.  A query that is entirely corpus-global scaffolding gives the
+    // corpus nothing to be held to, and this tier — which exists to serve
+    // scaffolding-DOMINATED queries — is exactly where that runs out.
+    // Measured on the trained store: "What is the capital " answered "Colombo
+    // is the commercial capital of Sri Lanka…" on breadth 0.667 / clusters 1,
+    // and every window it spells is a hub ("What":572).  See
+    // allWindowsAreScaffolding for the full separation, including the probes
+    // this tier serves CORRECTLY, which all retain a discriminating window
+    // ("what is the capital of france" → "f fr":248).
+    //
+    // DISPERSION WAS TRIED HERE FIRST AND FALSIFIED — do not retry it: the
+    // fabrication and the no-punctuation robustness probe have the IDENTICAL
+    // profile (breadth 0.667, clusters 1), so requiring clusters >= 2 silenced
+    // "what is the capital of france" too and cost the battery a probe.
+    const minVote = consensusFloor(corpusN(ctx));
+    if (
+      forest.length > 0 &&
+      !allWindowsAreScaffolding(ctx, query) &&
+      (forest[0].vote >= minVote ||
+        (dominates(forest[0].breadth, 1) && forest[0].peak > Math.LN2))
+    ) {
       const g = await project(ctx, forest[0].anchor, queryGist);
       // The anchor cleared the consensus floor, but the floor prices the
       // ANCHOR's evidence, not the projection's: a junk attractor can clear
@@ -301,6 +385,49 @@ export async function recallByResonance(
     }
   }
   // 3b. Corroborated-substitution bridge — refusal-path only (bridge.ts).
+  // MEMOISED ACROSS EVERY REMAINING TIER, and that is load-bearing rather than
+  // tidy: the bridge, prefix completion and the frame filler all read the SAME
+  // candidate list, so the exhaustive branch runs at most once per response.
+  // Without the memo each tier re-issues it — measured at 490 ms median against
+  // 13 ms non-exhaustive (36x).
+  const wideIdsOnce = async (): Promise<ReadonlyArray<number>> => {
+    // When the top resonance hit is below the concept threshold, the query
+    // gist has no concept-level match to any stored form — an exhaustive √N
+    // ANN would only score more vectors below the bar (profiled at 38K–40K
+    // annVectorReads per refusing query on a 325K-context store).  The
+    // bridge's structural channels (junction walks, anchor climbs) are the
+    // correct proposal source for a query whose gist has no clean match;
+    // the ANN cannot propose what the gist cannot rank.
+    // The condition above is the SCORE of the top hit, not the size of the
+    // corpus.  It used to be spelled `corpusN(ctx) <= (k · W)³`, which asks
+    // a different question and answers it wrongly at exactly the scale the
+    // note was written from: on the trained store N = 325,608 with k = 24
+    // and W = 4 puts the cube at 884,736, so that store took the exhaustive
+    // branch — the very branch measured here as 38K–40K annVectorReads.
+    // Measured cost of the mismatch: substitutionBridge 8,544ms of a
+    // 19,548ms think (44%), against 1,248ms and 14,218ms without it, with
+    // every answer in the battery byte-identical and the suite unchanged
+    // at 445/445.  Corpus size was never the discriminator; whether the
+    // gist ranks ANYTHING at concept level is.
+    //
+    // Reading it as the note states also removes a duplicated (k · W)³ —
+    // the same cube gates crossRegionVotes' walk budget, where it likewise
+    // never engages at real scale (see attention.ts).
+    if (whole.length > 0 && whole[0].score >= conceptThreshold(ctx.store.D)) {
+      const exhaustive = await ctx.store.resonate(
+        queryGist,
+        hubBound(ctx),
+        true,
+      );
+      return exhaustive.map((h) => h.id);
+    }
+    return whole.map((h) => h.id);
+  };
+  let wide: Promise<ReadonlyArray<number>> | null = null;
+  const wideIds = (): Promise<
+    ReadonlyArray<number>
+  > => (wide ??= wideIdsOnce());
+
   // Every gist-based tier has failed; before refusing, align the query
   // byte-for-byte against the trained contexts its own stored windows
   // anchor, accepting mismatches only as corpus-attested, concept-bar
@@ -321,39 +448,6 @@ export async function recallByResonance(
     // exact co-occurrence and bounded anchor ascent are the bridge's structural
     // proposal channels, while an exhaustive ANN call made every honest
     // refusal cost hundreds of milliseconds regardless of k.
-    const wideIds = async (): Promise<ReadonlyArray<number>> => {
-      // When the top resonance hit is below the concept threshold, the query
-      // gist has no concept-level match to any stored form — an exhaustive √N
-      // ANN would only score more vectors below the bar (profiled at 38K–40K
-      // annVectorReads per refusing query on a 325K-context store).  The
-      // bridge's structural channels (junction walks, anchor climbs) are the
-      // correct proposal source for a query whose gist has no clean match;
-      // the ANN cannot propose what the gist cannot rank.
-      // The condition above is the SCORE of the top hit, not the size of the
-      // corpus.  It used to be spelled `corpusN(ctx) <= (k · W)³`, which asks
-      // a different question and answers it wrongly at exactly the scale the
-      // note was written from: on the trained store N = 325,608 with k = 24
-      // and W = 4 puts the cube at 884,736, so that store took the exhaustive
-      // branch — the very branch measured here as 38K–40K annVectorReads.
-      // Measured cost of the mismatch: substitutionBridge 8,544ms of a
-      // 19,548ms think (44%), against 1,248ms and 14,218ms without it, with
-      // every answer in the battery byte-identical and the suite unchanged
-      // at 445/445.  Corpus size was never the discriminator; whether the
-      // gist ranks ANYTHING at concept level is.
-      //
-      // Reading it as the note states also removes a duplicated (k · W)³ —
-      // the same cube gates crossRegionVotes' walk budget, where it likewise
-      // never engages at real scale (see attention.ts).
-      if (whole.length > 0 && whole[0].score >= conceptThreshold(ctx.store.D)) {
-        const exhaustive = await ctx.store.resonate(
-          queryGist,
-          hubBound(ctx),
-          true,
-        );
-        return exhaustive.map((h) => h.id);
-      }
-      return whole.map((h) => h.id);
-    };
     const bridged = await substitutionBridge(ctx, query, wideIds);
     if (bridged !== null) {
       const g = await project(ctx, bridged.id, queryGist);
@@ -369,8 +463,33 @@ export async function recallByResonance(
         bridged.subs.some((s) =>
           indexOf(cBytes.subarray(s.cs, s.ce), g!, 0) >= 0
         );
+      // THE PREFIX TRAP IS NOT THIS TIER'S TO SPRING.  With no substitutions
+      // the claim is "a trained context IS this query, up to filler".  When
+      // the query is a STRICT BYTE PREFIX of that context, the claim is false
+      // in the one way that matters: the candidate's extra tail is precisely
+      // the DISCRIMINATING part, and dismissing it as filler asserts a
+      // specification the asker never made.  Measured on a 4,300-fact fixture
+      // of "what is the value of <i>?": the query "what is the value of"
+      // bridged with subs [] to "what is the value of 0?" and answered "the
+      // value of 0 is 0" — one arbitrary pick from 4,300 equally-matching
+      // contexts, every one of which fits the query exactly as well.
+      //
+      // The engine ALREADY has the right machinery for this shape:
+      // prefixCompletion runs a few lines below and carries the three guards
+      // this tier lacks — unreadable-continuation veto, sub-quantum
+      // continuation, and UNIQUENESS (distinct continuations ⇒ refuse), which
+      // is exactly what 4,300 competing values must trip.  So this is not a
+      // new rule and not a new threshold: it is deferring a prefix decision to
+      // the tier that owns it (§2.5, one factored machinery).  Byte-strict on
+      // purpose — a candidate differing by case or punctuation ("what is the
+      // capital of france" → "What is the capital of France?") is NOT a byte
+      // prefix, keeps grounding here, and is unaffected.
+      const strictPrefix = g !== null &&
+        cBytes.length > query.length &&
+        indexOf(cBytes, query, 0) === 0;
       if (
         g !== null && g.length > 0 && !restates(g) && !manufactured &&
+        !(bridged.subs.length === 0 && strictPrefix) &&
         !(g.length < query.length && indexOf(query, g, 0) >= 0)
       ) {
         return ground(
@@ -428,6 +547,86 @@ export async function recallByResonance(
         );
       }
     }
+
+    // 3b′. PREFIX COMPLETION — refusal-path only (prefix-completion.ts).
+    // Inside the bridge's block, and deliberately: it consumes `wideIds`, the
+    // list the bridge has already fetched, so it costs a bounded byte compare
+    // per candidate and not one resonance.  The claim it makes is the
+    // strongest in the ladder — every query byte is a LITERAL match from
+    // offset zero of a trained form — so it needs no projection and no reach
+    // gate.  It runs after the bridge only because the bridge answers the
+    // richer relation when it can; a prefix match that the bridge also
+    // explains is the same trained form either way.
+    {
+      // The resonance list first; only when it supplies nothing does the
+      // write side's leaf-id window index propose (prefixCandidates).  That
+      // ordering is the whole cost story: a query the ranked list can already
+      // explain pays not one extra read, and the fallback's bounded walk is
+      // spent only where the alternative is an empty answer.  It is a second
+      // SUPPLY, not a second mechanism — the same three guards decide.
+      const completed = prefixCompletion(ctx, query, await wideIds()) ??
+        prefixCompletion(ctx, query, prefixCandidates(ctx, query));
+      if (completed !== null) {
+        return ground(
+          completed.form,
+          "prefix completion — the query IS the opening of exactly one " +
+            "trained form, which this grounds whole",
+          // Every query byte is literally matched against the form.  The
+          // completion is the form's own continuation, not a substitution, so
+          // there is nothing to be humble about in the accounting — the same
+          // reading the IDENTITY bridge above takes.
+          whole_,
+          STEP,
+          false,
+          // NOT complete: the query is a proper PREFIX, so the form may carry
+          // more past the remainder this tier voiced.
+          false,
+        );
+      }
+    }
+  }
+
+  // 3c. FRAME-FILLER SUBSTITUTION — refusal-path only (frame-filler.ts).
+  // The bridge has failed, and for the shape this tier answers it MUST fail:
+  // a definite description standing where a proper noun stands is not a
+  // similarity relation the bridge can price (raw balance refuses
+  // `dominates(6, 37)`, and correctly — that is the France/Spain trap).  This
+  // tier makes a different claim: not that the two spans resemble each other,
+  // but that the store ALREADY HOLDS this query with the filler in the
+  // description's place, byte-exactly.  A key the store does not hold is
+  // discarded, so the answer is always a trained continuation.
+  {
+    // THE COHORT NEEDS EVIDENCE, AND THE REFUSAL PATH HAS ALREADY BOUGHT IT.
+    // This tier reads constituency from what a cohort of exemplars does NOT
+    // share, so its resolution is bounded by how many instances of the frame it
+    // can see.  The top-k resonance hits are too few — on the two-hop probe the
+    // exemplars holding the query's discriminative content number TWO, and two
+    // structures agree on so little that a whole clause reads as content.  The
+    // exhaustive list the bridge fetched is the same evidence at ~570 wide, and
+    // it is already paid for (memoised above, so this costs no ANN call).
+    const filled = frameFillerSubstitution(ctx, query, await wideIds());
+    if (filled !== null) {
+      const g = await project(ctx, filled.id, queryGist);
+      // The same restated-fragment and manufactured-answer guards every tier
+      // above applies: a projection contained in the FILLER is the
+      // substitution restated as if it were knowledge, not knowledge.
+      if (
+        g !== null && g.length > 0 && !restates(g) &&
+        indexOf(filled.filler, g, 0) < 0 &&
+        !(g.length < query.length && indexOf(query, g, 0) >= 0)
+      ) {
+        return ground(
+          g,
+          "frame-filler substitution — a trained form IS this query with a " +
+            "corroborated filler in the described span's place",
+          // The frame is literally matched against the resolved form and the
+          // described span is explained by the substitution — the same
+          // matched-plus-substituted accounting the bridge reports.
+          [[0, query.length]],
+          CONCEPT + STEP,
+        );
+      }
+    }
   }
 
   // The refusal/echo decision.  The echo returns a stored form's bytes AS