@hviana/sema 0.9.0 → 0.9.2

package/src/mind/learning.ts

@@ -7,13 +7,7 @@ import { addInto, normalize, Vec, zeros } from "../vec.js";
 import { bindSeat, companySignature, isChunk, Sema } from "../sema.js";
 import type { Input, MindContext } from "./types.js";
 import { changedNodes } from "./types.js";
-import {
-  inputBytes,
-  latin1Key,
-  perceive,
-  perceiveDeposit,
-  resolve,
-} from "./primitives.js";
+import { inputBytes, perceiveDeposit, resolve } from "./primitives.js";
 import { canonicalWindows, leafIdPrefix } from "./canonical.js";
 import { rItem, rNode } from "./trace.js";
 import { hubBound } from "./traverse.js";

package/src/mind/match.ts

@@ -40,7 +40,7 @@ import {
 } from "../geometry.js";
 import { bytesEqual, indexOf, latin1 } from "../bytes.js";
 import type { MindContext } from "./types.js";
-import { chainReach, leafIdRun } from "./canonical.js";
+import { leafIdRun } from "./canonical.js";
 import { foldTree, gistOf, perceive, read, resolve } from "./primitives.js";
 import {
   argmaxCosine,
@@ -54,7 +54,6 @@ import {
   sharedReachMemo,
 } from "./traverse.js";
 import { recognise, segment } from "./recognition.js";
-import { rItem } from "./trace.js";
 import type { Site } from "./graph-search.js";
 
 // ═══════════════════════════════════════════════════════════════════════════

package/src/mind/mechanisms/cast.ts

@@ -31,9 +31,8 @@ import {
 } from "../match.js";
 import { joinWithBridge } from "../resonance.js";
 import { CONCEPT, STEP } from "../graph-search.js";
-import { concat2, indexOf } from "../../bytes.js";
+import { indexOf } from "../../bytes.js";
 import { consensusFloor, dominates } from "../../geometry.js";
-import { decodeText } from "../rationale.js";
 import { restates, unexplainedSpans } from "../derivation.js";
 import { rItem, rNode } from "../trace.js";
 import { dismissedKnownContent } from "../bridge.js";

package/src/mind/mechanisms/cover.ts

@@ -10,55 +10,91 @@
 // ordinary admissible-floor check, with no extension special-case anywhere.
 
 import type { MindContext } from "../types.js";
-import type { ComputedResult, Site } from "../graph-search.js";
+import type {
+  ComputedResult,
+  ConceptLicence,
+  ConnectorLicence,
+  DerivationStep,
+  Site,
+} from "../graph-search.js";
 import { read, resolve } from "../primitives.js";
-import { guidedFirst, hubBound } from "../traverse.js";
+import {
+  guidedFirst,
+  hubBound,
+  namedContinuations,
+  scaffoldSpans,
+} from "../traverse.js";
 import { conceptHop } from "../match.js";
 import { bridge } from "../resonance.js";
 import { liftAnswer, liftedScaffolding, segRestatesQuery } from "../types.js";
 import { decodeText } from "../rationale.js";
 import { insideAnsweredTurn, restates } from "../derivation.js";
-import { indexOf } from "../../bytes.js";
 import type { RationaleItem } from "../rationale.js";
 import { rItem, rNode, traceDerivation } from "../trace.js";
 import type { PipelineMechanism } from "../pipeline-mechanism.js";
 
 // ── Concept / connector pre-resolution ──────────────────────────────────────
 
-export async function resolveConcepts(
+/** The concept hops the cover may take, OFFERED up front and looked up only
+ *  when the search asks (see {@link Licence}): every recognised form with no
+ *  continuation of its own may borrow a halo sibling's. */
+export interface CoverConcepts extends ConceptLicence {
+  /** Look up the asked forms' concept targets not yet granted. */
+  grant(nodes: Iterable<number>): Promise<void>;
+}
+
+export function offerConcepts(
   ctx: MindContext,
-  sites: Site[],
-): Promise<Map<number, number>> {
-  const target = new Map<number, number>();
-  const visited = new Set<number>();
+  sites: ReadonlyArray<Site>,
+): CoverConcepts {
+  const offered = new Set<number>();
   for (const { payload: n } of sites) {
-    if (visited.has(n)) continue;
-    visited.add(n);
-    if (ctx.store.hasNext(n)) continue;
-    const hop = await conceptHop(ctx, n);
-    if (hop !== null) target.set(n, hop);
-  }
-  if (target.size > 0) {
-    ctx.trace?.step(
-      "resolveConcepts",
-      [...target.keys()].map((n) => rNode(ctx, n, "edgeless-form")),
-      [...target.values()].map((h) => rNode(ctx, h, "concept-sibling")),
-      "borrow a synonym's continuation edge for each edge-less form (a concept/halo hop)",
-    );
+    if (!offered.has(n) && !ctx.store.hasNext(n)) offered.add(n);
   }
-  return target;
+  const granted = new Map<number, number | null>();
+  return {
+    offered,
+    granted,
+    asked: new Set(),
+    async grant(nodes) {
+      const found: Array<[number, number]> = [];
+      for (const n of nodes) {
+        if (granted.has(n)) continue;
+        const hop = await conceptHop(ctx, n);
+        granted.set(n, hop);
+        if (hop !== null) found.push([n, hop]);
+      }
+      if (found.length > 0) {
+        ctx.trace?.step(
+          "resolveConcepts",
+          found.map(([n]) => rNode(ctx, n, "edgeless-form")),
+          found.map(([, h]) => rNode(ctx, h, "concept-sibling")),
+          "borrow a synonym's continuation edge for each edge-less form the search reached (a concept/halo hop)",
+        );
+      }
+    },
+  };
+}
+
+/** The connectors the cover may splice, OFFERED up front and BRIDGED only when
+ *  the search asks (see {@link ConnectorLicence}): every pair a learnt whole
+ *  could run together — two touching sites, each side as itself or as its
+ *  answer, in both orders — and, when three or more answers are recognised, the
+ *  first answer to each later one (the N-ary whole). */
+export interface CoverConnectors extends ConnectorLicence {
+  /** Bridge the asked pairs not yet granted. */
+  grant(keys: Iterable<string>): Promise<void>;
 }
 
-export async function resolveConnectors(
+export function offerConnectors(
   ctx: MindContext,
   sites: ReadonlyArray<Site>,
   query?: Uint8Array,
-): Promise<Map<string, Uint8Array>> {
-  const links = new Map<string, Uint8Array>();
+): CoverConnectors {
   const answerOf = (n: number) => guidedFirst(ctx, n) ?? n;
   // A site's continuation already present elsewhere in the query is stale
   // transcript evidence: cover still needs the site for structural context,
-  // but liftAnswer will trim that continuation as already answered. Building
+  // but liftAnswer will trim that continuation as already answered. Offering
   // pairwise/n-ary bridges for it can only create connectors that are later
   // discarded — a semantically neutral gate (it removes work whose product
   // liftAnswer throws away), and a cumulative (multi-turn) query is exactly
@@ -98,20 +134,16 @@ export async function resolveConnectors(
         return restates(query, bytes, 0);
       });
     });
-  const bridgePair = async (l: number, r: number) => {
-    if (l === r || links.has(l + "," + r)) return;
-    if (ctx.meter) ctx.meter.coverBridges++;
-    const link = await bridge(ctx, read(ctx, l), read(ctx, r));
-    if (link !== null) links.set(l + "," + r, link);
-  };
+  const pairwise = new Set<string>();
   for (let i = 0; i + 1 < ordered.length; i++) {
     if (ordered[i].end !== ordered[i + 1].start) continue;
     const lefts = [ordered[i].payload, answerOf(ordered[i].payload)];
     const rights = [ordered[i + 1].payload, answerOf(ordered[i + 1].payload)];
     for (const l of new Set(lefts)) {
       for (const r of new Set(rights)) {
-        await bridgePair(l, r);
-        await bridgePair(r, l);
+        if (l === r) continue;
+        pairwise.add(l + "," + r);
+        pairwise.add(r + "," + l);
       }
     }
   }
@@ -123,46 +155,70 @@ export async function resolveConnectors(
     seenN.add(node);
     orderedNodes.push({ node, bytes: read(ctx, node) });
   }
+  const nary = new Map<
+    string,
+    { left: Uint8Array; right: Uint8Array; allowance: number }
+  >();
   if (orderedNodes.length >= 3) {
     const first = orderedNodes[0];
     const W = ctx.space.maxGroup;
     let middleBytes = 0; // Σ bytes of the answers BETWEEN first and m-th
     for (let m = 1; m < orderedNodes.length; m++) {
-      const key = first.node + "," + orderedNodes[m].node;
-      if (links.has(key)) {
-        middleBytes += orderedNodes[m].bytes.length;
-        continue;
-      }
       // The N-ary interior legitimately holds every intermediate answer
       // plus one W-quantum of glue per joint — pass that allowance so the
-      // bridge's phrase-scale cap admits the whole learnt run.
-      const allowance = middleBytes + (m + 1) * W;
-      if (ctx.meter) {
-        ctx.meter.coverBridges++;
-        ctx.meter.coverAllowanceBytes += allowance;
-      }
-      const interior = await bridge(
-        ctx,
-        first.bytes,
-        orderedNodes[m].bytes,
-        allowance,
-      );
-      if (interior !== null) links.set(key, interior);
+      // bridge's phrase-scale cap admits the whole learnt run.  Asked only
+      // when the pairwise bridge of the same key (if offered) found nothing.
+      nary.set(first.node + "," + orderedNodes[m].node, {
+        left: first.bytes,
+        right: orderedNodes[m].bytes,
+        allowance: middleBytes + (m + 1) * W,
+      });
       middleBytes += orderedNodes[m].bytes.length;
     }
   }
-  if (links.size > 0) {
-    ctx.trace?.step(
-      "resolveConnectors",
-      ordered.map((s) => rItem(read(ctx, s.payload), "answer", s.payload)),
-      [...links.entries()].map(([pair, bytes]) => ({
-        text: `${pair}: "${decodeText(bytes)}"`,
-        role: "connector",
-      } as RationaleItem)),
-      "the bytes the graph splices between adjacent answers (asked of the gist space)",
-    );
-  }
-  return links;
+  const granted = new Map<string, Uint8Array | null>();
+  return {
+    offered: new Set([...pairwise, ...nary.keys()]),
+    granted,
+    asked: new Set(),
+    async grant(keys) {
+      const found: Array<[string, Uint8Array]> = [];
+      for (const key of keys) {
+        if (granted.has(key)) continue;
+        let link: Uint8Array | null = null;
+        if (pairwise.has(key)) {
+          const comma = key.indexOf(",");
+          if (ctx.meter) ctx.meter.coverBridges++;
+          link = await bridge(
+            ctx,
+            read(ctx, Number(key.slice(0, comma))),
+            read(ctx, Number(key.slice(comma + 1))),
+          );
+        }
+        const whole = nary.get(key);
+        if (link === null && whole !== undefined) {
+          if (ctx.meter) {
+            ctx.meter.coverBridges++;
+            ctx.meter.coverAllowanceBytes += whole.allowance;
+          }
+          link = await bridge(ctx, whole.left, whole.right, whole.allowance);
+        }
+        granted.set(key, link);
+        if (link !== null) found.push([key, link]);
+      }
+      if (found.length > 0) {
+        ctx.trace?.step(
+          "resolveConnectors",
+          ordered.map((s) => rItem(read(ctx, s.payload), "answer", s.payload)),
+          found.map(([pair, bytes]) => ({
+            text: `${pair}: "${decodeText(bytes)}"`,
+            role: "connector",
+          } as RationaleItem)),
+          "the bytes the graph splices between adjacent answers the search reached (asked of the gist space)",
+        );
+      }
+    },
+  };
 }
 
 // ── Pipeline mechanism ──────────────────────────────────────────────────────
@@ -178,7 +234,7 @@ export const coverMechanism: PipelineMechanism = {
 
     // Masking: computed spans are authoritative.  Remove recognised sites
     // that overlap any computed span before building the cover search.
-    const sites = computed.length === 0
+    let sites = computed.length === 0
       ? rec.sites
       : rec.sites.filter((s) =>
         !computed.some((u) => s.start < u.j && u.i < s.end)
@@ -203,14 +259,53 @@ 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
+      );
+    if (leading.length < sites.length) {
+      if (ctx.meter) {
+        ctx.meter.unaskedFragments += sites.length - leading.length;
+      }
+      ctx.trace?.step(
+        "unaskedFragments",
+        sites.filter((s) => !leading.includes(s)).map((s) =>
+          rItem(query.subarray(s.start, s.end), "fragment", s.payload, [
+            s.start,
+            s.end,
+          ])
+        ),
+        [],
+        "a piece of other forms whose continuations the question names none of — it answers other questions",
+      );
+      sites = leading;
+    }
+
     if (sites.length === 0 && computed.length === 0) return [];
 
     const connectors = ctx.meter
-      ? await ctx.meter.time(
-        "cover.resolveConnectors",
-        () => resolveConnectors(ctx, sites, query),
+      ? ctx.meter.timeSync(
+        "cover.offerConnectors",
+        () => offerConnectors(ctx, sites, query),
       )
-      : await resolveConnectors(ctx, sites, query);
+      : offerConnectors(ctx, sites, query);
     let splits = rec.splits;
     if (computed.length > 0) {
       splits = new Set(rec.splits);
@@ -220,17 +315,15 @@ export const coverMechanism: PipelineMechanism = {
       }
     }
     const concepts = ctx.meter
-      ? await ctx.meter.time(
-        "cover.resolveConcepts",
-        () => resolveConcepts(ctx, sites),
+      ? ctx.meter.timeSync(
+        "cover.offerConcepts",
+        () => offerConcepts(ctx, sites),
       )
-      : await resolveConcepts(ctx, sites);
+      : offerConcepts(ctx, sites);
 
     const coverDeps = [
       ctx.trace?.lastIndex("recognise"),
       ctx.trace?.lastIndex("computeExtensions"),
-      ctx.trace?.lastIndex("resolveConcepts"),
-      ctx.trace?.lastIndex("resolveConnectors"),
     ].filter((x): x is number => x !== undefined);
 
     // Convert ComputedSpan[] to ComputedResult[] for the graph search.
@@ -251,17 +344,33 @@ export const coverMechanism: PipelineMechanism = {
       ...computedResults.map((u) => rItem(u.bytes, "computed")),
     ], coverDeps.length ? coverDeps : undefined);
 
-    const solved = ctx.search.cover(
-      query.length,
-      sites,
-      concepts,
-      rec.leaves,
-      splits,
-      undefined,
-      connectors,
-      computedResults,
-      ctx.trace ? (steps) => traceDerivation(ctx, steps) : undefined,
-    );
+    // COVER, GRANT WHAT IT ASKED, COVER AGAIN — until a cover asks for nothing
+    // (see Licence in graph-search.ts).  Only the final cover's derivations reach the
+    // rationale; a provisional one is superseded, not part of the answer.
+    let derivations: DerivationStep[][] = [];
+    let solved: ReturnType<typeof ctx.search.cover>;
+    for (;;) {
+      derivations = [];
+      solved = ctx.search.cover(
+        query.length,
+        sites,
+        concepts,
+        rec.leaves,
+        splits,
+        undefined,
+        connectors,
+        computedResults,
+        ctx.trace ? (steps) => derivations.push(steps) : undefined,
+      );
+      if (concepts.asked.size === 0 && connectors.asked.size === 0) break;
+      const grant = async () => {
+        await concepts.grant([...concepts.asked]);
+        await connectors.grant([...connectors.asked]);
+      };
+      if (ctx.meter) await ctx.meter.time("cover.grant", grant);
+      else await grant();
+    }
+    for (const steps of derivations) traceDerivation(ctx, steps);
     const segs = solved && solved.segs;
     tCover?.done(
       segs === null
@@ -317,8 +426,19 @@ export const coverMechanism: PipelineMechanism = {
     // restated span contributes nothing to the composed answer, so it must
     // not be priced as if it did (PASS-carried bytes are priced already;
     // the diagnostic label reflects the same distinction).
+    //
+    // …and a span made of nothing but corpus-global scaffolding names nothing:
+    // every window of it is a piece of more than √N stored forms, so the form
+    // recognised there — the song `What`, in the trained store — is one of
+    // thousands it could be.  Voicing that form's fact explains no byte the
+    // asker owes: measured, `What country is Jerry Bock a citizen of?` was won
+    // by `The performer of What is Melinda Marx.` glued onto the right fact.
+    const scaffold = scaffoldSpans(ctx, query);
     const accounted: Array<[number, number]> = segs
-      .filter((s) => s.rec && !segRestatesQuery(s, query, query.length, W))
+      .filter((s) =>
+        s.rec && !segRestatesQuery(s, query, query.length, W) &&
+        !scaffold.some(([a, b]) => a <= s.i && s.j <= b)
+      )
       .map((s) => [s.i, s.j]);
 
     return [{

package/src/mind/mechanisms/extraction.ts

@@ -8,8 +8,7 @@
 // that contains it.
 
 import type { MindContext } from "../types.js";
-import { read } from "../primitives.js";
-import { follow, isSpanShaped, locate, skillExemplar } from "../match.js";
+import { locate } from "../match.js";
 import { concatBytes, indexOf } from "../../bytes.js";
 import { decodeText } from "../rationale.js";
 import type {

package/src/mind/mechanisms/prefix-completion.ts

@@ -103,7 +103,7 @@ import { bytesEqual } from "../../bytes.js";
 import { rItem } from "../trace.js";
 import { formsOpenedBy } from "../traverse.js";
 import { STEP } from "../graph-search.js";
-import type { PipelineMechanism, Precomputed } from "../pipeline-mechanism.js";
+import type { PipelineMechanism } from "../pipeline-mechanism.js";
 
 /** A trained form the query opens, and the bytes by which it continues. */
 export interface PrefixCompletion {

package/src/mind/mechanisms/recall.ts

@@ -6,7 +6,6 @@
 
 import { cosine } from "../../vec.js";
 import {
-  conceptThreshold,
   consensusFloor,
   dominates,
   identityBar,
@@ -15,8 +14,14 @@ import {
 } from "../../geometry.js";
 import type { MindContext } from "../types.js";
 import { gistOf, read, resolve } from "../primitives.js";
-import { bytesEqual, indexOf } from "../../bytes.js";
-import { allWindowsAreScaffolding, corpusN, hubBound } from "../traverse.js";
+import { indexOf } from "../../bytes.js";
+import {
+  allWindowsAreScaffolding,
+  askedEvidence,
+  corpusN,
+  guidedFirst,
+  hubBound,
+} from "../traverse.js";
 import {
   follow,
   project,
@@ -73,7 +78,6 @@ export async function recallByResonance(
       ...(complete ? { complete } : {}),
     };
   };
-  const k = pre.k;
   const queryGist = pre.guide;
 
   // 0. Exact self-match — content-addressed, deterministic.
@@ -156,10 +160,18 @@ export async function recallByResonance(
         g !== null && g.length > 0 &&
         !lawRestates(query, g, 0, { proper: true })
       ) {
+        // EVIDENCE TRAVELS: when the question NAMED the continuation followed
+        // (traverse.ts, the exact tier — `Who is the father of Frederick II?`
+        // witnesses the father fact's own question `Frederick II father`), the
+        // spans that named it are explained too, not only the argument.
+        const hop = guidedFirst(ctx, arg.payload);
+        const named = hop === undefined
+          ? []
+          : askedEvidence(ctx, arg.payload, hop);
         return ground(
           g,
           "argument binding — the query's sole edge-source constituent, continuation followed",
-          [[arg.start, arg.end]],
+          [[arg.start, arg.end], ...named],
           STEP,
         );
       }

package/src/mind/mechanisms/reference.ts

@@ -38,7 +38,7 @@ import type { MindContext } from "../types.js";
 import type { FrameInstance } from "../match.js";
 import { carriesFillers, distinct, follow, substituteAll } from "../match.js";
 import { dominates } from "../../geometry.js";
-import { bytesEqual, indexOf } from "../../bytes.js";
+import { bytesEqual } from "../../bytes.js";
 import { restates } from "../derivation.js";
 import { STEP } from "../graph-search.js";
 import type {

package/src/mind/mind.ts

@@ -9,41 +9,20 @@
 // Architecture: 4 primitives × 2 patterns = all inference.
 // Implementation split across src/mind/*.ts — this file assembles the Mind class.
 
-import { cosine, makeKeyring, rng, setVecConfig, Vec } from "../vec.js";
-import { bindSeat, fold, Sema, Space } from "../sema.js";
+import { makeKeyring, rng, setVecConfig, Vec } from "../vec.js";
+import { Sema, Space } from "../sema.js";
 import { sampleCorpus, searchCorpus } from "./corpus.js";
 import type { CorpusPair, CorpusResult } from "./corpus.js";
 import { Alphabet } from "../alphabet.js";
-import {
-  bytesToTree,
-  contentFoldIncremental,
-  Grid,
-  gridToTree,
-  hilbertBytes,
-  reachThreshold,
-  stackGrids,
-} from "../geometry.js";
+import { contentFoldIncremental, Grid, reachThreshold } from "../geometry.js";
 import { keyEnds } from "./canonical.js";
 import type { ContentFold } from "../geometry.js";
 import { BoundedMap, type Store } from "../store.js";
 import { SQliteStore } from "../store-sqlite.js";
 import { type MindConfig, resolveConfig } from "../config.js";
 import { type Canon, canonHash, textCanon, textEdgeTrim } from "../canon.js";
-import {
-  type CandidateSpan,
-  coverSequence,
-  lightestDerivation,
-} from "../derive/src/index.js";
-import { bytesEqual, concat2, concatBytes, indexOf } from "../bytes.js";
-import {
-  type ComputedResult,
-  type DerivationItem,
-  type DerivationStep,
-  GraphSearch,
-  type Leaf,
-  type Seg,
-  type Site,
-} from "./graph-search.js";
+import { bytesEqual, concat2 } from "../bytes.js";
+import { GraphSearch, type Leaf, type Site } from "./graph-search.js";
 import { Alu } from "../alu/src/index.js";
 import type { ComputedSpan, ExtensionHost } from "../extension.js";
 
@@ -147,16 +126,12 @@ interface ConversationData {
 
 // Mind module imports
 import type { AttentionRead, MindContext, Recognition } from "./types.js";
-import { changedNodes, liftAnswer, spliceAll } from "./types.js";
 import {
   canonResolve as canonResolveImpl,
-  foldTree,
   gistOf,
   inputBytes,
-  latin1Key,
   perceive as perceiveImpl,
   perceiveKey,
-  read,
   resolve as resolveImpl,
 } from "./primitives.js";
 import {
@@ -166,6 +141,7 @@ import {
   leadsSomewhere,
 } from "./traverse.js";
 import { invalidateJunctionCache } from "./junction.js";
+import type { WindowIndex } from "./evidence.js";
 import { follow } from "./match.js";
 import { recognise, segment } from "./recognition.js";
 import { meaningOf } from "./resonance.js";
@@ -358,6 +334,8 @@ export class Mind implements MindContext {
    *  first-edge behaviour) and the reverse projection uses it for
    *  reverse-recall disambiguation via `chooseAmong`. */
   _edgeGuide: Vec | null = null;
+  /** See {@link MindContext._edgeAsked}. */
+  _edgeAsked: { bytes: Uint8Array; index: WindowIndex } | null = null;
   /** Per-response memo of {@link chooseNext} picks — ensures every mechanism
    *  of a single response follows the SAME continuation for each ambiguous
    *  context node. */
@@ -672,6 +650,7 @@ export class Mind implements MindContext {
     this.canon = null;
     this.canonMemo = null;
     this._edgeGuide = null;
+    this._edgeAsked = null;
     this._edgeChoice.clear();
   }