@hviana/sema 0.9.0 → 0.9.2

package/dist/src/mind/learning.js

@@ -5,7 +5,7 @@
 import { addInto, normalize, zeros } from "../vec.js";
 import { bindSeat, companySignature, isChunk } from "../sema.js";
 import { changedNodes } from "./types.js";
-import { inputBytes, 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/dist/src/mind/mechanisms/cover.d.ts

@@ -1,6 +1,22 @@
 import type { MindContext } from "../types.js";
-import type { Site } from "../graph-search.js";
+import type { ConceptLicence, ConnectorLicence, Site } from "../graph-search.js";
 import type { PipelineMechanism } from "../pipeline-mechanism.js";
-export declare function resolveConcepts(ctx: MindContext, sites: Site[]): Promise<Map<number, number>>;
-export declare function resolveConnectors(ctx: MindContext, sites: ReadonlyArray<Site>, query?: Uint8Array): Promise<Map<string, Uint8Array>>;
+/** 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 declare function offerConcepts(ctx: MindContext, sites: ReadonlyArray<Site>): CoverConcepts;
+/** 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 declare function offerConnectors(ctx: MindContext, sites: ReadonlyArray<Site>, query?: Uint8Array): CoverConnectors;
 export declare const coverMechanism: PipelineMechanism;

package/dist/src/mind/mechanisms/cover.js

@@ -9,38 +9,45 @@
 // near-zero-cost incumbent that prunes the other mechanisms through the
 // ordinary admissible-floor check, with no extension special-case anywhere.
 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 { rItem, rNode, traceDerivation } from "../trace.js";
-// ── Concept / connector pre-resolution ──────────────────────────────────────
-export async function resolveConcepts(ctx, sites) {
-    const target = new Map();
-    const visited = new Set();
+export function offerConcepts(ctx, sites) {
+    const offered = new Set();
     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();
+    return {
+        offered,
+        granted,
+        asked: new Set(),
+        async grant(nodes) {
+            const found = [];
+            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)");
+            }
+        },
+    };
 }
-export async function resolveConnectors(ctx, sites, query) {
-    const links = new Map();
+export function offerConnectors(ctx, sites, query) {
     const answerOf = (n) => 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
@@ -81,15 +88,7 @@ export async function resolveConnectors(ctx, sites, query) {
             return restates(query, bytes, 0);
         });
     });
-    const bridgePair = async (l, r) => {
-        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();
     for (let i = 0; i + 1 < ordered.length; i++) {
         if (ordered[i].end !== ordered[i + 1].start)
             continue;
@@ -97,8 +96,10 @@ export async function resolveConnectors(ctx, sites, query) {
         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);
             }
         }
     }
@@ -111,37 +112,61 @@ export async function resolveConnectors(ctx, sites, query) {
         seenN.add(node);
         orderedNodes.push({ node, bytes: read(ctx, node) });
     }
+    const nary = new Map();
     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",
-        })), "the bytes the graph splices between adjacent answers (asked of the gist space)");
-    }
-    return links;
+    const granted = new Map();
+    return {
+        offered: new Set([...pairwise, ...nary.keys()]),
+        granted,
+        asked: new Set(),
+        async grant(keys) {
+            const found = [];
+            for (const key of keys) {
+                if (granted.has(key))
+                    continue;
+                let link = 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",
+                })), "the bytes the graph splices between adjacent answers the search reached (asked of the gist space)");
+            }
+        },
+    };
 }
 // ── Pipeline mechanism ──────────────────────────────────────────────────────
 export const coverMechanism = {
@@ -154,7 +179,7 @@ export const coverMechanism = {
         const { rec, computed } = pre;
         // 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));
         if (computed.length > 0 && sites.length < rec.sites.length) {
@@ -166,11 +191,40 @@ export const coverMechanism = {
                 s.end,
             ])), "a computation always wins: recognised forms overlapping a computed span are dropped");
         }
+        // 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))
-            : await resolveConnectors(ctx, sites, query);
+            ? ctx.meter.timeSync("cover.offerConnectors", () => offerConnectors(ctx, sites, query))
+            : offerConnectors(ctx, sites, query);
         let splits = rec.splits;
         if (computed.length > 0) {
             splits = new Set(rec.splits);
@@ -180,13 +234,11 @@ export const coverMechanism = {
             }
         }
         const concepts = ctx.meter
-            ? await ctx.meter.time("cover.resolveConcepts", () => resolveConcepts(ctx, sites))
-            : await resolveConcepts(ctx, sites);
+            ? ctx.meter.timeSync("cover.offerConcepts", () => offerConcepts(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 !== undefined);
         // Convert ComputedSpan[] to ComputedResult[] for the graph search.
         const computedResults = computed.map((u) => ({
@@ -202,7 +254,27 @@ export const coverMechanism = {
             ])),
             ...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 = [];
+        let solved;
+        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
             ? []
@@ -235,8 +307,17 @@ export const coverMechanism = {
         // 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 = 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 [{
                 bytes: composed,

package/dist/src/mind/mechanisms/recall.js

@@ -7,7 +7,7 @@ import { cosine } from "../../vec.js";
 import { consensusFloor, dominates, identityBar, reachThreshold, significanceBar, } from "../../geometry.js";
 import { gistOf, read, resolve } from "../primitives.js";
 import { indexOf } from "../../bytes.js";
-import { allWindowsAreScaffolding, corpusN, hubBound } from "../traverse.js";
+import { allWindowsAreScaffolding, askedEvidence, corpusN, guidedFirst, hubBound, } from "../traverse.js";
 import { follow, project, reverseContext, voicesDisplacedFiller, } from "../match.js";
 import { CONCEPT, STEP } from "../graph-search.js";
 import { restates as lawRestates } from "../derivation.js";
@@ -32,7 +32,6 @@ export async function recallByResonance(ctx, query, pre) {
             ...(complete ? { complete } : {}),
         };
     };
-    const k = pre.k;
     const queryGist = pre.guide;
     // 0. Exact self-match — content-addressed, deterministic.
     const qId = pre.queryResolved;
@@ -103,7 +102,15 @@ export async function recallByResonance(ctx, query, pre) {
             // conversation reads as if it were the next thing to say.
             if (g !== null && g.length > 0 &&
                 !lawRestates(query, g, 0, { proper: true })) {
-                return ground(g, "argument binding — the query's sole edge-source constituent, continuation followed", [[arg.start, arg.end]], STEP);
+                // 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], ...named], STEP);
             }
         }
     }

package/dist/src/mind/mind.d.ts

@@ -47,6 +47,7 @@ export interface Conversation {
     readonly id: number;
 }
 import type { AttentionRead, MindContext, Recognition } from "./types.js";
+import type { WindowIndex } from "./evidence.js";
 export type { AnchorRejectionReason, ClimbConsensusData, ConsensusAnchorTrace, ConsensusReachTrace, ConsensusRegionTrace, CrossRegionTier, JunctionVoteTrace, RegionOutcome, } from "./attention.js";
 export type { AncestorReach, SaturationReason, SaturationStop, } from "./types.js";
 import { type CostReport, Meter } from "../meter.js";
@@ -165,6 +166,11 @@ export declare class Mind implements MindContext {
      *  first-edge behaviour) and the reverse projection uses it for
      *  reverse-recall disambiguation via `chooseAmong`. */
     _edgeGuide: Vec | null;
+    /** See {@link MindContext._edgeAsked}. */
+    _edgeAsked: {
+        bytes: Uint8Array;
+        index: WindowIndex;
+    } | null;
     /** Per-response memo of {@link chooseNext} picks — ensures every mechanism
      *  of a single response follows the SAME continuation for each ambiguous
      *  context node. */

package/dist/src/mind/mind.js

@@ -11,14 +11,14 @@
 import { makeKeyring, rng, setVecConfig } from "../vec.js";
 import { sampleCorpus, searchCorpus } from "./corpus.js";
 import { Alphabet } from "../alphabet.js";
-import { contentFoldIncremental, reachThreshold, } from "../geometry.js";
+import { contentFoldIncremental, reachThreshold } from "../geometry.js";
 import { keyEnds } from "./canonical.js";
 import { BoundedMap } from "../store.js";
 import { SQliteStore } from "../store-sqlite.js";
 import { resolveConfig } from "../config.js";
 import { canonHash, textCanon, textEdgeTrim } from "../canon.js";
 import { bytesEqual, concat2 } from "../bytes.js";
-import { GraphSearch, } from "./graph-search.js";
+import { GraphSearch } from "./graph-search.js";
 import { Alu } from "../alu/src/index.js";
 import { decodeText, Rationale, } from "./rationale.js";
 import { canonResolve as canonResolveImpl, gistOf, inputBytes, perceive as perceiveImpl, perceiveKey, resolve as resolveImpl, } from "./primitives.js";
@@ -104,6 +104,8 @@ export class Mind {
      *  first-edge behaviour) and the reverse projection uses it for
      *  reverse-recall disambiguation via `chooseAmong`. */
     _edgeGuide = null;
+    /** See {@link MindContext._edgeAsked}. */
+    _edgeAsked = null;
     /** Per-response memo of {@link chooseNext} picks — ensures every mechanism
      *  of a single response follows the SAME continuation for each ambiguous
      *  context node. */
@@ -334,6 +336,7 @@ export class Mind {
         this.canon = null;
         this.canonMemo = null;
         this._edgeGuide = null;
+        this._edgeAsked = null;
         this._edgeChoice.clear();
     }
     /** Shared response core — the one path from bytes to voiced answer.

package/dist/src/mind/pipeline.d.ts

@@ -1,6 +1,6 @@
 import type { MindContext } from "./types.js";
 import { type PipelineMechanism } from "./pipeline-mechanism.js";
-export { resolveConcepts, resolveConnectors } from "./mechanisms/cover.js";
+export { offerConcepts, offerConnectors } from "./mechanisms/cover.js";
 export { aluToMechanism } from "./mechanisms/alu.js";
 export declare const defaultMechanisms: PipelineMechanism[];
 export type Provenance = "cast" | "join" | "cover" | "extract" | "reference" | "recall" | "recall-echo" | "prefix";
@@ -60,6 +60,10 @@ export interface RegimePredictionData {
      *  CAST's floor) — the bar the incumbent must sit at or below for the
      *  consensus climb to be skipped. */
     climbFloorGrade: number;
+    /** The lowest grade reached by a mechanism run AHEAD of a dearer one (see
+     *  the grounding loop), when one ran and grounded: a bound below
+     *  `climbFloorGrade` makes the regime retrieval whatever the incumbent. */
+    boundGrade?: number;
 }
 /** Think: a single lightest-derivation exploration of the Sema graph.
  *