@hviana/sema 0.8.1 → 0.8.2

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

@@ -16,7 +16,7 @@ import { analogyStrength, follow, project, reverseContext, sharedFrameStrengthOf
 import { joinWithBridge } from "../resonance.js";
 import { restatesQuery } from "../reasoning.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 { unexplainedLabel, unexplainedSpans, } from "../rationale.js";
 import { rItem, rNode } from "../trace.js";
@@ -523,7 +523,23 @@ export async function counterfactualTransfer(ctx, query, pre) {
         const fwd = await follow(ctx, proj.anchor, qv);
         if (fwd !== null && indexOf(answer, fwd, 0) < 0 &&
             !restatesQuery(query, fwd)) {
-            answer = concat2(answer, fwd);
+            // THROUGH THE SHARED JOINER, not a bare concatenation.
+            //
+            // `joinWithBridge` is the composition step every out-of-search assembly
+            // shares (multi-topic fusion, CAST's substitution and comparison): it
+            // asks the corpus for a learnt connector between the pieces and, on a
+            // miss, joins them BARE **and says so** — the `bridgeMiss` step (see
+            // resonance.ts).  This site bypassed it, and that is the whole of the
+            // gluing the study measured: `"Steel is hard"` + `"wet"` came back as
+            // `"hardwet"`, `"eva director father"` + `"The father of…"` as
+            // `"fatherThe"` — compositions no rationale could show, because the one
+            // step that made them left no trace.
+            //
+            // Routing it through the shared joiner is the instrumentation fix that
+            // comes first: a bare join stays possible (the house rule is "joined
+            // bare, never silent") but it is now VISIBLE, and an attested connector
+            // is used when the corpus has one.
+            answer = await joinWithBridge(ctx, answer, fwd);
         }
         ctx.trace?.step("projectCounterfactual", [
             rItem(filler, "filler", subj.point.anchor),

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

@@ -83,6 +83,8 @@ export async function resolveConnectors(ctx, sites, query) {
     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);
@@ -122,6 +124,10 @@ export async function resolveConnectors(ctx, sites, query) {
             // 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);

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

@@ -1,5 +1,6 @@
 import { Vec } from "../vec.js";
 import { Sema, Space } from "../sema.js";
+import type { CorpusResult } from "./corpus.js";
 import { Alphabet } from "../alphabet.js";
 import { Grid } from "../geometry.js";
 import { BoundedMap, type Store } from "../store.js";
@@ -49,10 +50,40 @@ import type { AttentionRead, MindContext, Recognition } from "./types.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";
+/** A stored pair as TEXT — the text helper's view of {@link CorpusPair}. */
+export interface CorpusTextPair {
+    context: string;
+    continuation: string;
+    contextId: number;
+    continuationId: number;
+    matchedBytes: number;
+    contextTruncated: boolean;
+    continuationTruncated: boolean;
+}
+/** {@link CorpusResult} as text, plus the prose for why nothing matched.  The
+ *  byte layer reports a STATE; saying it in words belongs to the text layer. */
+export interface CorpusTextResult {
+    query: string;
+    pairs: CorpusTextPair[];
+    resolved: number;
+    reached: number;
+    totalContexts: number;
+    browsed: boolean;
+    note?: string;
+}
 export interface MindOptions {
     seed?: number;
     recallQueryK?: number;
     haloQueryK?: number;
+    /** Items one rationale step may itemise — see {@link MindConfig}. */
+    rationaleSampleK?: number;
+    /** Corpus-reading capacities and budgets — see {@link MindConfig}. */
+    corpusLimitMax?: number;
+    corpusClimbs?: number;
+    corpusContextsPerClimb?: number;
+    corpusSampleProbes?: number;
+    corpusPreviewBytes?: number;
+    corpusSampleFloorBytes?: number;
     normalizeEpsilon?: number;
     cosineEpsilon?: number;
     geometry?: Partial<import("../config.js").GeometryConfig>;
@@ -153,6 +184,10 @@ export declare class Mind implements MindContext {
      *  `traverse.ts`'s ONE definition (edge or halo, with its response-scoped
      *  cache).  The search holds a bare Store and cannot reach that cache itself,
      *  so it asks through this hook; a bare host keeps its raw-store fallback. */
+    /** The canonical identity for the search (see GraphSearchHost). */
+    canonResolve(bytes: Uint8Array): number | null;
+    /** Feed a search refusal into the rationale (see GraphSearchHost). */
+    reportSearch(name: string, parts: ReadonlyArray<Uint8Array>, note: string): void;
     leadsSomewhere(id: number): boolean;
     recogniseSpan(bytes: Uint8Array): {
         sites: ReadonlyArray<Site>;
@@ -167,6 +202,8 @@ export declare class Mind implements MindContext {
      *  with the most distributional evidence (highest `prevOf` count — the
      *  structural manifestation of its halo).  When evidence is equal the
      *  first-inserted edge wins. */
+    /** See {@link GraphSearchHost.contentCuts}. */
+    contentCuts(bytes: Uint8Array): readonly number[];
     chooseNext(node: number): number | undefined;
     constructor(opts?: MindOptions);
     constructor(cfg: MindConfig, store: Store, _fromStore: true);
@@ -249,6 +286,24 @@ export declare class Mind implements MindContext {
      *  as one form, provided the store's canon index is built
      *  ({@link buildCanonIndex}). */
     respondText(input: string, inspectRationale?: InspectRationale): Promise<string>;
+    /** Which stored notes does this query REACH?  BYTES in, BYTES out — this
+     *  method has no notion of text or encoding; the text case is
+     *  {@link searchCorpusText}, which is one caller of this.
+     *
+     *  Exact content addressing through the machinery an answer already uses
+     *  (see src/mind/corpus.ts): the query's recognised sites are the resolved
+     *  subtrees, the climb goes up from the biggest, and a result is a context
+     *  that carries a learnt continuation.  Nothing is written and nothing is
+     *  indexed. */
+    searchCorpus(queryBytes: Uint8Array, limit?: number): CorpusResult;
+    /** Browse real pairs.  Deterministic: `from` is the caller's own offset in
+     *  [0,1), so browsing twice with different offsets shows different notes
+     *  without a random draw. */
+    sampleCorpus(limit?: number, from?: number): CorpusResult;
+    /** The TEXT case of {@link searchCorpus}: encode, search, decode.  The search
+     *  itself exists once, in the byte layer above; only the rendering lives
+     *  here, with the rest of this class's text modality. */
+    searchCorpusText(query: string, limit?: number): CorpusTextResult;
     /** Begin a new conversation, optionally restoring from a previously-saved
      *  {@link ConversationState}.  The returned handle is required for
      *  {@link respondTurn} and {@link endConversation}.

package/dist/src/mind/mind.js

@@ -9,8 +9,9 @@
 // Architecture: 4 primitives × 2 patterns = all inference.
 // Implementation split across src/mind/*.ts — this file assembles the Mind class.
 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 { contentBoundaries, contentFoldIncremental, reachThreshold, } from "../geometry.js";
 import { BoundedMap } from "../store.js";
 import { SQliteStore } from "../store-sqlite.js";
 import { resolveConfig } from "../config.js";
@@ -19,7 +20,7 @@ import { bytesEqual, concat2 } from "../bytes.js";
 import { GraphSearch, } from "./graph-search.js";
 import { Alu } from "../alu/src/index.js";
 import { decodeText, Rationale, } from "./rationale.js";
-import { gistOf, inputBytes, perceive as perceiveImpl, perceiveKey, resolve as resolveImpl, } from "./primitives.js";
+import { canonResolve as canonResolveImpl, gistOf, inputBytes, perceive as perceiveImpl, perceiveKey, resolve as resolveImpl, } from "./primitives.js";
 import { chooseNext, edgeAncestors as edgeAncestorsFn, invalidateStructuralCaches, leadsSomewhere, } from "./traverse.js";
 import { invalidateJunctionCache } from "./junction.js";
 import { follow } from "./match.js";
@@ -33,6 +34,21 @@ import { rItem } from "./trace.js";
 // The work meter is exported from src/index.ts (via src/meter.ts) — the one
 // definition; the Mind only consumes it.
 import { Meter } from "../meter.js";
+/** What the text helper says when the byte layer reports a miss. */
+const CORPUS_NOTE = {
+    "nothing-resolved": "No trained note sits above the parts of that text the mind recognised. " +
+        "It addresses content exactly, so try wording closer to something it was " +
+        "actually given — or browse the examples instead.",
+    "no-continuations": "That text reaches stored nodes, but none of them carries a learnt " +
+        "continuation.",
+};
+/** UTF-8 of bytes for display: reuse {@link decodeText} (the mind's own text
+ *  conversion), then drop the replacement character a byte-boundary cut leaves
+ *  behind.  Much of a real corpus is non-Latin, so that trailing U+FFFD is the
+ *  common case, not an exotic one — and it is the ONLY thing added here. */
+function previewCorpusText(bytes) {
+    return decodeText(bytes).replace(/\uFFFD+$/, "").replace(/\s+/g, " ").trim();
+}
 // ═══════════════════════════════════════════════════════════════════════════
 // THE MIND
 // ═══════════════════════════════════════════════════════════════════════════
@@ -116,6 +132,14 @@ export class Mind {
      *  `traverse.ts`'s ONE definition (edge or halo, with its response-scoped
      *  cache).  The search holds a bare Store and cannot reach that cache itself,
      *  so it asks through this hook; a bare host keeps its raw-store fallback. */
+    /** The canonical identity for the search (see GraphSearchHost). */
+    canonResolve(bytes) {
+        return canonResolveImpl(this, bytes);
+    }
+    /** Feed a search refusal into the rationale (see GraphSearchHost). */
+    reportSearch(name, parts, note) {
+        this.trace?.step(name, parts.map((b) => rItem(b)), [], note);
+    }
     leadsSomewhere(id) {
         return leadsSomewhere(this, id);
     }
@@ -136,6 +160,10 @@ export class Mind {
      *  with the most distributional evidence (highest `prevOf` count — the
      *  structural manifestation of its halo).  When evidence is equal the
      *  first-inserted edge wins. */
+    /** See {@link GraphSearchHost.contentCuts}. */
+    contentCuts(bytes) {
+        return contentBoundaries(this.space, bytes);
+    }
     chooseNext(node) {
         return chooseNext(this, node, this._edgeGuide);
     }
@@ -411,6 +439,48 @@ export class Mind {
         const r = await this.respond(input, inspectRationale);
         return decodeText(r.bytes);
     }
+    // ── Reading the trained memory back ─────────────────────────────────────
+    /** Which stored notes does this query REACH?  BYTES in, BYTES out — this
+     *  method has no notion of text or encoding; the text case is
+     *  {@link searchCorpusText}, which is one caller of this.
+     *
+     *  Exact content addressing through the machinery an answer already uses
+     *  (see src/mind/corpus.ts): the query's recognised sites are the resolved
+     *  subtrees, the climb goes up from the biggest, and a result is a context
+     *  that carries a learnt continuation.  Nothing is written and nothing is
+     *  indexed. */
+    searchCorpus(queryBytes, limit) {
+        return searchCorpus(this, queryBytes, limit);
+    }
+    /** Browse real pairs.  Deterministic: `from` is the caller's own offset in
+     *  [0,1), so browsing twice with different offsets shows different notes
+     *  without a random draw. */
+    sampleCorpus(limit, from) {
+        return sampleCorpus(this, limit, from);
+    }
+    /** The TEXT case of {@link searchCorpus}: encode, search, decode.  The search
+     *  itself exists once, in the byte layer above; only the rendering lives
+     *  here, with the rest of this class's text modality. */
+    searchCorpusText(query, limit) {
+        const result = this.searchCorpus(new TextEncoder().encode(query), limit);
+        return {
+            query,
+            pairs: result.pairs.map((p) => ({
+                context: previewCorpusText(p.context),
+                continuation: previewCorpusText(p.continuation),
+                contextId: p.contextId,
+                continuationId: p.continuationId,
+                matchedBytes: p.matchedBytes,
+                contextTruncated: p.contextTruncated,
+                continuationTruncated: p.continuationTruncated,
+            })),
+            resolved: result.resolved,
+            reached: result.reached,
+            totalContexts: result.totalContexts,
+            browsed: result.browsed,
+            note: result.miss === "matched" ? undefined : CORPUS_NOTE[result.miss],
+        };
+    }
     // ── Conversation API ────────────────────────────────────────────────────
     /** Begin a new conversation, optionally restoring from a previously-saved
      *  {@link ConversationState}.  The returned handle is required for

package/dist/src/mind/pipeline.js

@@ -355,9 +355,32 @@ export async function think(ctx, query, mechs) {
     const voiced = (provenance === "cast" || provenance === "join")
         ? [...castUsed].flatMap((id) => ctx.store.nextFirst(id, hubBound(ctx)).map((n) => read(ctx, n)))
         : [];
+    // REPORTABLE, NOT SILENT.  A declared-complete grounding ends the derivation
+    // here, and that decision is part of the derivation's shape: the reader of a
+    // rationale must be able to see that the chain stopped because the mechanism
+    // claimed the query WAS the context, not because nothing followed.  The step
+    // carries the claim, not a re-description of the answer — the extension is
+    // skipped, so there is no output item to show.
+    if (decided.complete) {
+        ctx.trace?.step("completeGrounding", [rItem(answer, provenance)], [], "grounding declared complete — the query IS the context, so " +
+            "post-grounding extension is skipped");
+    }
+    // THE REASONER JUDGES ITS OWN EXTENSIONS BY THE PIPELINE'S REMAINDER, not by
+    // the ladder's `accounted` — and by the SAME reading the fuse gate below uses,
+    // with the same W floor.  `accounted` is a COST quantity (measured: a query
+    // fully explained by one computed span plus bridged connectors reports
+    // `accounted: []` while nothing is unexplained), and a remainder under one
+    // river-fold quantum is bridging punctuation, never a second topic — so it
+    // licenses no extension and blocks none.
+    const explained = [
+        ...decided.accounted,
+        ...pre.computed.map((u) => [u.i, u.j]),
+    ];
+    const uncovered = unexplainedSpans(query.length, explained)
+        .filter(([a, b]) => b - a >= ctx.space.maxGroup);
     const reasoned = decided.complete ? answer : meter
-        ? await meter.time("reason", () => reason(ctx, query, answer, preConsumed, pre, voiced))
-        : await reason(ctx, query, answer, preConsumed, pre, voiced);
+        ? await meter.time("reason", () => reason(ctx, query, answer, preConsumed, pre, voiced, uncovered))
+        : await reason(ctx, query, answer, preConsumed, pre, voiced, uncovered);
     // Fuse only when the query has a genuine REMAINDER no mechanism's
     // structural evidence touched at all.  `decided.accounted` alone
     // undercounts this: it is a COST-LADDER quantity (cover.ts prices its
@@ -374,10 +397,6 @@ export async function think(ctx, query, mechs) {
     // observed: a single space between two fully-computed arithmetic spans
     // ("2+2 3+3") registered as "unaccounted" and pulled in an unrelated
     // corpus fact, corrupting "4 6" into "4 63".
-    const explained = [
-        ...decided.accounted,
-        ...pre.computed.map((u) => [u.i, u.j]),
-    ];
     const remainder = unaccounted(explained);
     // Whether the winning candidate's entire recognised substance is
     // COMPUTED — every accounted span exactly a pre.computed span, nothing

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

@@ -20,7 +20,11 @@ export declare function restatesQuery(query: Uint8Array, bytes: Uint8Array): boo
  *  when it declared one — see the pivot's own containment rule.  `pre` is the
  *  response's shared pre-computation — the post-grounding stages read the
  *  same container the mechanisms did. */
-export declare function reason(ctx: MindContext, query: Uint8Array, answer: Uint8Array, preConsumed: ReadonlySet<number>, pre: Precomputed, voiced?: readonly Uint8Array[]): Promise<Uint8Array>;
+export declare function reason(ctx: MindContext, query: Uint8Array, answer: Uint8Array, preConsumed: ReadonlySet<number>, pre: Precomputed, voiced?: readonly Uint8Array[], 
+/** The query material the GROUNDING left uncovered — the cost ladder's own
+ *  `unaccounted` spans.  Only the reasoner's OWN extensions are judged
+ *  against it; a mechanism carrying its own `used` set owns its shape. */
+uncovered?: readonly (readonly [number, number])[]): Promise<Uint8Array>;
 /** Fuse independent points of attention into one answer (multi-topic).
  *  When the consensus climb finds more than one dominant point, each
  *  independent point grounds its own answer; they are bridged together

package/dist/src/mind/reasoning.js

@@ -30,7 +30,11 @@ export function restatesQuery(query, bytes) {
  *  when it declared one — see the pivot's own containment rule.  `pre` is the
  *  response's shared pre-computation — the post-grounding stages read the
  *  same container the mechanisms did. */
-export async function reason(ctx, query, answer, preConsumed, pre, voiced = []) {
+export async function reason(ctx, query, answer, preConsumed, pre, voiced = [], 
+/** The query material the GROUNDING left uncovered — the cost ladder's own
+ *  `unaccounted` spans.  Only the reasoner's OWN extensions are judged
+ *  against it; a mechanism carrying its own `used` set owns its shape. */
+uncovered = []) {
     // Echo guard: a query that is ITSELF a learnt continuation (some context's
     // answer) is being asked back at the system — hopping forward from it would
     // chain through the very fact that produced it and echo the conversation
@@ -178,6 +182,55 @@ export async function reason(ctx, query, answer, preConsumed, pre, voiced = [])
         consumeAll(pivot);
         if (fc === null || bytesEqual(fc, cur) || restatesQuery(query, fc))
             break;
+        // WHOSE EXTENSION IS THIS?
+        //
+        // `voiced` is what the mechanism WITHHELD (the pipeline sends the used
+        // anchors' CONTINUATIONS, not their bytes — see pipeline's own note), so a
+        // non-empty `voiced` means exactly what that note says: the grounding came
+        // from a mechanism that carries its own short `used` set (cast/join) and
+        // therefore owns the shape of its answer.  The further terms inside such a
+        // seat are legitimately followable — test/29 C3's `Mona Lisa` lives inside
+        // the voiced seat and leads on to a fact about neither analog.
+        //
+        // Every other grounding is ordinary, and an extension of it is the
+        // reasoner's own inference: it is taken only while question material the
+        // grounding left uncovered remains AND the step carries some of it, judged
+        // by the mind's own line between chance and evidence — one W-byte window,
+        // no word notion, no character class, no threshold.  Measured: the drift's
+        // second step (`the Eiffel Tower is in Paris` after `Paris is famous for
+        // the Eiffel Tower`) carries no window of `" famous for"` and is refused,
+        // while the first carries it.  Terminates by a real argument: the uncovered
+        // material is finite and each taken extension must carry some of it.
+        const producerOwnsShape = voiced.length > 0;
+        if (!producerOwnsShape && uncovered.length > 0) {
+            const W = ctx.space.maxGroup;
+            let progress = false;
+            for (const [a, b] of uncovered) {
+                for (let i = a; i + W <= b && !progress; i++) {
+                    if (indexOf(fc, query.subarray(i, i + W), 0) >= 0)
+                        progress = true;
+                }
+                if (progress)
+                    break;
+            }
+            if (!progress) {
+                // THE BRAKE, MADE VISIBLE.  The reasoner declines a step that carries
+                // none of the material the grounding left uncovered — the drift the
+                // extension tests pin.  A refusal that leaves no trace is the kind of
+                // silent cut AGENTS §6 forbids: the rationale is where a reader learns
+                // that an extension was declined for want of question material, and
+                // where the next person sees why the chain stopped here.  Measured with
+                // the check disabled, test/110 and test/116 fail — so this brake is the
+                // only thing keeping the extension honest until the pivot reports its
+                // own accounted spans and the ladder can judge it instead.
+                const left = uncovered.reduce((n, [a, b]) => n + (b - a), 0);
+                ctx.trace?.step("pivotRefused", [rItem(cur, "answer"), rItem(query, "query")], uncovered.map(([a, b]) => rItem(query.subarray(a, b), "uncovered")), `the step carries none of the question material the grounding left ` +
+                    `uncovered (${left} byte(s) in ${uncovered.length} span(s)) — refused`);
+                break;
+            }
+        }
+        if (ctx.meter)
+            ctx.meter.pivotSteps++;
         t ??= ctx.trace?.enter("reason", [rItem(startedFrom, "grounded")]);
         ctx.trace?.step("pivotStep", [rItem(cur, "answer"), rNode(ctx, pivot, "pivot")], [rItem(fc, "answer", resolve(ctx, fc) ?? undefined)], "pivot on the shared span this answer contains, then step forward across that fact");
         cur = fc;

package/dist/src/mind/traverse.js

@@ -664,7 +664,15 @@ export function chooseNext(ctx, id, guide) {
     // for the prevCount calls in the loop above, never for extra rItemShort
     // byte-reads.
     if (ctx.trace) {
-        const others = capped.filter((c) => c !== best);
+        // A BOUNDED SAMPLE, AND THE COUNT.  The step used to carry EVERY candidate
+        // it weighed — measured on the trained store, 1559 out-items in one step
+        // (hubBound's own size) and 1082 in another (the hub's degree).  The
+        // rationale's job is to explain the CHOICE, and the count is what says how
+        // wide the field was; the declared candidate budget (`recallQueryK`) is what
+        // bounds the sample, so no number is invented here.
+        const others = capped
+            .filter((c) => c !== best)
+            .slice(0, ctx.cfg.rationaleSampleK);
         ctx.trace.step("disambiguate", [rItemShort(ctx, best, "halo-evidence", bestSupport)], others.map((c) => rItemShort(ctx, c, "candidate", ctx.store.prevCount(c))), `${capped.length} continuations — distributional evidence selects ` +
             `the most corroborated (distinct contexts ${bestSupport}, ` +
             `poured mass ${bestMass})`);

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

@@ -35,12 +35,34 @@ export interface GraphSearchHost {
         starts: ReadonlySet<number>;
     };
     chooseNext?(node: number): number | undefined;
+    /** The boundary positions of `bytes` under the engine's ONE boundary rule
+     *  (geometry.ts's `contentBoundaries`), or undefined when the host has no
+     *  space to ask.  The join's key is an entity plus a prefix of the tail, and
+     *  the prefix that names a stored relation ENDS on one of these boundaries —
+     *  measured, 5 of 5 accepted keys over four join-firing queries, where the
+     *  byte-by-byte scan spent 153 probes for 14 boundaries.  Boundaries are
+     *  content-defined and STABLE under prefix extension, which is why a corpus
+     *  key's end is a boundary of the query's own fold of the same bytes. */
+    contentCuts?(bytes: Uint8Array): readonly number[];
     /** The admission predicate — `traverse.ts`'s `leadsSomewhere`, its ONE
      *  definition: does this node bear an edge or a halo?  Optional, so a bare
      *  host (a raw Store and nothing else) still works; when present, the search
      *  uses it rather than re-probing the store, which keeps the predicate
      *  single-defined AND memoised on the response-scoped struct cache. */
     leadsSomewhere?(id: number): boolean;
+    /** Report a SEARCH REFUSAL into the rationale — the channel AGENTS §6
+     *  requires: a callback threaded through a call chain must FEED the
+     *  rationale, the way `GraphSearch`'s `onDerivation` feeds `traceDerivation`,
+     *  never a channel of its own.  Optional, so a bare host stays silent rather
+     *  than crashing. */
+    reportSearch?(name: string, parts: ReadonlyArray<Uint8Array>, note: string): void;
+    /** The CANONICAL resolver ({@link canonResolve}), optional like
+     *  {@link leadsSomewhere}.  The store's keys were written through the
+     *  canonical fold, so a fact's `Gustaf Molander` and the deposited
+     *  `gustaf molander` are the SAME node (measured inside a response: the
+     *  canonical resolver maps the surface form to the deposited node while a raw
+     *  resolve returns null).  A bare host falls back to the plain probe. */
+    canonResolve?(bytes: Uint8Array): number | null;
 }
 export interface Recognition {
     /** Forms that can lead somewhere — they have an edge or a halo. */

package/docs/failures/tempting-but-wrong.md

@@ -1,6 +1,6 @@
-# Tempting but Wrong — 12 Traps
+# Tempting but Wrong — 13 Traps
 
-Twelve shortcuts that look plausible and break an invariant. Each states what
+Thirteen shortcuts that look plausible and break an invariant. Each states what
 not to do, why it fails, and what to do instead.
 
 ### 1. `score >= threshold` decides identity
@@ -141,3 +141,32 @@ not to do, why it fails, and what to do instead.
   `twoEndedSeat`); turns are API state in `mind/mind.ts`, not segmentation.
   Pinned by `test/59-fold-invariance.test.mjs` and
   `test/63-fold-invariants.test.mjs`.
+
+### 13. Capping a combinatorial explosion instead of budgeting it
+
+- **WRONG:** Answer a combinatorial explosion with a geometry-derived limit — a
+  cap on the pairs a sweep enumerates, the continuations a hop may offer, the
+  candidates a scan probes. A derived limit is the right cutoff for a DECISION;
+  used as the answer to explosion it is a short-circuit.
+- **WHY:** It stops the computation silently. Reach is lost, the capability that
+  depended on it goes with it, and no test fails, because the tests were written
+  against the capped behaviour. Capping and removing the cap are both wrong:
+  capping truncates, removing lets the cost run, and the two failure modes hide
+  each other.
+- **CORRECT:** BUDGET it. The work is charged in the one currency
+  (`MICRO`/`STEP`/`CONCEPT`/`PASS`; `weight = moves + PASS·unaccounted`, see
+  `docs/architecture/cost-model.md`), the charge is visible in the meter and the
+  rationale, and the SEARCH decides whether the work is worth paying — so
+  inference is never locked by a limit and nothing is truncated in silence.
+  Where the work is mechanical rather than evidential — enumeration, scans,
+  sweeps — the answer is an algorithm whose cost is structural in the bytes it
+  is given, not a smaller cap.
+- **THE IDEAL:** a universal **closure engine** — one law of closure, stated in
+  the quantities the machine already has (`leadsSomewhere`, the
+  exact-then-canonical identity, `accounted` bytes, the ladder, `hubBound`),
+  from which the reach of a gap, the offer of a hop, the depth of a join and the
+  scope of a substitution are CONSEQUENCES, not four separate decisions. Nothing
+  in this repository is that today.
+- **THE STANDARD A CHANGE MUST MEET:** state which consequence it is, and show
+  it following from the law. A change that cannot be stated that way is not
+  ready.

package/jsr.json

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

package/package.json

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

package/src/config.ts

@@ -116,6 +116,23 @@ export interface MindConfig {
   seed: number;
   recallQueryK: number;
   haloQueryK: number;
+  /** Corpus reading (see src/mind/corpus.ts): results per call, resolved
+   *  nodes climbed from, contexts requested per climb, probes used to stride
+   *  the id space when browsing, bytes of each side a preview keeps, and the
+   *  smallest deposited note browsing will show.  Capacities and budgets only —
+   *  the one material floor (a resolved node must account for W bytes) is
+   *  derived from the geometry, not declared here. */
+  corpusLimitMax: number;
+  corpusClimbs: number;
+  corpusContextsPerClimb: number;
+  corpusSampleProbes: number;
+  corpusPreviewBytes: number;
+  corpusSampleFloorBytes: number;
+  /** Items one rationale step may ITEMISE (the whole field is still counted in
+   *  the step's note).  A capacity of the rationale, not of recall: sharing
+   *  `recallQueryK` meant `new Mind({recallQueryK: 100000})` un-bounded the very
+   *  payload the bound exists for (found by an adversarial review). */
+  rationaleSampleK: number;
   normalizeEpsilon: number;
   cosineEpsilon: number;
 
@@ -131,6 +148,13 @@ export const DEFAULT_CONFIG: MindConfig = {
   seed: 42,
   recallQueryK: 12,
   haloQueryK: 12,
+  rationaleSampleK: 12,
+  corpusLimitMax: 24,
+  corpusClimbs: 24,
+  corpusContextsPerClimb: 6,
+  corpusSampleProbes: 6000,
+  corpusPreviewBytes: 220,
+  corpusSampleFloorBytes: 12,
   normalizeEpsilon: 1e-12,
   cosineEpsilon: 1e-12,
   alu: {
@@ -172,6 +196,17 @@ export function resolveConfig(opts: Partial<MindConfig> = {}): MindConfig {
     seed: opts.seed ?? DEFAULT_CONFIG.seed,
     recallQueryK: opts.recallQueryK ?? DEFAULT_CONFIG.recallQueryK,
     haloQueryK: opts.haloQueryK ?? DEFAULT_CONFIG.haloQueryK,
+    rationaleSampleK: opts.rationaleSampleK ?? DEFAULT_CONFIG.rationaleSampleK,
+    corpusLimitMax: opts.corpusLimitMax ?? DEFAULT_CONFIG.corpusLimitMax,
+    corpusClimbs: opts.corpusClimbs ?? DEFAULT_CONFIG.corpusClimbs,
+    corpusContextsPerClimb: opts.corpusContextsPerClimb ??
+      DEFAULT_CONFIG.corpusContextsPerClimb,
+    corpusSampleProbes: opts.corpusSampleProbes ??
+      DEFAULT_CONFIG.corpusSampleProbes,
+    corpusPreviewBytes: opts.corpusPreviewBytes ??
+      DEFAULT_CONFIG.corpusPreviewBytes,
+    corpusSampleFloorBytes: opts.corpusSampleFloorBytes ??
+      DEFAULT_CONFIG.corpusSampleFloorBytes,
     normalizeEpsilon: opts.normalizeEpsilon ?? DEFAULT_CONFIG.normalizeEpsilon,
     cosineEpsilon: opts.cosineEpsilon ?? DEFAULT_CONFIG.cosineEpsilon,
     alu: {

package/src/meter.ts

@@ -206,6 +206,53 @@ export class Meter {
   /** Candidates the decider weighed. */
   candidates = 0;
 
+  // ── Graph search: the fact join (DIRECTION) ─────────────────────────────
+  //
+  // The join's outcome was observable ONLY through the rationale, and the
+  // rationale PERTURBS the search (measured: appending text to a refusal note
+  // changed a traced answer).  These four counters are the untraced view — the
+  // same surface every other work counter uses, incremented where the decision
+  // is made, never behind a trace guard.
+  /** `deriveThrough` yielded — a fact was reached through the subject the query
+   *  never named. */
+  joinFired = 0;
+  /** Refused: no key names the entity and the tail together.  (A key that
+   *  resolves but leads nowhere is not "refused" — it is not the relation, so
+   *  the scan simply moves on; there is no counter for a case the loop cannot
+   *  reach.) */
+  joinNoKey = 0;
+  /** Refused: the fact contains no entity that leads anywhere. */
+  joinNoEntity = 0;
+
+  // ── Mind: the multi-hop pivot (EXTENSION) ───────────────────────────────
+  //
+  // `pivotStep` was observable only through the rationale, and the rationale
+  // perturbs the search (measured).  How far the reasoner hopped is a
+  // BEHAVIOUR, so it needs an untraced view: one counter, incremented where the
+  // step is emitted.
+  /** Times the reasoner pivoted on a span its answer contains and stepped
+   *  across that fact. */
+  pivotSteps = 0;
+
+  // ── Mind: the cover's connector assembly (LIMIT) ────────────────────────
+  //
+  // The cover's `run` is 91% of a hub query's time (`"Hello."`: 2.7 s of 3.0 s)
+  // and holds its ~270 MB peak, and none of it was countable: `searchPushes`
+  // and `candidates` do not see the connector assembly.  These two counters are
+  // the untraced view of it.
+  /** `bridge` calls the cover makes assembling connectors (pairwise + n-ary). */
+  coverBridges = 0;
+  /** Continuations a CHAIN hop offered the search.  Bounded by the question
+   *  (`ceil(queryLen / W)`) rather than by the corpus's fan-out — measured on a
+   *  hub of degree 1083, offering every continuation grew the chart to 3113 outs
+   *  and cost a 270 MB peak / 256 MB OOM for a two-word question. */
+  chainOffers = 0;
+  /** Σ byte-allowance the n-ary interior passes those bridges.  The allowance
+   *  is `middleBytes + (m + 1) * W` — every intermediate answer's bytes plus
+   *  one window of glue per joint — so it is the quantity that grows with a hub
+   *  query's answers, and the first thing to read when the peak moves. */
+  coverAllowanceBytes = 0;
+
   // ── Phases ──────────────────────────────────────────────────────────────
 
   private readonly _phases = new Map<string, PhaseCost>();