@hviana/sema 0.8.9 → 0.9.1

package/src/mind/graph-search.ts

@@ -87,6 +87,11 @@ export type GItem =
      *  consolidated, more-explanatory reading wins over leaving the parts split.
      *  See {@link GraphSearch.fuse} and {@link GraphSearch.formRules}. */
     rcmp?: boolean;
+    /** Set on a concept hop's ASKING form: the edge-less form `node` whose halo
+     *  target the caller has not granted yet, held at the hop's own cost and
+     *  span.  Popping it asks for the target; it leads nowhere itself, so it
+     *  is never part of a final derivation (see {@link Licence}). */
+    ask?: boolean;
   }
   | {
     kind: "out";
@@ -126,6 +131,13 @@ export type GItem =
   };
 type OutItem = Extract<GItem, { kind: "out" }>;
 
+/** What {@link GraphSearch.entityProposals} found inside one fact. */
+interface EntityProposals {
+  readonly proposed: ReadonlyMap<number, Uint8Array>;
+  readonly source: ReadonlyMap<number, string>;
+  readonly sites: ReadonlyArray<Site>;
+}
+
 // The cost ladder is a strict ORDERING, not tuned magic:
 //   • Coverage dominates everything: leaving one query byte unrecognised (PASS)
 //     outweighs any chain of graph steps a covering derivation could take, so
@@ -174,9 +186,6 @@ export interface Seg {
   fix?: boolean;
 }
 
-/** Read the chosen spans back off a derivation: the goal is a chain of bridge
- *  steps, each whose second premise is the `out` it crossed.  Walk the chain to
- *  the axiom and reverse into left-to-right order. */
 /** The BYTE TERM of a derivation's cost: how many bytes its bridge rule charged
  *  at PASS each — read back off the rule that charged them (`bridgeRule`:
  *  `o.rec ? MICRO : PASS * (o.j - o.i)`), so the split exists in ONE place and
@@ -201,6 +210,9 @@ function readBridgedBytes(derivation: Derivation<GItem>): number {
   return bytes;
 }
 
+/** Read the chosen spans back off a derivation: the goal is a chain of bridge
+ *  steps, each whose second premise is the `out` it crossed.  Walk the chain to
+ *  the axiom and reverse into left-to-right order. */
 function readCover(derivation: Derivation<GItem>): Seg[] {
   const segs: Seg[] = [];
   let node: Derivation<GItem> | undefined = derivation;
@@ -258,10 +270,6 @@ export interface DerivationItem {
   node?: number;
 }
 
-/** The reasoning act a derivation rule performs — the human name for which of
- *  {@link GraphSearch}'s rules fired, recovered from the rule's premise/
- *  conclusion shape (the rules carry no label, so this classifies by structure,
- *  the single place that maps rule geometry to a name). */
 // CLOSED ON PURPOSE — AND ONLY THIS ONE IS.  A derivation move is BRANCHED ON
 // (`classifyMove`, the rationale's readers, MOVE_NOTE's fallback), so it is a
 // closed union: adding one without teaching every reader is a compile error,
@@ -270,6 +278,10 @@ export interface DerivationItem {
 // branched on — and they stay free strings that COMPOSE with the nesting
 // (`["respond", "think", "recognise"]`).  That asymmetry is deliberate; do not
 // "fix" it by uniting the two (see test/126 for the pipeline half of it).
+/** The reasoning act a derivation rule performs — the human name for which of
+ *  {@link GraphSearch}'s rules fired, recovered from the rule's premise/
+ *  conclusion shape (the rules carry no label, so this classifies by structure,
+ *  the single place that maps rule geometry to a name). */
 export type DerivationMove =
   | "axiom" // a seed: a perceived leaf, a recognised form, or a computed result
   | "follow-edge" // form→form via a continuation edge (STEP) — the core "what follows what"
@@ -285,6 +297,93 @@ export type DerivationMove =
   | "pool-vote" // N premises→conclusion, evidence pooled (combine:"sum" — see derive)
   | "step"; // any other single-premise move (fallback)
 
+/** The chart's canonical key — an item's boundary signature (see
+ *  {@link DeductionSystem.key}).  Module-level because the join license
+ *  ({@link GraphSearch.solve}) names facts by the same key the chart does. */
+function chartKey(it: GItem): string {
+  if (it.kind === "cover") return "c" + it.p;
+  if (it.kind === "form") {
+    return `f${it.i}.${it.j}.${it.node}.${it.via ? 1 : 0}.${it.rcmp ? 1 : 0}${
+      it.ask ? "?" : ""
+    }`;
+  }
+  return `o${it.i}.${it.j}.${it.cover ? 1 : 0}.${it.rec ? 1 : 0}.${
+    it.fix ? 1 : 0
+  }.${it.throughFact ? 1 : 0}.${it.node ?? -1}.${latin1(it.bytes)}`;
+}
+
+/** The facts a derivation STANDS ON — every node-bearing `out` in its proof
+ *  tree, premises before conclusions, each once. */
+function factsOf(root: Derivation<GItem>): OutItem[] {
+  const out: OutItem[] = [];
+  const seen = new Set<Derivation<GItem>>();
+  const walk = (d: Derivation<GItem>): void => {
+    if (seen.has(d)) return;
+    seen.add(d);
+    for (const p of d.premises) walk(p);
+    if (d.item.kind === "out" && d.item.node !== undefined) out.push(d.item);
+  };
+  walk(root);
+  return out;
+}
+
+/** The joins granted to the facts a derivation stood on: fact chart key → the
+ *  conclusions {@link GraphSearch.deriveThrough} derives through it, computed
+ *  once per fact (an empty list is an answer: that fact joins nothing). */
+type JoinLicense = Map<
+  string,
+  ReadonlyArray<{ conclusion: GItem; cost: number }>
+>;
+
+/** THE ASYNC PREMISES A COVER USES, RESOLVED ONLY WHERE THE SEARCH REACHES THEM.
+ *
+ *  Two of the cover's rules need data the synchronous search cannot fetch — a
+ *  connector splice (a bridge between two answers) and a concept hop (an
+ *  edge-less form's halo sibling) — and both used to be resolved for EVERY
+ *  candidate before the search ran.  A rule fires only from popped premises,
+ *  and the agenda pops in cost order up to the goal, so most of that work fed
+ *  rules the search never reached: measured on the 31.7M-node store, a 262-byte
+ *  query recognised whole paid 23 bridges (143,520 junction pops, 7.3 s of its
+ *  7.9 s) for sub-forms whose rewrites cost a STEP each and so never left the
+ *  agenda before the one-STEP goal — and then 1.2 s of halo reads for concept
+ *  hops priced at CONCEPT, ten times that goal.
+ *
+ *  So the caller OFFERS what it can resolve; where the search reaches an offered
+ *  key it uses a GRANTED value and ASKS for an ungranted one — a connector when
+ *  its splice's premises meet, a concept target when the hop's conclusion, held
+ *  as an asking form at the hop's own cost, is popped.  A run that asked
+ *  nothing is the run every key resolved in advance would have made: the pops
+ *  are decided only by the rules fired from popped items, a granted key fires
+ *  the very rule it fired before, and an asking form that was never popped fired
+ *  none.  So its cover is final.  A run that asked is PROVISIONAL: the caller
+ *  grants the asked keys (the async reads the search cannot run) and covers
+ *  again; every round grants at least one offered key, so the rounds end. */
+export interface Licence<K, V> {
+  /** Every key the caller can resolve. */
+  readonly offered: ReadonlySet<K>;
+  /** The keys resolved so far: their value, or null (nothing learnt). */
+  readonly granted: ReadonlyMap<K, V | null>;
+  /** Filled by the search: the offered keys it reached ungranted. */
+  readonly asked: Set<K>;
+}
+/** Connectors, keyed `L,R` by answer-node ids, valued by the learnt glue. */
+export type ConnectorLicence = Licence<string, Uint8Array>;
+/** Concept hops, keyed by an edge-less form's node, valued by the node its
+ *  halo sibling's edge leads to. */
+export type ConceptLicence = Licence<number, number>;
+/** Whether a run asked for anything — its cover is then provisional. */
+function asked(
+  concepts: ConceptLicence,
+  connectors: ConnectorLicence | undefined,
+): boolean {
+  return concepts.asked.size > 0 || (connectors?.asked.size ?? 0) > 0;
+}
+/** Nothing offered: a cover with no async premises (a nested completion,
+ *  articulation's revoicing). */
+export function noLicence<K, V>(): Licence<K, V> {
+  return { offered: new Set(), granted: new Map(), asked: new Set() };
+}
+
 /** Flatten a {@link GItem} into the {@link DerivationItem} a rationale shows. */
 function derivationItem(it: GItem): DerivationItem {
   if (it.kind === "cover") return { kind: "cover", span: [it.p, it.p] };
@@ -407,18 +506,9 @@ export class GraphSearch {
     private readonly host: GraphSearchHost,
   ) {}
 
-  /** The nodes the QUERY canonically names — the same identity the store's keys
-   *  were written through.  A byte-exact test is not enough: the query writes
-   *  `Eiffel Tower country` and the deposited node is `eiffel tower country`, so
-   *  a join that filters the query's own subject by RAW bytes re-admits it —
-   *  measured: that is the trap's wrong answer (`The capital of Eiffel Tower
-   *  country is Berlin.`).  Cached by query identity, because the search is
-   *  reused across responses. */
-
-  /* * The hub bound √N (bounded-reads.md) — the ONE
-   *  fan-out cap, stated here rather than imported from `traverse.ts` because
-   *  this module is deliberately host-based (it holds a bare Store, never a
-   *  MindContext).
+  /** The hub bound √N (bounded-reads.md) — the ONE fan-out cap, stated here
+   *  rather than imported from `traverse.ts` because this module is
+   *  deliberately host-based (it holds a bare Store, never a MindContext).
    *  That is the same write/read-side duplication convention canonical.ts's
    *  header documents: if the formula changes it must change in BOTH places.
    *  It is stated ONCE per side, though — the expression used to be spelled
@@ -443,15 +533,17 @@ export class GraphSearch {
    *
    *  Any learnt connector between two rewrites is spliced IN by the in-search
    *  connector rule (see {@link outRules}), so the returned spans already carry
-   *  it — there is no post-pass. */
+   *  it — there is no post-pass.  With a {@link ConnectorLicence}, a cover
+   *  returned while `connectors.asked` is non-empty is PROVISIONAL: grant the
+   *  asked pairs and cover again. */
   cover(
     queryLen: number,
     sites: ReadonlyArray<Site>,
-    conceptTarget: ReadonlyMap<number, number>,
+    concepts: ConceptLicence,
     leaves: ReadonlyArray<Leaf>,
     splits: ReadonlySet<number>,
     substitutions?: ReadonlyMap<number, Uint8Array>,
-    connectors?: ReadonlyMap<string, Uint8Array>,
+    connectors?: ConnectorLicence,
     computedResults?: ReadonlyArray<ComputedResult>,
     /** When given, receives each solved span's lightest derivation — the full
      *  adapted A*LD proof tree as classified {@link DerivationStep}s — for the
@@ -466,14 +558,17 @@ export class GraphSearch {
     // through (completion is cover, recursively — see {@link recompleteNode}).
     this.recompleteOpen.clear();
     this.recompleteMemo = new Map<number, Uint8Array | null>();
+    this.entityMemo = new Map<string, EntityProposals>();
     // The top cover's derivation sink is threaded into every nested completion
     // so the recompositions a produced form needs are reported in the same
     // trace instead of vanishing after the first layer.
     this.derivationSink = onDerivation;
+    concepts.asked.clear();
+    if (connectors) connectors.asked.clear();
     const solved = this.solve(
       queryLen,
       { sites, leaves, splits },
-      conceptTarget,
+      concepts,
       substitutions,
       connectors,
       computedResults,
@@ -486,7 +581,9 @@ export class GraphSearch {
     // continuations instead of following the chain the answer itself licensed.
     // With deepening only at the top, `recompleteNode` walks the accepted chain
     // one link at a time (its own memo and stack), so the work is the answer's.
-    return solved === null ? null : {
+    // A provisional cover is not deepened: it is about to be re-covered.
+    if (solved === null || asked(concepts, connectors)) return solved;
+    return {
       segs: this.deepen(solved.segs),
       cost: solved.cost,
       moves: solved.moves,
@@ -512,32 +609,94 @@ export class GraphSearch {
       leaves: ReadonlyArray<Leaf>;
       splits: ReadonlySet<number>;
     },
-    conceptTarget: ReadonlyMap<number, number>,
+    concepts: ConceptLicence,
     substitutions?: ReadonlyMap<number, Uint8Array>,
-    connectors?: ReadonlyMap<string, Uint8Array>,
+    connectors?: ConnectorLicence,
     computedResults?: ReadonlyArray<ComputedResult>,
     onDerivation?: (steps: DerivationStep[]) => void,
   ): { segs: Seg[]; cost: number; moves: number } | null {
-    const system = this.buildSearch(
-      spanLen,
-      recognition.sites,
-      conceptTarget,
-      recognition.leaves,
-      recognition.splits,
-      substitutions,
-      connectors,
-      computedResults,
-    );
+    // The query's own bytes, tiled from its perceived leaves.  A JOIN reads the
+    // tail a produced fact's contained entity has to combine with, and the
+    // search otherwise only ever sees positions, never the bytes behind them.
+    const queryBytes = new Uint8Array(spanLen);
+    for (const lf of recognition.leaves) {
+      queryBytes.set(lf.bytes.subarray(0, lf.end - lf.start), lf.start);
+    }
+    // The nodes this span's recognition names — read ONCE per solve, on the first
+    // join that asks, instead of re-reading the memo per fact.
+    let queryNodeSet: ReadonlySet<number> | undefined;
+    const queryNodes = (): ReadonlySet<number> =>
+      queryNodeSet ??= new Set<number>(
+        (this.host.recogniseSpan?.(queryBytes)?.sites ?? []).map((s) =>
+          s.payload
+        ),
+      );
+    // THE JOIN DERIVES THROUGH THE FACTS THE DERIVATION STANDS ON — never
+    // through every fact the exploration REACHES.  How many facts the search
+    // reaches is set by how densely the corpus interconnects the forms on the
+    // way (a dialogue hub's continuations, walked to their fixpoints, are
+    // thousands), and pricing a join from each of them made the work track the
+    // corpus instead of the answer: measured on the 31.7M-node store, a 46-byte
+    // query reached 2,000+ fixpoints in a minute, each paying an entity scan,
+    // past 10 GB.  It is the trap {@link recompleteNode} already records, and
+    // the same cure as {@link deepen}: the expensive step runs on what the
+    // lightest derivation CHOSE.
+    //
+    // So the search runs to its lightest derivation, the facts that derivation
+    // stands on are LICENSED — their joins computed once — and it runs again
+    // with those joins as ordinary rules of the same system, priced exactly as
+    // before (the fact's own cost + STEP).  A join's conclusion is itself a fact
+    // the next derivation may stand on, so chains extend round by round until
+    // no newly licensed fact joins anything: the depth is the answer's, never a
+    // count.  A round is re-run only when a newly licensed fact DOES join, so a
+    // query whose facts join nothing pays one search, as before.
+    //
+    // The joins a covering round licensed are KEPT across a licence's re-covers:
+    // a round that asked for nothing is the very round the next re-cover repeats
+    // (see {@link Licence}), so its joins are the ones that re-cover would grant
+    // again.
+    const joins: JoinLicense = this.joinsKept.get(concepts) ?? new Map();
+    this.joinsKept.set(concepts, joins);
     // Search-effort accounting (src/meter.ts): the chart's pops/pushes are
     // the cover's real cost, and a heuristic that stops being admissible
     // shows up as a pop count that explodes while the answer stays the same.
     const meter = this.host.meter;
-    const stats = meter ? { pops: 0, pushes: 0 } : undefined;
-    const derivation = lightestDerivation(system, stats);
-    if (meter && stats) {
-      meter.searches++;
-      meter.searchPops += stats.pops;
-      meter.searchPushes += stats.pushes;
+    let derivation: Derivation<GItem> | null;
+    for (;;) {
+      const system = this.buildSearch(
+        spanLen,
+        recognition.sites,
+        concepts,
+        recognition.leaves,
+        recognition.splits,
+        queryBytes,
+        joins,
+        substitutions,
+        connectors,
+        computedResults,
+      );
+      const stats = meter ? { pops: 0, pushes: 0 } : undefined;
+      derivation = lightestDerivation(system, stats);
+      if (meter && stats) {
+        meter.searches++;
+        meter.searchPops += stats.pops;
+        meter.searchPushes += stats.pushes;
+      }
+      // A round that ASKED for a connector is provisional: return it before any
+      // join is licensed from a derivation the granted connectors may change.
+      if (derivation === null || asked(concepts, connectors)) break;
+      let joined = false;
+      for (const fact of factsOf(derivation)) {
+        const k = chartKey(fact);
+        if (joins.has(k)) continue;
+        if (meter) meter.joinFacts++;
+        const granted = [
+          ...this.deriveThrough(fact, queryBytes, spanLen, queryNodes),
+        ].map((r) => ({ conclusion: r.conclusion, cost: r.cost }));
+        joins.set(k, granted);
+        if (granted.length > 0) joined = true;
+      }
+      if (!joined) break;
     }
     // When covering under a substitution map (articulation), a form→out rule is
     // the form EMITTING the asker's voice, not grounding to its own answer — so
@@ -587,11 +746,13 @@ export class GraphSearch {
   private buildSearch(
     queryLen: number,
     sites: ReadonlyArray<Site>,
-    conceptTarget: ReadonlyMap<number, number>,
+    concepts: ConceptLicence,
     leaves: ReadonlyArray<Leaf>,
     splits: ReadonlySet<number>,
+    queryBytes: Uint8Array,
+    joins: JoinLicense,
     substitutions?: ReadonlyMap<number, Uint8Array>,
-    connectors?: ReadonlyMap<string, Uint8Array>,
+    connectors?: ConnectorLicence,
     computedResults?: ReadonlyArray<ComputedResult>,
   ): DeductionSystem<GItem> {
     const W = this.maxGroup; // fusible span ceiling (shortest composite bound)
@@ -603,13 +764,6 @@ export class GraphSearch {
       Math.ceil((this.store.edgeSourceCount() * W) / 256),
     ) > this.hubBound();
     const nodeBytes = (n: number) => this.store.bytesPrefix(n, ALL);
-    // The query's own bytes, tiled from its perceived leaves.  A JOIN reads the
-    // tail a produced fact's contained entity has to combine with, and `buildSearch`
-    // otherwise only ever sees positions, never the bytes behind them.
-    const queryBytes = new Uint8Array(queryLen);
-    for (const lf of leaves) {
-      queryBytes.set(lf.bytes.subarray(0, lf.end - lf.start), lf.start);
-    }
     // Content-addressed probes over the store's hash-cons maps — the same keys
     // training filled.  No byte-by-byte trie walk.
     const findLeafU = (b: Uint8Array) => this.store.findLeaf(b) ?? undefined;
@@ -622,34 +776,82 @@ export class GraphSearch {
     const outsByNode = new Map<number, OutItem[]>();
     const coverableByStart = new Map<number, OutItem[]>();
 
-    // Index the connectors by their left and right answer-node, so the connector
-    // rule iterates only this out's FEW resolved partners (selective, and for the
-    // N-ary case O(parts) keys) instead of scanning every position pair — what
-    // keeps the in-search bridge bounded when many parts are recognised at once.
-    const linksByLeft = new Map<number, Array<[number, Uint8Array]>>();
-    const linksByRight = new Map<number, Array<[number, Uint8Array]>>();
+    // Index the offered connectors by their left and right answer-node, so the
+    // connector rule iterates only this out's FEW offered partners (selective,
+    // and for the N-ary case O(parts) keys) instead of scanning every position
+    // pair — what keeps the in-search bridge bounded when many parts are
+    // recognised at once.
+    const linksByLeft = new Map<number, Array<[number, string]>>();
+    const linksByRight = new Map<number, Array<[number, string]>>();
     if (connectors) {
-      for (const [key, bytes] of connectors) {
+      for (const key of connectors.offered) {
         const comma = key.indexOf(",");
         const l = Number(key.slice(0, comma));
         const r = Number(key.slice(comma + 1));
-        pushInto(linksByLeft, l, [r, bytes]);
-        pushInto(linksByRight, r, [l, bytes]);
+        pushInto(linksByLeft, l, [r, key]);
+        pushInto(linksByRight, r, [l, key]);
       }
     }
 
-    return {
-      key(it) {
-        if (it.kind === "cover") return "c" + it.p;
-        if (it.kind === "form") {
-          return `f${it.i}.${it.j}.${it.node}.${it.via ? 1 : 0}.${
-            it.rcmp ? 1 : 0
-          }`;
+    // A SPAN'S CHEAPEST COMPLETION DOMINATES THE REST.  Coverage is positional:
+    // every recognised completion of [i, j) advances the cover from i to j at
+    // the same MICRO, so for the goal only the cheapest matters.  What else a
+    // completion can do turns on its BYTES — fuse it with a neighbour, splice a
+    // connector, join through it — and those rules fire from the completion the
+    // search would stand on for that span, never from every alternative it
+    // reached: the cure {@link deepen} and the join license already apply, for
+    // the same trap.  Measured on the 31.7M-node store, a 46-byte dialogue query
+    // reached 60,530 continuation forms and 57,072 fixpoints for its few spans —
+    // a greeting's thousands of replies, each a fixpoint at the same depth — and
+    // canonically resolved every one of them fused with its neighbours (5.4 s
+    // of an 8.6 s cover) to stand, in the end, on two hops.
+    //
+    // So a form or completion of [i, j) whose cost has reached that of a
+    // completion of [i, j) already yielded is DOMINATED and fires nothing: every
+    // completion it could lead to costs at least as much (local costs are
+    // non-negative and a form's rules keep its span), and a tie goes to the one
+    // yielded first — the evidence-preferred continuation, yielded first by
+    // {@link formRules}.  This is also what makes the stop-here offer a real
+    // horizon: a chain deeper than its first hop's stop (STEP + CONCEPT) is
+    // dominated by it, where before the PASS-priced goal let the search buy a
+    // thousand hops to look for one more byte.
+    const spanBest = new Map<number, { cost: number; item: GItem }>();
+    const spanOf = (i: number, j: number) => i * (queryLen + 1) + j;
+    const completes = (it: GItem): it is OutItem =>
+      it.kind === "out" && it.rec && it.cover;
+    const dominated = (it: GItem, cost: number): boolean => {
+      if (it.kind === "cover") return false;
+      if (it.kind === "out" && !completes(it)) return false;
+      const best = spanBest.get(spanOf(it.i, it.j));
+      if (best === undefined || best.cost > cost) {
+        if (completes(it)) spanBest.set(spanOf(it.i, it.j), { cost, item: it });
+        return false;
+      }
+      return best.item !== it &&
+        (it.kind !== "out" || chartKey(best.item) !== chartKey(it));
+    };
+    const completing = function* (
+      rules: Iterable<Rule<GItem>>,
+      costOf: (it: GItem) => number,
+    ): Iterable<Rule<GItem>> {
+      for (const r of rules) {
+        const c = r.conclusion;
+        if (completes(c)) {
+          let cost = r.cost;
+          for (const p of r.premises) cost += costOf(p);
+          const s = spanOf(c.i, c.j);
+          const best = spanBest.get(s);
+          if (best === undefined || cost < best.cost) {
+            spanBest.set(s, { cost, item: c });
+          }
         }
-        return `o${it.i}.${it.j}.${it.cover ? 1 : 0}.${it.rec ? 1 : 0}.${
-          it.fix ? 1 : 0
-        }.${it.throughFact ? 1 : 0}.${it.node ?? -1}.${latin1(it.bytes)}`;
-      },
+        yield r;
+      }
+    };
+    const meter = this.host.meter;
+
+    return {
+      key: chartKey,
       *axioms() {
         yield { item: { kind: "cover", p: 0 }, cost: 0 };
         // One out per tree leaf — content-defined chunks, far fewer than bytes.
@@ -735,35 +937,39 @@ export class GraphSearch {
         const right = it.kind === "cover" ? it.p : it.j;
         return (queryLen - right) * MICRO;
       },
-      rules: (it) => {
+      rules: (it, costOf) => {
         if (it.kind === "cover") {
           return this.coverRules(it, coversDone, coverableByStart);
         }
+        if (dominated(it, costOf(it))) {
+          if (meter) meter.searchDominated++;
+          return [];
+        }
         if (it.kind === "form") {
-          return this.formRules(
-            it,
-            conceptTarget,
-            substitutions,
-            nodeBytes,
-            queryLen,
+          return completing(
+            this.formRules(it, concepts, substitutions, nodeBytes),
+            costOf,
           );
         }
-        return this.outRules(it, {
-          W,
-          splits,
-          atomsAreHubs,
-          coversDone,
-          outsByStart,
-          outsByEnd,
-          outsByNode,
-          coverableByStart,
-          findLeafU,
-          findBranchU,
-          linksByLeft,
-          linksByRight,
-          queryBytes,
-          queryLen,
-        });
+        return completing(
+          this.outRules(it, {
+            W,
+            splits,
+            atomsAreHubs,
+            coversDone,
+            outsByStart,
+            outsByEnd,
+            outsByNode,
+            coverableByStart,
+            findLeafU,
+            findBranchU,
+            linksByLeft,
+            linksByRight,
+            connectors,
+            joins,
+          }),
+          costOf,
+        );
       },
     };
   }
@@ -815,19 +1021,24 @@ export class GraphSearch {
 
   /** The connector-SPLICE rule for an oriented (l, r) pair, or null when the
    *  pair does not qualify — the ONE body behind {@link outRules}' two
-   *  mirror loops (this-as-left over resolved right partners, this-as-right
-   *  over resolved left partners).  Fires only when both sides are
+   *  mirror loops (this-as-left over offered right partners, this-as-right
+   *  over offered left partners).  Fires only when both sides are
    *  recognised, r starts at or after l ends, and the gap between them is
    *  empty or wholly recognised — never across the asker's own literal
-   *  separator. */
+   *  separator — and the pair's connector is granted and learnt.  A qualifying
+   *  pair not yet granted is ASKED for (see {@link ConnectorLicence}). */
   private trySplice(
     l: OutItem,
     r: OutItem,
-    link: Uint8Array,
+    key: string,
+    licence: ConnectorLicence,
     outsByEnd: Map<number, OutItem[]>,
   ): Rule<GItem> | null {
     if (!l.rec || !r.rec || r.i < l.j) return null;
     if (!this.gapRecognised(l.j, r.i, outsByEnd)) return null;
+    const link = licence.granted.get(key);
+    if (link === undefined) licence.asked.add(key);
+    if (!link) return null;
     return {
       premises: [l, r],
       conclusion: {
@@ -847,11 +1058,15 @@ export class GraphSearch {
    *  emit its substitute voice directly. */
   private *formRules(
     it: Extract<GItem, { kind: "form" }>,
-    conceptTarget: ReadonlyMap<number, number>,
+    concepts: ConceptLicence,
     substitutions: ReadonlyMap<number, Uint8Array> | undefined,
     nodeBytes: (n: number) => Uint8Array,
-    queryLen: number,
   ): Iterable<Rule<GItem>> {
+    // An asking form reached the agenda's front: the hop it stands for is due.
+    if (it.ask) {
+      concepts.asked.add(it.node);
+      return;
+    }
     // Articulation: emit voice bytes at the recognised span; the hop/concept/
     // emit chain is suppressed — the form contributes only its substitute.
     if (substitutions) {
@@ -886,41 +1101,17 @@ export class GraphSearch {
       // guard then dead-ends it) with no way to reach the forward edge.
       // Forking offers every continuation as its own rule so the one that
       // genuinely advances (not a duplicate) is still reachable.
-      // A CHAIN HOP OFFERS ONLY WHAT THE QUESTION CAN PAY FOR.
-      //
-      // `hubBound` = √N is the READ cap — every read here stays inside it — but
-      // it is not an exploration bound: measured, a hub of degree 1083 sits
-      // BELOW √N = 1559, so a hop offered all 1083 continuations, the chart grew
-      // to 3113 outs for a two-word question, and since every out with an
-      // uncovered tail probes its tail's prefixes (measured: 16 885 canonical
-      // probes = 87% of that query's work, and its 270 MB peak / 256 MB OOM),
-      // the cost came from OFFERING rather than from reading.
       //
-      // The bound is derived, not tuned: a derivation of L hops consumes ~L
-      // units of the question, so a hop cannot be paid for by offering more
-      // continuations than the question has units —
-      // `ceil(queryLen / W)`, floored at 2 for plurality. It is QUERY-sized
-      // (invariant 5: no per-query read grows with N) and it leaves `hubBound`
-      // and every read untouched.
-      // THE OFFER IS THE CORPUS'S OWN STRUCTURE, and the search pays for
-      // exploring it.  There is no offer cap here any more: the traversal cap I
-      // had put on this hop was a short-circuit — it bounded what a hop could
-      // OFFER instead of charging for it — and it was not needed.
-      //
-      // MEASURED in the regime where it used to bite (`hubBound = ceil(√N)`
-      // GREATER than the hub's degree — reached in a fixture by choosing the
-      // degree below √N, so the trained store is not needed): with the cap the
-      // offer was 8/9/9 continuations at degrees 35/70/120; without it, 52/84/120
-      // — and the WORK is LINEAR in the degree, not quadratic: pushes 262/296/332,
-      // perceptions 530/592/757, while the PEAK is identical with and without the
-      // cap (218/415/689 MB against 215/410/662) because it is set by the store,
-      // not by the fan-out.  What made this hop expensive was never the fan-out
-      // breadth: it was the per-offer work, two duplicate/oversized computations
-      // since removed (the per-offset canonical scan, and the tail scan now
-      // restricted to the fold's boundaries).
-      //
-      // The residual, stated: the trained store's hub (degree 1 083) is an
-      // EXTRAPOLATION from this linear shape, not a measurement.
+      // THE OFFER IS THE CORPUS'S OWN STRUCTURE, and the search pays for it.
+      // In the closure law's terms (derivation.ts) a hop is a MOVE — it reaches
+      // structure the derivation has not stood on — so it is admitted on that
+      // ground and priced one STEP; the A*LD search, not a count, decides how
+      // many are worth taking.  `hubBound` is the READ cap (invariant 5) and
+      // nothing else bounds the offer: a cap on what a hop may OFFER was tried
+      // and removed as a short-circuit (trap 13).  Measured with the hub's
+      // degree below √N: the work is LINEAR in the degree (pushes 262/296/332 at
+      // degrees 35/70/120) and the peak is set by the store, not the fan-out
+      // (test/112 pins the non-quadratic shape).
       const nx = this.store.nextFirst(it.node, this.hubBound());
       // Count what is OFFERED, not what was read: the evidence-preferred
       // continuation is yielded too, even when it lies outside the cap.
@@ -1071,8 +1262,24 @@ export class GraphSearch {
       // Recognised but edge-less: borrow a concept (halo) sibling's edge.  No
       // edge and no concept means the form leads nowhere — it yields no rule, so
       // a query of only such forms produces no derivation, and think is silent.
-      const target = conceptTarget.get(it.node);
-      if (target !== undefined) {
+      // An offered form not yet granted yields the hop's ASKING form at the
+      // hop's own cost and span (see {@link Licence}).
+      if (!concepts.offered.has(it.node)) return;
+      const target = concepts.granted.get(it.node);
+      if (target === undefined) {
+        yield {
+          premises: [it],
+          conclusion: {
+            kind: "form",
+            i: it.i,
+            j: it.j,
+            node: it.node,
+            via: true,
+            ask: true,
+          },
+          cost: CONCEPT,
+        };
+      } else if (target !== null) {
         yield {
           premises: [it],
           conclusion: {
@@ -1211,7 +1418,7 @@ export class GraphSearch {
           leaves: rec.leaves,
           splits: rec.splits,
         },
-        new Map(),
+        noLicence(),
         undefined,
         undefined,
         undefined,
@@ -1245,6 +1452,14 @@ export class GraphSearch {
    *  outs of a long query re-cover each distinct node at most once); reset at the
    *  top of {@link cover}. */
   private recompleteMemo = new Map<number, Uint8Array | null>();
+  /** {@link entityProposals}, per fact BYTES — a pure function of them while
+   *  the store is read-only (one response), so a fact the chart reaches as
+   *  several items (cover/fix variants, nested completions) is scanned once.
+   *  Reset at the top of {@link cover}, like {@link recompleteMemo}. */
+  private entityMemo = new Map<string, EntityProposals>();
+  /** The joins licensed under one cover's {@link Licence}, kept across its
+   *  re-covers (see {@link solve}). */
+  private readonly joinsKept = new WeakMap<ConceptLicence, JoinLicense>();
   /** The derivation sink of the TOP cover, threaded into every nested
    *  completion so a produced form's own recompositions are reported in the
    *  same trace instead of vanishing after the first layer.  Undefined when
@@ -1260,6 +1475,57 @@ export class GraphSearch {
    *  open — the invariant a reader needs to check the guard. */
   private recompleteOpen = new Set<number>();
 
+  /** The ENTITIES a produced fact's bytes contain that lead somewhere — the
+   *  candidates a join may travel through.  The forms the fact CONTAINS, by the
+   *  same recogniser the query went through (so the evidence standard is the
+   *  query's), plus — because the recognition of a STORED WHOLE returns the
+   *  whole and stops (measured: one site, the fact's own node, for `The
+   *  director of Eva is Gustaf Molander.`) — the longest canonically-resolving
+   *  form at each offset.  A byte atom is never a subject.  The scan runs only
+   *  for a FORM (≥ W: per letter it measured 20-26 s in test/99), and each probe
+   *  is a `canonResolve` whose exact tier decides a miss by its segment probe,
+   *  without a fold.  The admission predicate is the store's `leadsSomewhere`
+   *  (edge or halo); the host lends its memoised form when it can.
+   *
+   *  The SOURCE of each proposal travels with it, so a refusal names which path
+   *  proposed the candidate.  Memoised per fact bytes ({@link entityMemo}). */
+  private entityProposals(factBytes: Uint8Array): EntityProposals {
+    const memoKey = latin1(factBytes);
+    const hit = this.entityMemo.get(memoKey);
+    if (hit !== undefined) return hit;
+    const leads = (id: number): boolean =>
+      this.host.leadsSomewhere !== undefined
+        ? this.host.leadsSomewhere(id)
+        : this.store.leadsSomewhere(id);
+    const sites = this.host.recogniseSpan?.(factBytes)?.sites ?? [];
+    const proposed = new Map<number, Uint8Array>();
+    const source = new Map<number, string>();
+    for (const s of sites) {
+      if (s.payload >= 0 && leads(s.payload)) {
+        proposed.set(s.payload, this.store.bytesPrefix(s.payload, ALL));
+        source.set(s.payload, "recognised site");
+      }
+    }
+    const W = this.maxGroup;
+    if (this.host.canonResolve !== undefined && factBytes.length >= W) {
+      const canon = this.host.canonResolve.bind(this.host);
+      for (let start = 0; start < factBytes.length; start++) {
+        for (let end = factBytes.length; end - start >= W; end--) {
+          const id = canon(factBytes.subarray(start, end));
+          if (id === null) continue;
+          if (leads(id)) {
+            proposed.set(id, this.store.bytesPrefix(id, ALL));
+            source.set(id, "canonical fold");
+          }
+          break; // the longest form at this offset wins
+        }
+      }
+    }
+    const out = { proposed, source, sites };
+    this.entityMemo.set(memoKey, out);
+    return out;
+  }
+
   /** DERIVE-THROUGH — a RULE this module's DeductionSystem was missing.  The
    *  A*LD library is untouched: this is one more `premises → conclusion + cost`
    *  rule in the system {@link buildSearch} hands to {@link lightestDerivation},
@@ -1274,7 +1540,10 @@ export class GraphSearch {
    *  fact reached through it.  On the ladder it is one STEP: a direct edge,
    *  exactly as following a literal continuation is.  Deterministic and
    *  point-probed (`resolve` + `nextFirst`, no scan), so it adds no read that
-   *  grows with the corpus.  The move is visible in the rationale as its own act
+   *  grows with the corpus.  Asked ONCE per fact a lightest derivation stood on
+   *  (the join license, {@link solve}) — never per fact the exploration merely
+   *  reached — so the number of facts it prices is the answer's, not the
+   *  corpus's.  The move is visible in the rationale as its own act
    *  (`classifyMove` reports `derive-through`), distinct from the
    *  byte-concatenating `fuse`/`splice` — and named `derive-through` rather than
    *  `join` so it cannot be read as the confluence mechanism's `Provenance`. */
@@ -1282,13 +1551,14 @@ export class GraphSearch {
     fact: OutItem,
     queryBytes: Uint8Array,
     queryLen: number,
+    queryNodes: () => ReadonlySet<number>,
   ): Iterable<Rule<GItem>> {
     if (!this.host.recogniseSpan) return;
     const tail = queryBytes.subarray(fact.j, queryLen);
     if (tail.length === 0) return;
-    // Report ONLY the invocations that could have joined: the search asks this
-    // rule for every finalized out with a node, which includes the one-byte
-    // outs the cover bridges with — measured, 68 refusals for a single
+    // Report ONLY the invocations that could have joined: a derivation stands on
+    // node-bearing outs of every width, including the one-byte outs the cover
+    // bridges with — measured, 68 refusals for a single
     // 3-relation query, all of them letters.  A form shorter than one window is
     // not a fact a join could travel through, so it is not a refusal worth
     // reporting; W is the same line the rest of the mind draws between a chance
@@ -1298,69 +1568,24 @@ export class GraphSearch {
     // same recogniser the query went through, so the evidence standard is the
     // query's.  A byte atom is never a subject; the fact's own node is the span
     // itself, not an entity inside it.  The admission predicate has ONE
-    // definition — `traverse.ts`'s `leadsSomewhere` (edge or halo); the host
-    // LENDS it when it can (Mind does, with the response-scoped struct cache),
-    // and a bare host falls back to the raw-store probe, so the search stays
+    // definition — the store's `leadsSomewhere` (edge or halo); the host LENDS
+    // its memoised form when it can (Mind does, with the response-scoped struct
+    // cache), and a bare host asks the store directly, so the search stays
     // host-based.
-    const factRec = this.host.recogniseSpan(fact.bytes);
-    const leads = (id: number): boolean =>
-      this.host.leadsSomewhere !== undefined
-        ? this.host.leadsSomewhere(id)
-        : this.store.hasNext(id) || this.store.hasHalo(id);
+    const { proposed, source, sites: factSites } = this.entityProposals(
+      fact.bytes,
+    );
     // THE QUERY'S OWN SUBJECT, CANONICALLY.  The filter used raw bytes and the
     // store's nodes are canonical, so `Eiffel Tower country` in the query did
     // not match the deposited `eiffel tower country` — measured, that is the
-    // trap's wrong answer.
-    //
-    // TAKEN FROM THE RECOGNITION THE RESPONSE ALREADY COMPUTED — the host's
-    // `recogniseSpan`, the same surface the rest of this search uses — not from
-    // a second offset scan.  `canonicalQueryNodes` re-derived, per byte offset,
-    // what `recognise` had already resolved once per query (its memo is keyed by
-    // content), and that scan was the largest single cost the DIANOT join added:
-    // measured against the pre-change tree, the same fixture and the same test
-    // were 21 s slower with the scan than without it.  A recognised site IS a
-    // canonical node of the query that can lead somewhere, which is exactly the
-    // set this filter wants, and it costs nothing to read.
-    const queryNodes = new Set<number>(
-      (this.host.recogniseSpan?.(queryBytes)?.sites ?? []).map((s) =>
-        s.payload
-      ),
-    );
-    // TWO SOURCES, ONE ADMISSION.  The recognition of a STORED WHOLE returns the
-    // whole and stops — measured: for `The director of Eva is Gustaf Molander.`
-    // it yields exactly ONE site, the fact's own node — so the entity a join
-    // exists for is never proposed.  The canonical fold is the second source,
-    // and the scan runs only for a FORM (≥ W: a one-byte out is not something to
-    // join through, and running it per letter measured 20-26 s in test/99).
-    const W = this.maxGroup;
-    const proposed = new Map<number, Uint8Array>();
-    // The SOURCE of each proposal travels with it: a refusal that names only the
-    // bytes leaves the next reader guessing which path proposed them — three
-    // attempts at the chained join were spent fixing paths that never produced
-    // the offending candidate.
-    const source = new Map<number, string>();
-    for (const s of factRec.sites) {
-      if (s.payload >= 0 && leads(s.payload)) {
-        proposed.set(s.payload, this.store.bytesPrefix(s.payload, ALL));
-        source.set(s.payload, "recognised site");
-      }
-    }
-    if (this.host.canonResolve !== undefined && fact.bytes.length >= W) {
-      const canon = this.host.canonResolve.bind(this.host);
-      for (let start = 0; start < fact.bytes.length; start++) {
-        for (let end = fact.bytes.length; end - start >= W; end--) {
-          const id = canon(fact.bytes.subarray(start, end));
-          if (id === null) continue;
-          if (leads(id)) {
-            proposed.set(id, this.store.bytesPrefix(id, ALL));
-            source.set(id, "canonical fold");
-          }
-          break; // the longest form at this offset wins
-        }
-      }
-    }
+    // trap's wrong answer.  Read from the recognition the response already
+    // computed (`queryNodes`, once per solve), never from a second offset scan:
+    // a per-offset `canonicalQueryNodes` re-derived what `recognise` had
+    // resolved once, and was the largest single cost the join first added.
     const leading = [...proposed]
-      .filter(([payload]) => payload !== fact.node && !queryNodes.has(payload))
+      .filter(([payload]) =>
+        payload !== fact.node && !queryNodes().has(payload)
+      )
       .map(([payload, bytes]) => ({ payload, bytes }));
     // …then prefer the entity the query did NOT name, and the MAXIMAL one.  The
     // join exists to reach the subject the query never wrote, so:
@@ -1378,13 +1603,13 @@ export class GraphSearch {
         // Report WHAT the recognition returned, not just that nothing led: the
         // count and the first few site texts are the difference between "the
         // fact was not recognised" and "it was recognised but nothing led".
-        const seen = factRec.sites.slice(0, 3).map((s) =>
+        const seen = factSites.slice(0, 3).map((s) =>
           this.store.bytesPrefix(s.payload, ALL)
         );
         this.host.reportSearch?.(
           "deriveThroughMiss",
           [fact.bytes, tail, ...seen],
-          `no entity inside the fact leads anywhere — ${factRec.sites.length} site(s) recognised inside it`,
+          `no entity inside the fact leads anywhere — ${factSites.length} site(s) recognised inside it`,
         );
       }
     }
@@ -1496,8 +1721,8 @@ export class GraphSearch {
   /** out(i,j,bytes,…): index it for the binary rules, then offer splicing a
    *  learnt connector (the in-search bridge), splitting (at a sub-leaf form
    *  boundary), bridging (cover(i) ∧ this → cover(j)), fusing with an adjacent
-   *  finalised out, and — for a produced fact — JOINING the entity it contains
-   *  with the query's tail ({@link deriveThrough}). */
+   *  finalised out, and — for a LICENSED fact — JOINING the entity it contains
+   *  with the query's tail ({@link deriveThrough}, granted in {@link solve}). */
   private *outRules(
     it: OutItem,
     ctx: {
@@ -1511,16 +1736,16 @@ export class GraphSearch {
       coverableByStart: Map<number, OutItem[]>;
       findLeafU: (b: Uint8Array) => number | undefined;
       findBranchU: (k: number[]) => number | undefined;
-      linksByLeft?: ReadonlyMap<number, Array<[number, Uint8Array]>>;
-      linksByRight?: ReadonlyMap<number, Array<[number, Uint8Array]>>;
-      queryBytes: Uint8Array;
-      queryLen: number;
+      linksByLeft: ReadonlyMap<number, Array<[number, string]>>;
+      linksByRight: ReadonlyMap<number, Array<[number, string]>>;
+      connectors?: ConnectorLicence;
+      joins: JoinLicense;
     },
   ): Iterable<Rule<GItem>> {
     const { splits, coversDone, outsByStart, outsByEnd, coverableByStart } =
       ctx;
     const outsByNode = ctx.outsByNode;
-    const byRight = ctx.linksByRight ?? new Map();
+    const byRight = ctx.linksByRight;
     pushInto(outsByStart, it.i, it);
     pushInto(outsByEnd, it.j, it);
     if (it.rec && it.node !== undefined) pushInto(outsByNode, it.node, it);
@@ -1536,23 +1761,25 @@ export class GraphSearch {
     // Points 2 & 5) — but NEVER across the asker's own unrecognised separator (a
     // space, comma), so "ice fire" stays "cold hot", never "cold or hot".
     //
-    // Cost stays bounded by iterating only the FEW resolved connector targets of
+    // Cost stays bounded by iterating only the FEW offered connector targets of
     // this out's node (links are selective and, for the N-ary case, keyed first→
     // later — O(parts), not O(parts²)), and matching them against finalised outs
-    // by node id, rather than scanning every position pair.
+    // by node id, rather than scanning every position pair.  A pair is bridged
+    // only once its two premises have met here ({@link ConnectorLicence}).
     const byLeft = ctx.linksByLeft;
-    if (byLeft && it.rec && it.node !== undefined) {
-      // L = this out, R = a later out whose node is a resolved target.
-      for (const [rNode, link] of byLeft.get(it.node) ?? []) {
+    const licence = ctx.connectors;
+    if (licence && it.rec && it.node !== undefined) {
+      // L = this out, R = a later out whose node is an offered target.
+      for (const [rNode, key] of byLeft.get(it.node) ?? []) {
         for (const r of outsByNode.get(rNode) ?? []) {
-          const rule = this.trySplice(it, r, link, outsByEnd);
+          const rule = this.trySplice(it, r, key, licence, outsByEnd);
           if (rule) yield rule;
         }
       }
-      // R = this out, L = an earlier out whose node has a resolved target here.
-      for (const [lNode, link] of byRight.get(it.node) ?? []) {
+      // R = this out, L = an earlier out whose node has an offered target here.
+      for (const [lNode, key] of byRight.get(it.node) ?? []) {
         for (const l of outsByNode.get(lNode) ?? []) {
-          const rule = this.trySplice(l, it, link, outsByEnd);
+          const rule = this.trySplice(l, it, key, licence, outsByEnd);
           if (rule) yield rule;
         }
       }
@@ -1615,10 +1842,11 @@ export class GraphSearch {
     // continuation is the derived answer — a genuine relational join, distinct
     // from the confluence mechanism's `join` PROVENANCE — and not the
     // juxtaposition the cover produces when the intermediate key IS named.
-    // Fired per finalized out with a node, so it is the search's own rule, on
-    // the ladder, memoised by {@link key}, and bounded by the fact's own length.
-    if (it.node !== undefined) {
-      yield* this.deriveThrough(it, ctx.queryBytes, ctx.queryLen);
+    // On the ladder and memoised by {@link key} like every rule, but fired only
+    // for a fact the solve has LICENSED (a fact a lightest derivation stood on —
+    // see {@link solve}), from the joins computed for it once.
+    for (const g of ctx.joins.get(chartKey(it)) ?? []) {
+      yield { premises: [it], conclusion: g.conclusion, cost: g.cost };
     }
   }