@hviana/sema 0.4.1 → 0.4.3

package/dist/src/mind/pipeline.js

@@ -46,7 +46,7 @@ async function collectComputed(ctx, mechanisms, query) {
 // invests in its own precomputation.  CAST's and confluence's floors (2*STEP,
 // 3*STEP) then fail `worthRunning` and are skipped by the SAME admissible-
 // floor pruning every mechanism is already subject to — not by asking
-// "is this an extension?".  Grade TIES keep the earlier candidate, so this
+// "is this an extension?". Grade TIES keep the earlier candidate, so this
 // order is also the tie-break priority: cover, cast, confluence, extraction,
 // recall.
 export const defaultMechanisms = [

package/dist/src/mind/reasoning.js

@@ -65,17 +65,25 @@ export async function reason(ctx, query, answer, preConsumed, pre) {
     // grounding can pre-consume one node per recognised site, O(query length));
     // nodes past the cap are still consumed directly, they just skip the
     // synonym expansion.
-    let haloSweeps = 0;
-    for (const id of preConsumed) {
-        consumeNode(id);
-        if (haloSweeps >= ctx.cfg.haloQueryK)
-            continue;
-        const h = ctx.store.halo(id);
-        if (!h)
-            continue;
-        haloSweeps++;
-        for (const sib of await haloSiblings(ctx, id, h))
-            consumeNode(sib.id);
+    const preconsume = async () => {
+        let haloSweeps = 0;
+        for (const id of preConsumed) {
+            consumeNode(id);
+            if (haloSweeps >= ctx.cfg.haloQueryK)
+                continue;
+            const h = ctx.store.halo(id);
+            if (!h)
+                continue;
+            haloSweeps++;
+            for (const sib of await haloSiblings(ctx, id, h))
+                consumeNode(sib.id);
+        }
+    };
+    if (ctx.meter) {
+        await ctx.meter.time("reason.preconsumeHalos", preconsume);
+    }
+    else {
+        await preconsume();
     }
     let cur = answer;
     const qv = pre.guide; // the response-wide guide IS the query's gist

package/dist/src/mind/recognition.js

@@ -333,6 +333,47 @@ function recogniseImpl(ctx, bytes) {
             return null;
         return singleLeaf[p];
     };
+    // ── exact query-edge forms beyond the canonical chain reach ─────────
+    //
+    // At corpus scale off-boundary atom chains are deliberately suppressed,
+    // but a whole trained form can be longer than chainReach(W) and sit at a
+    // query edge without being a subtree of the query's larger root. Appending
+    // another topic demonstrates the failure: the exact 30-byte trained
+    // question `What is the capital of France?` ends inside the larger query's
+    // [27,33) content segment, so neither the structural walk nor a W² chain
+    // can name it.
+    //
+    // Probe only prefix/suffix endpoints within one maximum segment of the
+    // query's own content cuts. The flat-branch lookup is byte-exact and runs
+    // before resolveSpan pays for a fold; approximate evidence never enters.
+    // This tier is needed only where atom chains are suppressed. Small stores
+    // retain their existing decomposition unchanged.
+    if (atomsAreHubs) {
+        const allLeafIds = singleLeaf.map((x) => x?.id ?? null);
+        if (allLeafIds.every((x) => x !== null)) {
+            const radius = ctx.space.seats.length;
+            const endpoints = new Set([0, bytes.length]);
+            for (const cut of startList) {
+                for (let p = Math.max(0, cut - radius); p <= Math.min(bytes.length, cut + radius); p++)
+                    endpoints.add(p);
+            }
+            const ordered = [...endpoints].sort((a, b) => a - b);
+            const probe = (start, end) => {
+                if (end - start < W || end - start <= chainReach(W))
+                    return;
+                const ids = allLeafIds.slice(start, end);
+                if (store.findBranch(ids) === null)
+                    return;
+                const id = resolveSpan(start, end);
+                if (id !== null)
+                    emit(start, end, id);
+            };
+            for (const end of ordered)
+                probe(0, end);
+            for (const start of ordered)
+                probe(start, bytes.length);
+        }
+    }
     const chunkEnd = new Uint32Array(bytes.length);
     const sorted = [...starts].sort((a, b) => a - b);
     for (let si = 0; si < sorted.length; si++) {

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

@@ -1,6 +1,6 @@
 import { Vec } from "../vec.js";
 import type { AncestorReach, MindContext } from "./types.js";
-/** The reach memo this response should use — see the note above.
+/** The reach memo this ask should use — see the note above.
  *
  *  A TRACED response always gets a fresh, empty one.  `AncestorReach`'s
  *  `visited`/`maxDepth`/`saturation` fields are populated only when a trace
@@ -11,6 +11,8 @@ import type { AncestorReach, MindContext } from "./types.js";
  *  Consistent with AGENTS §2.11: a traced response is a different machine —
  *  never benchmark with a trace attached. */
 export declare function sharedReachMemo(ctx: MindContext): Map<number, AncestorReach>;
+/** Invalidate every session-lifetime structural read after a write. */
+export declare function invalidateStructuralCaches(ctx: MindContext): void;
 /** Climb the structural DAG from a node to its edge-bearing ancestor contexts.
  *  Ascent stops at hub nodes (parents > √N) — their reach is non-discriminative.
  *  When the start node has no structural parents, climbs from containment parents

package/dist/src/mind/traverse.js

@@ -18,20 +18,16 @@ const structCaches = new WeakMap();
 // every mechanism that prices commonality" — was reached only by confluence.
 // The climb is by far the biggest consumer.
 //
-// Keyed off `ctx.climbMemo`'s OBJECT IDENTITY, exactly like the struct cache
-// above, which buys the right lifetime for free: a plain respond() has a
-// fresh climbMemo, so the memo is response-scoped; a conversation turn has
-// the conversation's persistent one, so it is conversation-scoped.  That
-// matters — the stable-prefix fold makes each turn's subtree independent of
-// what follows, so 59–70% of a later turn's climb regions are byte-identical
-// repeats of an earlier turn's (measured on a 4-turn session), and every one
-// of them used to re-climb from cold.
+// Keyed by the Mind's structural lifecycle identity: ordinary and
+// conversational asks share it, and every ingest invalidates it. A real
+// battery repeatedly reaches the same corpus scaffolding even when its
+// surface questions differ.
 //
 // Budgeted, not unbounded (AGENTS §2.12): past the cap the whole map is
 // dropped and re-derived, costing a cold climb and never a wrong answer.
 const REACH_MEMO_MAX = 100_000;
 const reachCaches = new WeakMap();
-/** The reach memo this response should use — see the note above.
+/** The reach memo this ask should use — see the note above.
  *
  *  A TRACED response always gets a fresh, empty one.  `AncestorReach`'s
  *  `visited`/`maxDepth`/`saturation` fields are populated only when a trace
@@ -44,9 +40,9 @@ const reachCaches = new WeakMap();
 export function sharedReachMemo(ctx) {
     if (ctx.trace !== null || ctx.climbMemo === null)
         return new Map();
-    let m = reachCaches.get(ctx.climbMemo);
+    let m = reachCaches.get(ctx._structMemoKey);
     if (m === undefined)
-        reachCaches.set(ctx.climbMemo, m = new Map());
+        reachCaches.set(ctx._structMemoKey, m = new Map());
     else if (m.size >= REACH_MEMO_MAX)
         m.clear();
     return m;
@@ -54,9 +50,9 @@ export function sharedReachMemo(ctx) {
 function getStructCache(ctx) {
     if (ctx.climbMemo === null)
         return null;
-    let c = structCaches.get(ctx.climbMemo);
+    let c = structCaches.get(ctx._structMemoKey);
     if (c === undefined) {
-        structCaches.set(ctx.climbMemo, c = {
+        structCaches.set(ctx._structMemoKey, c = {
             hasNext: new Map(),
             prevCount: new Map(),
             hasParents: new Map(),
@@ -64,6 +60,11 @@ function getStructCache(ctx) {
     }
     return c;
 }
+/** Invalidate every session-lifetime structural read after a write. */
+export function invalidateStructuralCaches(ctx) {
+    reachCaches.delete(ctx._structMemoKey);
+    structCaches.delete(ctx._structMemoKey);
+}
 /** Cached {@link Store.hasNext} — pure during one respond(). */
 function cachedHasNext(ctx, id, cache) {
     if (cache === null)

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

@@ -232,6 +232,9 @@ export interface MindContext extends GraphSearchHost {
      *  Null outside respond(); during respondTurn() the conversation's
      *  persistent map is swapped in. */
     climbMemo: Map<string, Map<string, AttentionRead>> | null;
+    /** Stable identity for session-lifetime, write-invalidated structural
+     *  caches. Query-level climb results remain on climbMemo. */
+    _structMemoKey: object;
     /** Memo of {@link recognise} — content-keyed (latin1) so recognised
      *  forms carry forward across conversation turns.  Bypassed while a
      *  trace is attached.  Null outside respond(). */
@@ -251,6 +254,13 @@ export interface MindContext extends GraphSearchHost {
         id: number;
         len: number;
     }> | null;
+    /** Completed assistant-turn byte spans in the current cumulative query.
+     *  Empty for ordinary respond(); response-scoped structural context for
+     *  mechanisms that must not re-derive already-produced replies. */
+    answeredSpans: ReadonlyArray<readonly [number, number]>;
+    /** Start offset of the user turn currently being answered. Zero for an
+     *  ordinary respond() and for the first turn of a conversation. */
+    currentTurnStart: number;
     _edgeGuide: Vec | null;
     _edgeChoice: Map<number, number>;
     _prevSeen: Set<number> | null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hviana/sema",
-  "version": "0.4.1",
+  "version": "0.4.3",
   "description": "Sema: a non-parametric, instance-based reasoning system.",
   "type": "module",
   "main": "dist/src/index.js",

package/src/ingest-cache.ts

@@ -42,6 +42,8 @@ import { bindSeat, companySignature, type Sema } from "./sema.js";
 import type { Input } from "./mind/index.js";
 import { BoundedMap } from "./store.js";
 import type { Vec } from "./vec.js";
+import { invalidateStructuralCaches } from "./mind/traverse.js";
+import { invalidateJunctionCache } from "./mind/junction.js";
 
 /** The interned result of perceiving + interning ONE input.
  *
@@ -122,6 +124,8 @@ export class CachedIngest {
     input: Input | (Input | [Input, Input])[],
     second?: Input,
   ): Promise<(Sema & { id: number }) | undefined> {
+    invalidateStructuralCaches(this.mind);
+    invalidateJunctionCache(this.mind);
     // One shape-reading for both ingest paths — see {@link dispatchIngest}.
     return dispatchIngest(
       input,

package/src/meter.ts

@@ -176,6 +176,11 @@ export class Meter {
   /** Nodes popped by those ascents, against their √N·W budget — the counter
    *  that shows whether the walks are deciding early or burning the budget. */
   junctionPops = 0;
+  /** Arbitrary byte spans whose distributional company was VSA-bundled from
+   *  existing episode halos. */
+  spanHalos = 0;
+  /** Canonical W-windows examined while composing those span halos. */
+  spanHaloWindows = 0;
 
   /** `lightestDerivation` searches started. */
   searches = 0;

package/src/mind/attention.ts

@@ -2275,6 +2275,16 @@ async function crossRegionVotes(
   // the same container (or a sub-container of it) twice.
   const consumed = new Set<number>();
   let probes = 0;
+  // Once atoms themselves are hubs (N > W²), the cross-region analysis gets
+  // one k·W walk allowance per evidence tier. Without a shared allowance,
+  // each of k candidate pairs spends the full corpus-derived budget and a
+  // cumulative dialogue multiplies bounded work into tens of seconds. Small
+  // corpora retain exhaustive exact traversal: below this same scale the
+  // budget would be smaller than the structures the tests deliberately build.
+  const marketScale = k * ctx.space.maxGroup;
+  const corpusScale = N > marketScale ** 3;
+  const exactBudget = corpusScale ? { n: k * ctx.space.maxGroup } : undefined;
+  const synonymBudget = corpusScale ? { n: k * ctx.space.maxGroup } : undefined;
 
   for (let a = 0; a < cand.length && probes < k; a++) {
     if (consumed.has(cand[a])) continue;
@@ -2284,6 +2294,12 @@ async function crossRegionVotes(
       const rb = regions[cand[b]];
       if (!strong.has(cand[a]) && !strong.has(cand[b])) continue;
       if (ra.end >= rb.start) continue; // overlap or adjacent — nothing between
+      // In a cumulative conversation, an old↔old interaction cannot explain
+      // the user turn currently being answered; it was already available
+      // before that turn existed. Keep old↔current pairs (the current turn may
+      // refer to a prior answer), but do not repeatedly spend the junction
+      // budget recomposing two regions wholly before the current boundary.
+      if (ctx.currentTurnStart > 0 && rb.end <= ctx.currentTurnStart) continue;
       // Candidates strictly BETWEEN ra and rb (cand is sorted by start, so
       // that is exactly cand[a+1 .. b-1]) that already cast their OWN vote —
       // genuine, individually-corroborated evidence about what fills the gap
@@ -2364,7 +2380,7 @@ async function crossRegionVotes(
           cap,
           seedsOf(cand[a]),
           seedsOf(cand[b]),
-          undefined,
+          exactBudget,
           true,
         );
       if (probe) {
@@ -2384,6 +2400,7 @@ async function crossRegionVotes(
           maxInterior,
           true,
           sides,
+          synonymBudget,
         );
         if (probe) {
           const singleAttempted = sides.leftSiblings.length > 0 ||