@hviana/sema 0.9.2 → 0.9.3

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

@@ -162,6 +162,19 @@ export declare function chooseNext(ctx: MindContext, id: number, guide?: Vec | n
  *  ASCII without interior whitespace runs; where it is not, the raw bytes are
  *  read and a case-variant window simply does not match. */
 export declare function offsetCanon(ctx: MindContext, bytes: Uint8Array): Uint8Array;
+/** 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, and `director`
+ *  the answer of every `… director` one.  Choosing one of several such
+ *  continuations by popularity voices some other question's answer.  A
+ *  fragment with several continuations leads somewhere FOR THIS QUESTION only
+ *  when the question names one (the exact tier below).  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.  Read by
+ *  every mechanism that projects through a recognised site (cover's sites,
+ *  recall's argument binding). */
+export declare function answersOtherQuestions(ctx: MindContext, id: number, queryLen: number, siteLen: number): boolean;
 /** The continuations of `id` that `asked` NAMES (see {@link
  *  askedContinuations}) — for a caller holding material other than the whole
  *  question: the multi-hop walk asks with what of the question no product has
@@ -176,6 +189,45 @@ export declare function namedContinuations(ctx: MindContext, id: number, asked:
  *  evidence travels).  Empty when the question names no continuation of `id`
  *  or names others. */
 export declare function askedEvidence(ctx: MindContext, id: number, pick: number): Array<[number, number]>;
+/** The climb's points the question HOLDS under the response's equivalence —
+ *  stored forms whose canonical bytes occur in the question's, as sites.  The
+ *  recognition walk matches bytes and the fold's own boundaries, so a stored
+ *  `Man at Bath` inside `… of film Man At Bath work at?` is no site; the
+ *  consensus climb reaches it through the windows the two spellings share, and
+ *  containment under the canon (offset-preserving, so the span is the
+ *  question's own) decides.  Approximate proposes, exact decides.  Read off
+ *  the `chainReach(W)` most corroborated points; empty before the climb. */
+export declare function canonHeldPoints(ctx: MindContext, minLen: number): Array<{
+    start: number;
+    end: number;
+    payload: number;
+}>;
+/** A CO-INSTANCE of the question: a stored form that shares the question's
+ *  FRAME — the same opening and the same close, byte for byte under the
+ *  response's equivalence — around ONE different filler.  `Where was Peter
+ *  Jackson born?` against `Where was the director of film Beat Girl born?`
+ *  shares `Where was ` and ` born?`, and leaves `Peter Jackson` against `the
+ *  director of film Beat Girl`: another instance of the same question, never
+ *  this one.  It is the ordered limit of witnessing: a frame is not a bag of
+ *  windows (an order-free reading lets `Lyon is a city in France` pass for an
+ *  instance of `what if the capital of France were Lyon?`, which NAMES Lyon;
+ *  and a coincidental window inside a filler splits it).
+ *
+ *  The frame must reach one window, every window inside it must be held by
+ *  the material (so on the walk, a frame a product already said cannot name a
+ *  second step), and the form's filler must be a thing the corpus knows
+ *  (below) — a record that differs from the question only inside the frame
+ *  by a description (`converts sunlight into chemical energy` against
+ *  `works`) is the same question about the frame's own subject.  (Requiring
+ *  the two fillers to share no window as well was measured redundant with
+ *  this and cost two answers on the 2Wiki fixture.)  Returns the form's filler span in `raw` and the
+ *  question spans of the frame, or null.  One reading for every consumer: the
+ *  exact tier transfers the relation through it, and the readers that would
+ *  VOICE such a form's own continuation refuse it. */
+export declare function coInstanceFiller(ctx: MindContext, raw: Uint8Array, indexes: ReadonlyArray<WindowIndex>, question: Uint8Array): {
+    span: [number, number];
+    spans: Array<[number, number]>;
+} | null;
 /** The perceived gist of a candidate node, through the session gist cache.
  *  Re-gisting a candidate is a full river fold of its bytes — the measured
  *  recall bottleneck (a hub context offers up to √N continuations, EACH

package/dist/src/mind/traverse.js

@@ -6,7 +6,7 @@
 // The PROJECTIONS built on these walks (follow, conceptHop, reverseContext,
 // project) live in match.ts — the elementary match-and-project operation.
 import { cosine } from "../vec.js";
-import { gistOf, read } from "./primitives.js";
+import { gistOf, read, resolve } from "./primitives.js";
 import { canonicalWindows, chainReach, leafIdPrefix, leafIdRun, } from "./canonical.js";
 // Imported at the TOP, where every other import is.  They used to sit 800 lines
 // down under a note claiming the position mattered ("before trace module is
@@ -14,7 +14,7 @@ import { canonicalWindows, chainReach, leafIdPrefix, leafIdRun, } from "./canoni
 // file's line order never decides load order.  The note described an intention
 // the runtime does not honour; the imports move and the claim goes.
 import { decodeText } from "./rationale.js";
-import { latin1 } from "../bytes.js";
+import { concatBytes, indexOf, latin1 } from "../bytes.js";
 import { windowIndex, witness } from "./evidence.js";
 //
 // Budgeted on the same terms as the reach memo below (caches.md): these three
@@ -590,7 +590,9 @@ export function guidedNext(ctx, node) {
     // policy climbMemo and recogniseMemo follow (every mechanism must emit its
     // own steps; a memo hit would swallow the repeat's `disambiguate` step).
     // Consistency does not need the memo: chooseNext is a pure function of the
-    // (read-only) store and the guide, so recomputation yields the same pick.
+    // (read-only) store, the guide and the consensus climb's points once they
+    // exist (the memo is cleared when they arrive), so recomputation yields the
+    // same pick.
     if (!ctx.trace) {
         const memo = ctx._edgeChoice.get(node);
         if (memo !== undefined)
@@ -723,6 +725,28 @@ export function offsetCanon(ctx, bytes) {
     const c = ctx.canon(bytes);
     return c.length === bytes.length ? c : bytes;
 }
+/** 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, and `director`
+ *  the answer of every `… director` one.  Choosing one of several such
+ *  continuations by popularity voices some other question's answer.  A
+ *  fragment with several continuations leads somewhere FOR THIS QUESTION only
+ *  when the question names one (the exact tier below).  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.  Read by
+ *  every mechanism that projects through a recognised site (cover's sites,
+ *  recall's argument binding). */
+export function answersOtherQuestions(ctx, id, queryLen, siteLen) {
+    const asked = ctx._edgeAsked;
+    if (asked === null || queryLen - siteLen < ctx.space.maxGroup)
+        return false;
+    if (!(ctx.store.hasParents(id) || ctx.store.hasContainers(id)))
+        return false;
+    if (ctx.store.nextFirst(id, 2).length < 2)
+        return false;
+    return namedContinuations(ctx, id, asked) === null;
+}
 /** The continuations of `id` that `asked` NAMES (see {@link
  *  askedContinuations}) — for a caller holding material other than the whole
  *  question: the multi-hop walk asks with what of the question no product has
@@ -774,7 +798,11 @@ function askedEntry(ctx, id, nx, asked) {
     if (hit !== undefined && !ctx.trace)
         return hit;
     const entry = askedContinuationsImpl(ctx, id, nx, asked);
-    memo.set(id, entry);
+    // Nothing named before the climb has run is provisional: a co-instance
+    // read from its points may still name one.
+    if (entry.named !== null || ctx._edgeAsked?.points !== undefined) {
+        memo.set(id, entry);
+    }
     return entry;
 }
 /** One pick per node per question — every mechanism of a response asks the
@@ -818,7 +846,8 @@ function askedContinuationsImpl(ctx, id, nx, asked) {
     // reply established by hundreds of contexts would otherwise spend the whole
     // allowance alone.  The order changes what is READ, never what wins: scores
     // are compared afterwards in the continuations' own order.
-    let budget = Math.max(hubBound(ctx), chainReach(W));
+    const allowance = Math.max(hubBound(ctx), chainReach(W));
+    let budget = allowance;
     const order = nx
         .map((n, at) => ({ n, at, support: cachedPrevCount(ctx, n, cache) }))
         .filter((c) => c.support >= 2) // only `id` establishes the rest
@@ -847,6 +876,15 @@ function askedContinuationsImpl(ctx, id, nx, asked) {
                 continue;
             if (!indexes.some((ix) => ix.has(latin1(head))))
                 continue;
+            // AN ESTABLISHING CONTEXT IS A DEPOSITED ONE.  A span interned inside
+            // bigger forms inherits their edges (the fragment ` born?` leads to the
+            // fact of every `Where was … born?` question), so witnessing it names
+            // every one of them — measured on the 2Wiki fixture with one-hop
+            // questions deposited, ` born?` named nine strangers' birthplaces.  The
+            // structural predicate pivotInto already reads: a form with parents or
+            // containers was never a context on its own.
+            if (cachedHasParents(ctx, c, cache) || ctx.store.hasContainers(c))
+                continue;
             const form = read(ctx, c, formCap + 1);
             if (form.length < W || form.length > formCap)
                 continue;
@@ -875,8 +913,9 @@ function askedContinuationsImpl(ctx, id, nx, asked) {
         else if (score === bestBytes)
             best.push(n);
     }
-    if (best.length === 0)
-        return none;
+    if (best.length === 0) {
+        return byCoInstance(ctx, id, nx, asked, formCap, allowance);
+    }
     if (ctx.meter)
         ctx.meter.askedContinuations++;
     if (ctx.trace && witnessed !== null) {
@@ -890,6 +929,294 @@ function askedContinuationsImpl(ctx, id, nx, asked) {
             evidence.set(c.n, c.spans);
     return { named: best, spans: evidence };
 }
+/** The climb's points the question HOLDS under the response's equivalence —
+ *  stored forms whose canonical bytes occur in the question's, as sites.  The
+ *  recognition walk matches bytes and the fold's own boundaries, so a stored
+ *  `Man at Bath` inside `… of film Man At Bath work at?` is no site; the
+ *  consensus climb reaches it through the windows the two spellings share, and
+ *  containment under the canon (offset-preserving, so the span is the
+ *  question's own) decides.  Approximate proposes, exact decides.  Read off
+ *  the `chainReach(W)` most corroborated points; empty before the climb. */
+export function canonHeldPoints(ctx, minLen) {
+    const asked = ctx._edgeAsked;
+    if (asked === null || asked.points === undefined || ctx.canon === null) {
+        return [];
+    }
+    const W = ctx.space.maxGroup;
+    const out = [];
+    for (const id of asked.points.slice(0, chainReach(W))) {
+        const raw = read(ctx, id, asked.bytes.length);
+        if (raw.length < minLen || raw.length >= asked.bytes.length)
+            continue;
+        const form = ctx.canon(raw);
+        if (form.length !== raw.length)
+            continue;
+        const at = indexOf(asked.bytes, form, 0);
+        if (at >= 0)
+            out.push({ start: at, end: at + raw.length, payload: id });
+    }
+    return out;
+}
+/** A CO-INSTANCE of the question: a stored form that shares the question's
+ *  FRAME — the same opening and the same close, byte for byte under the
+ *  response's equivalence — around ONE different filler.  `Where was Peter
+ *  Jackson born?` against `Where was the director of film Beat Girl born?`
+ *  shares `Where was ` and ` born?`, and leaves `Peter Jackson` against `the
+ *  director of film Beat Girl`: another instance of the same question, never
+ *  this one.  It is the ordered limit of witnessing: a frame is not a bag of
+ *  windows (an order-free reading lets `Lyon is a city in France` pass for an
+ *  instance of `what if the capital of France were Lyon?`, which NAMES Lyon;
+ *  and a coincidental window inside a filler splits it).
+ *
+ *  The frame must reach one window, every window inside it must be held by
+ *  the material (so on the walk, a frame a product already said cannot name a
+ *  second step), and the form's filler must be a thing the corpus knows
+ *  (below) — a record that differs from the question only inside the frame
+ *  by a description (`converts sunlight into chemical energy` against
+ *  `works`) is the same question about the frame's own subject.  (Requiring
+ *  the two fillers to share no window as well was measured redundant with
+ *  this and cost two answers on the 2Wiki fixture.)  Returns the form's filler span in `raw` and the
+ *  question spans of the frame, or null.  One reading for every consumer: the
+ *  exact tier transfers the relation through it, and the readers that would
+ *  VOICE such a form's own continuation refuse it. */
+export function coInstanceFiller(ctx, raw, indexes, question) {
+    const W = ctx.space.maxGroup;
+    const form = offsetCanon(ctx, raw);
+    const max = Math.min(form.length, question.length);
+    let a = 0;
+    while (a < max && form[a] === question[a])
+        a++;
+    let b = 0;
+    while (b < max - a &&
+        form[form.length - 1 - b] === question[question.length - 1 - b])
+        b++;
+    const fe = form.length - b;
+    if (a + b < W || fe <= a || question.length - b <= a)
+        return null;
+    // Scaffolding is nobody's evidence, so a frame window that is a hub need not
+    // be unsaid (` is ` in `Which country Leo Mittler is from?`, which the first
+    // hop's `… is Arshad Khan.` already said).
+    const hub = hubWindows(ctx, raw);
+    const held = (o) => {
+        if (hub[o])
+            return true;
+        const key = latin1(form.subarray(o, o + W));
+        return indexes.some((ix) => ix.has(key));
+    };
+    for (let o = 0; o + W <= a; o++)
+        if (!held(o))
+            return null;
+    for (let o = fe; o + W <= form.length; o++)
+        if (!held(o))
+            return null;
+    // THE FILLER IS A THING THE CORPUS KNOWS: a stored context with
+    // continuations of its own, opening where the slot opens (up to one window
+    // earlier — a filler byte can sit in a window the question holds by chance:
+    // the `T` of `Taika` inside `as t` of `was the`).  `Peter Jackson` is one;
+    // `converts sunlight into chemical energy`, the slot of `Explain how
+    // photosynthesis …`, is a description of the frame's own subject, and the
+    // record answers the question.  The longest such context is the filler.
+    // One content-addressed probe per byte (the `keyEnds` reading); only a run
+    // some deposit spelled whole is looked up.
+    const ids = leafIdPrefix(ctx, raw);
+    let best = null;
+    const cache = getStructCache(ctx);
+    const reach = Math.min(ids.length, fe + W - 1);
+    for (let st = Math.max(0, a - W + 1); st <= a; st++) {
+        const run = [];
+        for (let en = st + 1; en <= reach; en++) {
+            run.push(ids[en - 1]);
+            if (en - st < W)
+                continue;
+            // The flat branch over the whole run exists only where some deposit
+            // spelled exactly these bytes — the cheap filter; the context it names
+            // is then looked up by content.
+            if (ctx.store.findBranch(run) === null)
+                continue;
+            if (best !== null && en - st <= best[1] - best[0])
+                continue;
+            const id = resolve(ctx, raw.subarray(st, en));
+            if (id !== null && cachedHasNext(ctx, id, cache))
+                best = [st, en];
+        }
+    }
+    if (best === null)
+        return null;
+    const spans = [];
+    if (a > 0)
+        spans.push([0, a]);
+    if (b > 0)
+        spans.push([question.length - b, question.length]);
+    return { span: best, spans };
+}
+/** THE RELATION, READ OFF ANOTHER INSTANCE — the exact tier's second reading,
+ *  asked only when no establishing context of `id`'s continuations is
+ *  witnessed outright.
+ *
+ *  `When was the director of film Jinpa born?` reaches `Pema Tseden`, whose
+ *  date-of-birth fact is established by `Pema Tseden date of birth`: the
+ *  question says `born`, the corpus says `date of birth`, and no window joins
+ *  them.  What can join them is ANOTHER INSTANCE of the same question.  A
+ *  stored context the question witnesses in every byte but ONE contiguous span
+ *  (`When was Peter Jackson born?`, residue `Peter Jackson`) is the question's
+ *  own frame around a different filler — a CO-INSTANCE.  Its continuation is
+ *  established by other contexts too (`Peter Jackson date of birth`), and one
+ *  that holds the filler is the relation spelled the way the corpus spells it.
+ *  Put this node where the filler was and look the result up by content:
+ *  `Pema Tseden date of birth` exists, and its continuation is named.
+ *
+ *  Nothing here is stored as a unit — not `born` ≈ `date of birth`, not the
+ *  frame — and nothing is approximate: the co-instance is witnessed, the
+ *  substitution is bytes, the target is an exact lookup that either exists
+ *  with this node's continuation or does not.  A frame the question shares only
+ *  partly (`Where was … born?` against `When was …`) leaves two residues and
+ *  is no co-instance.
+ *
+ *  BOUNDED: the frames are a property of the question and are read once per
+ *  question (`relationFrames`); co-instances are proposed by the edge-bearing
+ *  ancestors of its windows (`edgeAncestors`, the climb's own memoised reach;
+ *  a saturated window proposes nothing), rarest first, at most `allowance` of
+ *  them, each read once.  A node pays one exact lookup per frame. */
+function byCoInstance(ctx, id, nx, asked, formCap, allowance) {
+    const none = { named: null, spans: new Map() };
+    const frames = relationFrames(ctx, asked, allowance);
+    if (frames.length === 0)
+        return none;
+    const node = read(ctx, id, formCap);
+    const support = new Map();
+    const spans = new Map();
+    const via = new Map();
+    for (const fr of frames) {
+        const t = resolve(ctx, concatBytes([fr.prefix, node, fr.suffix]));
+        if (t === null || t === id)
+            continue;
+        for (const n of ctx.store.nextFirst(t, allowance)) {
+            if (!nx.includes(n))
+                continue;
+            let by = support.get(n);
+            if (by === undefined)
+                support.set(n, by = new Set());
+            for (const q of fr.by)
+                by.add(q);
+            if (!spans.has(n)) {
+                spans.set(n, fr.spans);
+                via.set(n, { q: fr.by[0], t });
+            }
+        }
+    }
+    let best = [];
+    let most = 0;
+    for (const n of nx) {
+        const k = support.get(n)?.size ?? 0;
+        if (k === 0)
+            continue;
+        if (k > most) {
+            best = [n];
+            most = k;
+        }
+        else if (k === most)
+            best.push(n);
+    }
+    if (best.length === 0)
+        return none;
+    if (ctx.meter)
+        ctx.meter.coInstanceNamings++;
+    const first = via.get(best[0]);
+    if (ctx.trace && first !== undefined) {
+        ctx.trace.step("askedByCoInstance", [
+            rItemShort(ctx, id, "node"),
+            rItemShort(ctx, first.q, "co-instance"),
+            rItemShort(ctx, first.t, "asked"),
+        ], best.map((n) => rItemShort(ctx, n, "named")), `${nx.length} continuations — no establishing context is witnessed; ` +
+            `${most} co-instance(s) of the question carry the relation to ` +
+            `${best.length === 1 ? "one" : best.length} of them`);
+    }
+    const evidence = new Map();
+    for (const n of best)
+        evidence.set(n, spans.get(n) ?? []);
+    return { named: best, spans: evidence };
+}
+/** The relation frames the question's co-instances carry — a property of the
+ *  QUESTION, not of the node asked about, so it is read once per question
+ *  (and once per walk material) and every node only pays the exact lookups.
+ *  A question the corpus holds verbatim is its own instance and reads none. */
+function relationFrames(ctx, asked, allowance) {
+    // A co-instance is the question's frame around ONE other filler, so it is
+    // read at most to twice the question's length.
+    const formCap = 2 * asked.bytes.length;
+    const hit = frameMemo.get(asked);
+    if (hit !== undefined && !ctx.trace)
+        return hit;
+    const whole = ctx._edgeAsked;
+    // THE PROPOSALS ARE THE CLIMB'S.  The consensus climb already scored the
+    // stored forms the question's regions reach — measured on the 2Wiki
+    // fixture with one-hop questions, the co-instances were among its points —
+    // so the tier reads co-instances from those and climbs nothing of its own.
+    // Before the climb has run there is nothing to read, and nothing is
+    // remembered: a later ask, after the climb, reads its points.
+    const points = whole?.points;
+    if (points === undefined)
+        return [];
+    const frames = [];
+    frameMemo.set(asked, frames);
+    if (whole !== null && resolve(ctx, whole.bytes) !== null)
+        return frames;
+    const W = ctx.space.maxGroup;
+    const cache = getStructCache(ctx);
+    const deposited = (c) => !cachedHasParents(ctx, c, cache) && !ctx.store.hasContainers(c);
+    const spelled = new Map();
+    // Most corroborated first (the climb's own ranking), at most
+    // `chainReach(W)` read — the exact tier's own floor.
+    const proposals = points.filter((c) => cachedHasNext(ctx, c, cache))
+        .slice(0, Math.min(allowance, chainReach(W)));
+    for (const q of proposals) {
+        if (!deposited(q))
+            continue;
+        const raw = read(ctx, q, formCap + 1);
+        if (raw.length > formCap)
+            continue;
+        if (ctx.meter)
+            ctx.meter.coInstanceReads++;
+        const co = coInstanceFiller(ctx, raw, [asked.index], asked.bytes);
+        if (co === null)
+            continue;
+        const [fs, fe] = co.span;
+        const filler = raw.subarray(fs, fe);
+        for (const f of ctx.store.nextFirst(q, W)) {
+            for (const c of ctx.store.prevFirst(f, allowance)) {
+                if (c === q || !deposited(c))
+                    continue;
+                const cb = read(ctx, c, formCap + 1);
+                const at = indexOf(cb, filler, 0);
+                if (at < 0)
+                    continue;
+                const prefix = cb.subarray(0, at);
+                const suffix = cb.subarray(at + filler.length);
+                if (prefix.length + suffix.length === 0)
+                    continue;
+                const key = latin1(prefix) + "\u0000" + latin1(suffix);
+                const known = spelled.get(key);
+                if (known === undefined) {
+                    spelled.set(key, { by: [q], prefix, suffix, spans: co.spans });
+                }
+                else if (!known.by.includes(q))
+                    known.by.push(q);
+            }
+        }
+    }
+    // ONE INSTANCE AGREES WITH NOTHING.  A relation is read off the corpus only
+    // where two co-instances spell it the same way — the agreement `reference`
+    // demands of a frame (MIN_INSTANCES), for the same reason: a single
+    // coincidental alignment is not evidence of what the frame means.  Measured
+    // on the trained store, long dialogue turns proposed hundreds of one-off
+    // "frames", each an exact lookup for every node asked about.
+    for (const fr of spelled.values())
+        if (fr.by.length >= 2)
+            frames.push(fr);
+    frames.sort((a, b) => b.by.length - a.by.length);
+    return frames;
+}
+const frameMemo = new WeakMap();
 /** The perceived gist of a candidate node, through the session gist cache.
  *  Re-gisting a candidate is a full river fold of its bytes — the measured
  *  recall bottleneck (a hub context offers up to √N continuations, EACH

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

@@ -374,10 +374,13 @@ export interface MindContext extends GraphSearchHost {
     /** The question currently being answered, as the material `chooseNext`'s
      *  exact tier witnesses a continuation's establishing contexts against —
      *  its bytes (canonical when the response's canon preserves offsets) and
-     *  their window index.  Set and cleared with `_edgeGuide`. */
+     *  their window index.  Set and cleared with `_edgeGuide`.  `points` are the
+     *  anchors the response's consensus climb scored, once it has climbed —
+     *  the proposals the exact tier reads co-instances from. */
     _edgeAsked: {
         bytes: Uint8Array;
         index: WindowIndex;
+        points?: readonly number[];
     } | null;
     _edgeChoice: Map<number, number>;
     _prevSeen: Set<number> | null;

package/docs/INDEX.md

@@ -21,23 +21,23 @@ proof in `test/` (pins that fail when the law is broken).
 
 ## Architecture laws (15)
 
-| Law | File                                        | Summary                                                                                                                                                                                                                                                            | Pins                                         |
-| --- | ------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | -------------------------------------------- |
-| 1   | `docs/architecture/determinism.md`          | No `Math.random`/`Date.now` in behaviour; seed-derived randomness; corpus-determined tie-breaks                                                                                                                                                                    | `test/20`                                    |
-| 2   | `docs/architecture/thresholds.md`           | Every decision cutoff derived in `geometry.ts` over D/W/N; no tunable knobs                                                                                                                                                                                        | `test/40`, `test/64`                         |
-| 3   | `docs/architecture/exact-vs-approximate.md` | Vector scores rank only; identity via content-addressed lookup; six graded ladders                                                                                                                                                                                 | `test/51`                                    |
-| 4   | `docs/architecture/cost-model.md`           | Single ladder `MICRO`/`STEP`/`CONCEPT`/`PASS`; weight `moves + PASS·unaccounted`; `STEP`-grade compare                                                                                                                                                             | `test/04`, `test/55`                         |
-| 5   | `docs/architecture/match-project.md`        | Shared `match.ts` family (`locate`/`alignGraded`/`frameSlots`/`project`); voicing gates belong to consumers                                                                                                                                                        | `test/24`, `test/76`                         |
-| 6   | `docs/architecture/mechanism-market.md`     | `PipelineMechanism` (`floor`/`run`/`parse`); admissible-floor pruning, investment discipline, run-ahead bounds                                                                                                                                                     | `test/01`, `test/04`, `test/153`             |
-| 7   | `docs/architecture/commonality.md`          | Three: global (`reachOf`+`dominates`), weave-local (`depth[]`), window rarity                                                                                                                                                                                      | `test/17`, `test/34`                         |
-| 8   | `docs/architecture/bounded-reads.md`        | No per-query read grows with N; `hubBound=√N` enforced at store via LIMIT/probe/prefix caps                                                                                                                                                                        | `test/77`, `test/90`                         |
-| 9   | `docs/architecture/store.md`                | `AbstractStore` owns dedup/indexing/batch; `store-sqlite.ts` is thin wrappers; canon index optional                                                                                                                                                                | `test/08`                                    |
-| 10  | `docs/architecture/fold-contract.md`        | `perceiveDeposit` and `perceive` agree; the read side names a branch as `intern` does; `contentLevels` is single boundary rule; no W/offset dependence                                                                                                             | `test/59`, `test/63`, `test/148`, `test/152` |
-| 11  | `docs/architecture/memoization.md`          | `Precomputed` is per-response lazy cache (promise-cached async); `beginResponse`/`endResponse` lifecycle                                                                                                                                                           | `test/42`                                    |
-| 12  | `docs/architecture/saturation.md`           | Every walk names a deciding saturation beside its cap; cap is safety net, not decision                                                                                                                                                                             | `test/27`, `test/16`                         |
-| 13  | `docs/architecture/meter.md`                | `meter.ts` is write-only work accounting; counts are exact, phases nest                                                                                                                                                                                            | `test/55`                                    |
-| 14  | `docs/architecture/closure.md`              | A derivation is closed when its structure accounts for the question's remainder; every transition asks that law, one engine walks the layers                                                                                                                       | `test/133`–`151`                             |
-| 15  | `docs/architecture/evidence.md`             | A stored form is identified when the material at hand (question ∪ the node a derivation stands on) witnesses every byte of it, order-free; the question NAMES a continuation through its establishing context; a step it did not name pays from what is still owed | `test/154`                                   |
+| Law | File                                        | Summary                                                                                                                                                                                                                                                                                                                                                  | Pins                                         |
+| --- | ------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------- |
+| 1   | `docs/architecture/determinism.md`          | No `Math.random`/`Date.now` in behaviour; seed-derived randomness; corpus-determined tie-breaks                                                                                                                                                                                                                                                          | `test/20`                                    |
+| 2   | `docs/architecture/thresholds.md`           | Every decision cutoff derived in `geometry.ts` over D/W/N; no tunable knobs                                                                                                                                                                                                                                                                              | `test/40`, `test/64`                         |
+| 3   | `docs/architecture/exact-vs-approximate.md` | Vector scores rank only; identity via content-addressed lookup; six graded ladders                                                                                                                                                                                                                                                                       | `test/51`                                    |
+| 4   | `docs/architecture/cost-model.md`           | Single ladder `MICRO`/`STEP`/`CONCEPT`/`PASS`; weight `moves + PASS·unaccounted`; `STEP`-grade compare                                                                                                                                                                                                                                                   | `test/04`, `test/55`                         |
+| 5   | `docs/architecture/match-project.md`        | Shared `match.ts` family (`locate`/`alignGraded`/`frameSlots`/`project`); voicing gates belong to consumers                                                                                                                                                                                                                                              | `test/24`, `test/76`                         |
+| 6   | `docs/architecture/mechanism-market.md`     | `PipelineMechanism` (`floor`/`run`/`parse`); admissible-floor pruning, investment discipline, run-ahead bounds                                                                                                                                                                                                                                           | `test/01`, `test/04`, `test/153`             |
+| 7   | `docs/architecture/commonality.md`          | Three: global (`reachOf`+`dominates`), weave-local (`depth[]`), window rarity                                                                                                                                                                                                                                                                            | `test/17`, `test/34`                         |
+| 8   | `docs/architecture/bounded-reads.md`        | No per-query read grows with N; `hubBound=√N` enforced at store via LIMIT/probe/prefix caps                                                                                                                                                                                                                                                              | `test/77`, `test/90`                         |
+| 9   | `docs/architecture/store.md`                | `AbstractStore` owns dedup/indexing/batch; `store-sqlite.ts` is thin wrappers; canon index optional                                                                                                                                                                                                                                                      | `test/08`                                    |
+| 10  | `docs/architecture/fold-contract.md`        | `perceiveDeposit` and `perceive` agree; the read side names a branch as `intern` does; `contentLevels` is single boundary rule; no W/offset dependence                                                                                                                                                                                                   | `test/59`, `test/63`, `test/148`, `test/152` |
+| 11  | `docs/architecture/memoization.md`          | `Precomputed` is per-response lazy cache (promise-cached async); `beginResponse`/`endResponse` lifecycle                                                                                                                                                                                                                                                 | `test/42`                                    |
+| 12  | `docs/architecture/saturation.md`           | Every walk names a deciding saturation beside its cap; cap is safety net, not decision                                                                                                                                                                                                                                                                   | `test/27`, `test/16`                         |
+| 13  | `docs/architecture/meter.md`                | `meter.ts` is write-only work accounting; counts are exact, phases nest                                                                                                                                                                                                                                                                                  | `test/55`                                    |
+| 14  | `docs/architecture/closure.md`              | A derivation is closed when its structure accounts for the question's remainder; every transition asks that law, one engine walks the layers                                                                                                                                                                                                             | `test/133`–`151`                             |
+| 15  | `docs/architecture/evidence.md`             | A stored form is identified when the material at hand (question ∪ the node a derivation stands on) witnesses every byte of it, order-free; the question NAMES a continuation through its establishing context, or through another instance of its frame (a co-instance, never voiced as the answer); a step it did not name pays from what is still owed | `test/154`, `test/155`                       |
 
 ## Mechanisms (8)
 

package/docs/INVARIANTS.md

@@ -16,4 +16,4 @@
 | 12 | Meter contracts                      | `src/meter.ts:Meter,PhaseCost,time` `src/mind/pipeline-mechanism.ts:Precomputed.shared`                                                                                | `test/55`                      | `meter.md`                |
 | 13 | Saturation                           | `traverse.ts:edgeAncestors,types.ts:SaturationReason` `src/mind/junction.ts:junctionContainersFrom` `src/mind/resonance.ts:pivotInto`                                  | `test/27` `test/16`            | `saturation.md`           |
 | 14 | Closure                              | `src/mind/derivation.ts:admissible,advance,closeOver`                                                                                                                  | `test/133`–`151`               | `closure.md`              |
-| 15 | Witnessed evidence                   | `src/mind/evidence.ts:witness,windowIndex` `src/mind/traverse.ts:chooseNext,askedEvidence,namedContinuations,scaffoldExtents`                                          | `test/154`                     | `evidence.md`             |
+| 15 | Witnessed evidence                   | `src/mind/evidence.ts:witness,windowIndex` `src/mind/traverse.ts:chooseNext,askedEvidence,namedContinuations,answersOtherQuestions,coInstanceFiller,scaffoldExtents`   | `test/154`, `test/155`         | `evidence.md`             |