@hviana/sema 0.8.3 → 0.8.5

package/test/133-the-decision-point-renders-the-state.test.mjs

@@ -0,0 +1,204 @@
+// 133-the-decision-point-renders-the-state.test.mjs — FAIL BEFORE, recorded first.
+//
+// THE CLAIM the extraction has to earn, from the acceptance file written and
+// MEASURED BEFORE any line of the law existed (3 failures on a clean tree, each
+// for its own reason).  The two assertions that are now green live here; the
+// third — "the coverage scan exists exactly once in src/mind" — stays out of the
+// tree until `reasoning.ts`'s brake is migrated onto the law, because until then
+// it would be a red pin rather than a proof.
+//
+//   133.1 the state the pipeline decides on is RENDERED where it is decided —
+//         remainder spans, their bytes, and the supplied fixed point — through
+//         the official surface (inspectRationale's post-grounding step).  It
+//         must fail today on the ASSERTION, not at import: the payload exists,
+//         it simply does not carry the state.
+//   133.2 the closure law is PRODUCER-FREE as an invariant: two states equal in
+//         every field the law reads, differing only in a provenance label, get
+//         identical verdicts for every continuation.  Fails today at import —
+//         the law has no home yet.
+//
+// Nor does any accept `answer === expected` as proof: the first reads the
+// official instrumentation and its agreement with the meter's own reading of the
+// same remainder; the second is an invariant over states; the third reads the
+// source.  The existing suites remain the GUARDS that the extractions change no
+// answer — measured, before and after each step: answers, transition sequences
+// and every meter counter identical.
+
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { readdir, readFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const here = dirname(fileURLToPath(import.meta.url));
+const { Mind, SQliteStore } = await import("../dist/src/index.js");
+
+const CHAIN = [
+  ["What is the capital of France", "The capital of France is Paris"],
+  ["Paris", "Paris is famous for the Eiffel Tower"],
+  ["the Eiffel Tower", "the Eiffel Tower is in Paris"],
+];
+const CARRIED = [
+  ["How do I compile hello.c?", "Run gcc hello.c"],
+  ["How do I compile server.c?", "Run gcc server.c"],
+  ["How do I compile parser.c?", "Run gcc parser.c"],
+];
+
+async function profile(facts, query) {
+  const store = new SQliteStore({ path: ":memory:" });
+  const mind = new Mind({ seed: 7, store, profile: true });
+  await mind.ingest(facts);
+  const steps = [];
+  await mind.respondText(query, (s) => steps.push(s));
+  const out = { steps, counters: mind.lastCost?.counters ?? {} };
+  await store.close();
+  return out;
+}
+
+test("133.1 the decision point renders the state it decides on", async () => {
+  const { steps, counters } = await profile(
+    CHAIN,
+    "What is the capital of France famous for",
+  );
+  const pg = steps.filter((s) => s.data && s.data.preConsumed !== undefined);
+  assert.ok(pg.length >= 1, "the post-grounding step must exist");
+  const d = pg[pg.length - 1].data;
+  assert.equal(
+    typeof d.remainderSpans,
+    "number",
+    "the state's remainder must be rendered where it is decided — it is " +
+      "today computed, used, and published only as an aggregate counter",
+  );
+  assert.equal(typeof d.remainderBytes, "number");
+  assert.equal(typeof d.fixed, "boolean");
+  assert.equal(
+    d.remainderSpans,
+    counters.postGroundingRemainderSpans,
+    "the rendered state must agree with the meter's own reading of the same " +
+      "remainder — one measure, rendered twice, never two measures",
+  );
+});
+
+test("133.2 the law reads no producer, as an invariant over states", async () => {
+  let law;
+  try {
+    law = await import("../dist/src/mind/derivation.js");
+  } catch {
+    assert.fail(
+      "the closure law has no home yet: `admissible`/`advance`/`closed` must " +
+        "live in one lowest-layer module so every tier can ask it",
+    );
+  }
+  const query = new TextEncoder().encode(
+    "What is the capital of France famous for",
+  );
+  const W = 4;
+  const product = new TextEncoder().encode("qqqqqqqqqqqq");
+  const open = {
+    product,
+    accounted: [],
+    remainder: law.remainderOf(query.length, [], W),
+    cost: 0,
+  };
+  const continuations = [
+    { product, contains: true, cost: 1 },
+    { product, contains: true, reaches: true, cost: 1 },
+    { product, contains: false, cost: 1 },
+  ];
+  for (const t of continuations) {
+    const a = law.admissible(open, t, query, W);
+    for (
+      const label of ["cast", "cover", "recall", "reference", "alu", "prefix"]
+    ) {
+      const b = law.admissible({ ...open, provenance: label }, t, query, W);
+      assert.deepEqual(
+        b,
+        a,
+        `the verdict changed when the state was labelled "${label}" — the law ` +
+          `must be a function of the state and the continuation alone`,
+      );
+    }
+  }
+});
+
+test("133.3 the law has one home and one definition", async () => {
+  const mind = join(here, "..", "src", "mind");
+  const files = await readdir(mind);
+  assert.ok(
+    files.includes("derivation.ts"),
+    `the law's module must exist in the lowest mind layer; src/mind holds ${files.length} file(s)`,
+  );
+  const src = await readFile(join(mind, "derivation.ts"), "utf8");
+  const imports = [...src.matchAll(/from\s+"([^"]+)"/g)].map((m) => m[1]);
+  assert.deepEqual(
+    imports,
+    ["../bytes.js"],
+    `the law may import byte helpers only — it imported ${
+      JSON.stringify(imports)
+    }`,
+  );
+  let scans = 0;
+  for (const f of files) {
+    if (!f.endsWith(".ts")) continue;
+    const text = await readFile(join(mind, f), "utf8");
+    scans += (text.match(/i \+ W <= b/g) ?? []).length;
+  }
+  assert.equal(
+    scans,
+    1,
+    `the coverage scan (the law's own measure) must exist exactly once in ` +
+      `src/mind — found ${scans}`,
+  );
+});
+
+test("133.4 the law costs nothing the meter can see", async () => {
+  // THE ZERO-COST CLAIM, on one tree and through the official instrumentation.
+  // The formal A/B (ten diverse fixtures against the pre-extraction tree,
+  // comparing every answer, every move and all 480 counter values) is recorded
+  // in the commit that extracted the law; what lives here is the invariant that
+  // makes it reproducible: asking the law moves NO counter, because the law has
+  // nothing to read them through.
+  const law = await import("../dist/src/mind/derivation.js");
+  const store = new SQliteStore({ path: ":memory:" });
+  const mind = new Mind({ seed: 7, store, profile: true });
+  await mind.ingest(CHAIN);
+  await mind.respondText("What is the capital of France famous for");
+  const before = JSON.stringify(mind.lastCost?.counters ?? {});
+  const query = new TextEncoder().encode(
+    "What is the capital of France famous for",
+  );
+  const W = mind.space.maxGroup;
+  const state = {
+    product: new TextEncoder().encode("qqqqqqqqqqqq"),
+    accounted: [],
+    remainder: law.remainderOf(query.length, [[0, 5]], W),
+    cost: 0,
+  };
+  const t = { product: query.subarray(0, 3 * W), contains: true, cost: 1 };
+  for (let i = 0; i < 200; i++) {
+    const w = law.admissible(state, t, query, W);
+    if (w !== null) law.advance(state, t, w);
+    law.closed(state);
+    law.carries(state.remainder, t.product, query, W);
+    law.restates(query, state.product, 0, { proper: true });
+    law.insideAnsweredTurn([[0, 5]], { at: 0 }, 1, 2);
+    law.unexplainedSpans(query.length, [[0, 5]]);
+  }
+  assert.equal(
+    JSON.stringify(mind.lastCost?.counters ?? {}),
+    before,
+    "the law moved a meter counter — it must perform no work the instrumentation " +
+      "can see, which is what makes the extraction free",
+  );
+  // AND IT TAKES NO CONTEXT.  The arity is the structural statement: there is no
+  // parameter through which a store, a mind or a producer could be consulted.
+  assert.equal(
+    law.admissible.length,
+    4,
+    "admissible(state, continuation, query, W)",
+  );
+  assert.equal(law.advance.length, 3, "advance(state, continuation, witness)");
+  assert.equal(law.closed.length, 1, "closed(state)");
+  assert.equal(law.carries.length, 4, "carries(remainder, product, query, W)");
+  await store.close();
+});

package/test/134-the-law-explains-the-engines-own-refusal.test.mjs

@@ -0,0 +1,237 @@
+// 134-the-law-explains-the-engines-own-refusal.test.mjs — the law, coupled to the
+// engine's own observed behaviour rather than to itself.
+//
+// WHAT THIS PINS, and why it is not a restatement of test/133:
+//
+//   133 says the state is rendered where it is decided, that the law reads no
+//   producer, and that it has one home.  This file says the LAW'S OWN MEASURE
+//   EXPLAINS WHAT THE ENGINE DID: on a real fixture the reasoner takes one step
+//   and refuses the next, and the two products are in the corpus, so the law's
+//   `carries` can be evaluated on them and must agree with the trace — the
+//   admitted product carries a quantum of the remainder, the refused one carries
+//   none.  A test that only checked the law against itself would prove nothing
+//   about the engine; this one couples the two through the OFFICIAL
+//   instrumentation (`inspectRationale` for the products and the refusal, the
+//   meter for the remainder's own counts).
+//
+// It also pins the two invariants a reader of the extraction relies on: the law
+// is TOTAL over states x continuations and every clause holds, and `advance` is
+// the transition it says it is — including that the remainder TRAVELS UNCHANGED,
+// the reading that was implemented and refuted (draining it let test/110's chain
+// drift one hop past its satisfying answer).
+
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const here = dirname(fileURLToPath(import.meta.url));
+const law = await import("../dist/src/mind/derivation.js");
+const { Mind, SQliteStore } = await import("../dist/src/index.js");
+
+const enc = (s) => new TextEncoder().encode(s);
+
+/** The chain of test/110 and of the report's §16 example 3. */
+const LINKS = [
+  ["What is the capital of France", "The capital of France is Paris"],
+  ["Paris", "Paris is famous for the Eiffel Tower"],
+  ["the Eiffel Tower", "the Eiffel Tower is in Paris"],
+];
+const QUERY = "What is the capital of France famous for";
+
+async function run() {
+  const store = new SQliteStore({ path: ":memory:" });
+  const mind = new Mind({ seed: 7, store, profile: true });
+  await mind.ingest(LINKS);
+  const steps = [];
+  const answer = String(await mind.respondText(QUERY, (s) => steps.push(s)))
+    .trim();
+  const out = {
+    mind,
+    store,
+    steps,
+    answer,
+    counters: mind.lastCost?.counters ?? {},
+  };
+  return out;
+}
+
+test("134.1 the law is total, and every clause holds over the matrix", async () => {
+  const query = enc(QUERY);
+  const W = 4;
+  const none = enc("qqqqqqqqqqqqqqqq");
+  const owed = law.remainderOf(query.length, [], W);
+  assert.ok(
+    owed.length > 0,
+    "the fixture must owe material, else this pins nothing",
+  );
+  const states = {
+    open: { product: query, accounted: [], remainder: owed, cost: 0 },
+    closed: {
+      product: none,
+      accounted: [[0, query.length]],
+      remainder: [],
+      cost: 3,
+    },
+    fixed: {
+      product: query,
+      accounted: [],
+      remainder: owed,
+      cost: 0,
+      fixed: true,
+    },
+  };
+  const conts = {
+    carries: { product: query.subarray(0, 3 * W), contains: true, cost: 1 },
+    moves: { product: none, contains: true, reaches: true, cost: 1 },
+    plain: { product: none, contains: true, cost: 1 },
+    alien: { product: none, contains: false, cost: 1 },
+  };
+  for (const sn of Object.keys(states)) {
+    for (const cn of Object.keys(conts)) {
+      const v = law.admissible(states[sn], conts[cn], query, W);
+      assert.ok(
+        v === null || Array.isArray(v),
+        `${sn} x ${cn} produced ${String(v)}, neither a witness nor a refusal`,
+      );
+    }
+  }
+  for (const cn of Object.keys(conts)) {
+    assert.equal(
+      law.admissible(states.fixed, conts[cn], query, W),
+      null,
+      `a supplied fixed point stops every continuation (${cn})`,
+    );
+  }
+  for (const sn of Object.keys(states)) {
+    assert.equal(
+      law.admissible(states[sn], conts.alien, query, W),
+      null,
+      `identity comes before progress: an alien structure (state ${sn})`,
+    );
+  }
+  for (const cn of ["carries", "moves", "plain"]) {
+    assert.notEqual(
+      law.admissible(states.closed, conts[cn], query, W),
+      null,
+      `a closed derivation admits every contained continuation (${cn})`,
+    );
+  }
+  assert.equal(law.closed(states.closed), true);
+  assert.equal(law.closed(states.open), false);
+  // progress is EITHER the material carried OR the structure moved to
+  assert.notEqual(law.admissible(states.open, conts.carries, query, W), null);
+  assert.notEqual(law.admissible(states.open, conts.moves, query, W), null);
+  assert.equal(
+    law.admissible(states.open, conts.plain, query, W),
+    null,
+    "a step that neither carries the remainder nor moves is refused",
+  );
+});
+
+test("134.2 advance is the transition it says it is", async () => {
+  const query = enc(QUERY);
+  const W = 4;
+  const before = {
+    product: query,
+    accounted: [],
+    remainder: law.remainderOf(query.length, [], W),
+    cost: 2,
+    used: new Set([1, 2]),
+  };
+  const t = { product: query.subarray(0, 3 * W), contains: true, cost: 1 };
+  const witness = law.admissible(before, t, query, W);
+  assert.ok(witness !== null);
+  const after = law.advance(before, t, witness);
+  assert.equal(after.product, t.product, "the product moves");
+  assert.equal(after.cost, before.cost + t.cost, "the cost accumulates");
+  assert.deepEqual(
+    after.remainder,
+    before.remainder,
+    "CARRIES ENGAGES: a step that carries question material consumes none of it",
+  );
+  assert.equal(
+    after.fixed,
+    undefined,
+    "the result is no longer a supplied fixed point",
+  );
+  assert.equal(after.used, before.used, "the declaration travels");
+  assert.deepEqual(
+    after.accounted,
+    [...before.accounted, ...witness.map((w) => w.span)],
+    "the accounting accumulates what the step accounted for",
+  );
+  // A DECLARED MOVE CONSUMES WHAT IT CARRIES, and only that (test/138): the same
+  // product, offered this time by a step that moves and accounts for the span it
+  // holds.  This is the one thing the remainder responds to.
+  const movedT = {
+    product: t.product,
+    contains: true,
+    reaches: true,
+    explains: [[0, 3 * W]],
+    cost: 1,
+  };
+  const movedWitness = law.admissible(before, movedT, query, W);
+  assert.ok(movedWitness !== null);
+  const drained = law.advance(before, movedT, movedWitness);
+  assert.notDeepEqual(
+    drained.remainder,
+    before.remainder,
+    "a declared move consumes the question material it carries",
+  );
+  // and the state it came from is untouched (the law is pure)
+  assert.deepEqual(before.accounted, []);
+  assert.equal(before.product, query);
+});
+
+test("134.3 the engine's own refusal is the law's refusal", async () => {
+  const { mind, store, steps, answer, counters } = await run();
+  const W = mind.space.maxGroup;
+  const query = enc(QUERY);
+
+  // THE TRACE'S OWN PRODUCTS: what the walk produced and what it declined.
+  const pivots = steps.filter((s) => s.mechanism.at(-1) === "pivotStep");
+  const refusals = steps.filter((s) => s.mechanism.at(-1) === "pivotRefused");
+  assert.equal(
+    pivots.length,
+    1,
+    `the fixture takes exactly one extension step (got ${pivots.length}; answer "${answer}")`,
+  );
+  assert.equal(refusals.length, 1, "and declines the next one");
+  assert.equal(
+    counters.pivotSteps,
+    pivots.length,
+    "the meter agrees with the trace",
+  );
+  const admitted = pivots[0].outputs[0].bytes;
+  assert.ok(
+    admitted && admitted.length > 0,
+    "the admitted step reports its product",
+  );
+
+  // THE REMAINDER, from the meter's own counts and the fixture's structure: the
+  // grounding accounts for "What is the capital of France" and owes the rest.
+  assert.equal(counters.postGroundingRemainderSpans, 1);
+  const owedSpan = [
+    QUERY.length - counters.postGroundingRemainderBytes,
+    QUERY.length,
+  ];
+  const remainder = [owedSpan];
+
+  // THE LAW ON THE ENGINE'S OWN TWO PRODUCTS.
+  assert.notEqual(
+    law.carries(remainder, admitted, query, W),
+    null,
+    "the step the engine TOOK is one the law admits: its product carries a " +
+      "quantum of what the grounding left unaccounted",
+  );
+  // The step it declined is the corpus's own next link — the drift test/110 pins.
+  const drift = enc(LINKS[2][1]);
+  assert.equal(
+    law.carries(remainder, drift, query, W),
+    null,
+    "the step the engine DECLINED carries none of that material — which is " +
+      "exactly the law's refusal the trace reports",
+  );
+  await store.close();
+});