amalgm 0.1.245 → 0.1.246

package/runtime/scripts/amalgm-mcp/tests/entity.storm.test.js

@@ -0,0 +1,486 @@
+'use strict';
+
+/**
+ * SEEDED STORMS over the full detection alphabet — the conclusive
+ * detection gate. Random compositions of every ratified operation kind
+ * over every entity kind Detect witnesses — files (text and binary),
+ * folders, links, and repositories, contests and refusals included —
+ * judged by the COMPLETE oracle at every quiet point: model vs
+ * disk referee, every field of every six-field record, detector slice,
+ * event ledger, channel law, emitted-truth, and the durable registry.
+ *
+ * Two storms, named for what they prove:
+ *   - the engine storm drives detection with explicit scans (catch-up
+ *     mode) and judges the NET of each random batch — burst composition
+ *     is its territory, because the model and the detector share the
+ *     same interval by construction;
+ *   - the live storm rings doorbells through production wiring after
+ *     start() and never invokes a manual scan — one operation is one
+ *     interval (ring, drain, judge), because a live observer lawfully
+ *     settles between operations and witnesses the intermediate
+ *     continuity a net-state model cannot claim.
+ *
+ * The alphabet is proven TOTAL by construction: the weight table must
+ * name every operation, so a new op cannot ship unstormed. (Managed
+ * references sit outside this ground: they are minted by deliberate
+ * act, never by detection, so no storm operation can compose one.)
+ *
+ * Storms are seeded so any failure replays exactly. Every run replays
+ * the default seed plus the PERMANENT REGRESSION SEEDS — compositions
+ * that convicted the judge during the gate and forced a ratified law.
+ * Setting AMALGM_STORM_SEED switches to single-seed replay for
+ * diagnosis. A seed lists under the storm that convicted it: the live
+ * storm draws its rng from seed + 1, so the same number is a different
+ * composition in each storm — moving a seed between lists loses the
+ * discovery.
+ */
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+const {
+  cleanup, fakeWatchKit, makeKit, sleep,
+} = require('./entity.rig');
+
+test.after(cleanup);
+
+const DEFAULT_SEED = 20260802;
+
+// Permanent regression seeds. Engine trio: 987654321 put two active
+// entities on one slot (forced the slot-based occupant law), 77777 was
+// the last engine conviction standing (the occupant desync under an
+// ancestor rename in the same interval), 123123123 convicted through
+// the parent-at-open / lens-exclusion era. Live seed: 1732050808 landed
+// a rename onto standing divergent ground (forced the standing-ground
+// absorption law; the only known kill of the graph.js standing-ground
+// mutant — the engine storm PASSES that mutant at this seed).
+const ENGINE_SEEDS = [DEFAULT_SEED, 77777, 987654321, 123123123];
+const LIVE_SEEDS = [DEFAULT_SEED, 1732050808];
+
+const replay = process.env.AMALGM_STORM_SEED
+  ? [Number(process.env.AMALGM_STORM_SEED)] : null;
+const engineSeeds = replay ?? ENGINE_SEEDS;
+const liveSeeds = replay ?? LIVE_SEEDS;
+
+function mulberry32(seed) {
+  let a = seed >>> 0;
+  return () => {
+    a = (a + 0x6d2b79f5) >>> 0;
+    let t = a;
+    t = Math.imul(t ^ (t >>> 15), t | 1);
+    t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+  };
+}
+
+/**
+ * The storm: every op performs a real filesystem operation through the
+ * kit (which records it in the model) and keeps its own bookkeeping of
+ * what the DISK holds — never identity; the judges own that. `touched`
+ * collects the addresses each op moved, for the live storm's doorbells.
+ */
+function makeStorm(rng, kit) {
+  const files = []; // relPaths of on-disk regular files
+  const links = []; // relPaths of on-disk symlinks
+  const dirs = ['']; // on-disk directories ('' = the root)
+  const repos = []; // dirs currently holding a .git
+  const touched = [];
+
+  // The name/content counter is LOCAL to the storm, so a seed's
+  // composition is a pure function of the seed — the same whether it
+  // runs alone under AMALGM_STORM_SEED or after other seeds in the
+  // full suite. A shared counter would break exact replay.
+  let stamp = 0;
+  /** Deterministic, always-distinct content. */
+  const bytes = () => `#${(stamp++).toString(36)}-${'x'.repeat(12 + Math.floor(rng() * 400))}`;
+
+  const pick = (arr) => arr[Math.floor(rng() * arr.length)];
+  const drop = (arr, value) => arr.splice(arr.indexOf(value), 1);
+  const fresh = (kind) => `${kind}${(stamp++).toString(36)}`;
+  const join = (dir, name) => (dir ? `${dir}/${name}` : name);
+  const dirname = (rel) => (rel.includes('/') ? rel.slice(0, rel.lastIndexOf('/')) : '');
+  const touch = (...rels) => touched.push(...rels);
+
+  /** A dir leaves disk: everything beneath it leaves the books with it. */
+  const dropUnder = (relDir) => {
+    const gone = (rel) => rel === relDir || rel.startsWith(`${relDir}/`);
+    for (const list of [files, links, repos]) {
+      for (const rel of list.filter(gone)) drop(list, rel);
+    }
+    for (const rel of dirs.filter((d) => d && gone(d))) drop(dirs, rel);
+  };
+  /** A dir moves: everything beneath it re-addresses in the books. */
+  const moveUnder = (from, to) => {
+    const moved = (rel) => `${to}${rel.slice(from.length)}`;
+    for (const list of [files, links, dirs, repos]) {
+      for (let i = 0; i < list.length; i += 1) {
+        if (list[i] === from || list[i].startsWith(`${from}/`)) list[i] = moved(list[i]);
+      }
+    }
+  };
+  const linkTarget = () => pick([
+    () => pick(files) ?? 'nowhere/empty',
+    () => pick(dirs.filter(Boolean)) ?? 'nowhere/empty',
+    () => `nowhere/${fresh('t')}`,
+  ])();
+
+  const ops = {
+    // --- file ground -----------------------------------------------------
+    fileCreate() {
+      const rel = join(pick(dirs), `${fresh('f')}.md`);
+      kit.write(rel, bytes());
+      files.push(rel);
+      touch(rel);
+    },
+    fileCreateBinary() {
+      const rel = join(pick(dirs), `${fresh('b')}.bin`);
+      kit.write(rel, Buffer.from([0x00, 0xff, stamp % 256, 0x00, stamp % 251]));
+      files.push(rel);
+      touch(rel);
+    },
+    fileEdit() {
+      const rel = pick(files);
+      kit.write(rel, bytes());
+      touch(rel);
+    },
+    sameSizeEdit() {
+      // Stats lie about content: same length, different bytes.
+      const rel = pick(files);
+      kit.write(rel, `#${(stamp++).toString(36).padStart(6, '0')}-same-size`);
+      touch(rel);
+    },
+    atomicReplace() {
+      const rel = pick(files);
+      kit.replace(rel, bytes());
+      touch(rel);
+    },
+    touchSame() {
+      // mtime moves, bytes do not: must be silence.
+      kit.touchSame(pick(files));
+    },
+    fileRename() {
+      const rel = pick(files);
+      const to = join(dirname(rel), `${fresh('f')}.md`);
+      kit.mv(rel, to);
+      drop(files, rel);
+      files.push(to);
+      touch(rel, to);
+    },
+    fileMove() {
+      const rel = pick(files);
+      const to = join(pick(dirs), `${fresh('f')}.md`);
+      kit.mv(rel, to);
+      drop(files, rel);
+      files.push(to);
+      touch(rel, to);
+    },
+    fileOverwriteByMove() {
+      // rename(2) atomically replaces the occupant of the same kind.
+      const rel = pick(files);
+      const onto = pick(files);
+      if (rel === onto) return ops.fileRename();
+      kit.mv(rel, onto);
+      drop(files, rel);
+      touch(rel, onto);
+      return undefined;
+    },
+    fileSwap() {
+      const [a, b] = [pick(files), pick(files)];
+      if (a === b) return ops.fileRename();
+      const tmp = join(dirname(a), `${fresh('s')}.md`);
+      kit.mv(a, tmp);
+      kit.mv(b, a);
+      kit.mv(tmp, b);
+      touch(a, b, tmp);
+      return undefined;
+    },
+    copyDupe() {
+      // Identical bytes, two channels: identity is never derived from bytes.
+      const rel = pick(files);
+      const to = join(pick(dirs), `${fresh('c')}.md`);
+      const data = bytes();
+      kit.write(rel, data);
+      kit.copy(rel, to, data);
+      files.push(to);
+      touch(rel, to);
+    },
+    fileRemove() {
+      const rel = pick(files);
+      kit.rm(rel);
+      drop(files, rel);
+      touch(rel);
+    },
+    fileRecreate() {
+      // Death and rebirth inside one interval: the address never
+      // observably died.
+      const rel = pick(files);
+      kit.rm(rel);
+      kit.write(rel, bytes());
+      touch(rel);
+    },
+
+    // --- folder ground ---------------------------------------------------
+    mkdirTree() {
+      const a = join(pick(dirs), fresh('d'));
+      const b = `${a}/${fresh('d')}`;
+      kit.mkdir(b);
+      dirs.push(a, b);
+      const rel = join(b, `${fresh('f')}.md`);
+      kit.write(rel, bytes());
+      files.push(rel);
+      touch(a, b, rel);
+    },
+    dirRename() {
+      const rel = pick(dirs.filter(Boolean));
+      if (!rel || repos.some((r) => rel === r || rel.startsWith(`${r}/`))) return ops.mkdirTree();
+      const to = join(dirname(rel), fresh('d'));
+      kit.mvDir(rel, to);
+      moveUnder(rel, to);
+      touch(rel, to);
+      return undefined;
+    },
+    dirRemove() {
+      const rel = pick(dirs.filter(Boolean));
+      if (!rel) return ops.mkdirTree();
+      kit.rmDir(rel);
+      dropUnder(rel);
+      touch(rel);
+      return undefined;
+    },
+
+    // --- link ground -----------------------------------------------------
+    linkCreate() {
+      const rel = join(pick(dirs), `${fresh('l')}.md`);
+      kit.symlink(rel, linkTarget());
+      links.push(rel);
+      touch(rel);
+    },
+    linkRetarget() {
+      if (links.length === 0) return ops.linkCreate();
+      const rel = pick(links);
+      kit.retarget(rel, `nowhere/${fresh('t')}`);
+      touch(rel);
+      return undefined;
+    },
+    linkRename() {
+      if (links.length === 0) return ops.linkCreate();
+      const rel = pick(links);
+      const to = join(pick(dirs), `${fresh('l')}.md`);
+      kit.mvLink(rel, to);
+      drop(links, rel);
+      links.push(to);
+      touch(rel, to);
+      return undefined;
+    },
+    linkSilentRecreate() {
+      // A new inode under an old name with an old target: silence.
+      if (links.length === 0) return ops.linkCreate();
+      const rel = pick(links);
+      const target = require('fs').readlinkSync(kit.abs(rel));
+      kit.retarget(rel, target);
+      touch(rel);
+      return undefined;
+    },
+    linkRemove() {
+      if (links.length === 0) return ops.linkCreate();
+      const rel = pick(links);
+      kit.rmLink(rel);
+      drop(links, rel);
+      touch(rel);
+      return undefined;
+    },
+
+    // --- kinds crossing at a slot ---------------------------------------
+    linkOntoFileSlot() {
+      const rel = pick(files);
+      kit.rm(rel);
+      kit.symlink(rel, linkTarget());
+      drop(files, rel);
+      links.push(rel);
+      touch(rel);
+    },
+    fileOntoLinkSlot() {
+      if (links.length === 0) return ops.linkCreate();
+      const rel = pick(links);
+      kit.rmLink(rel);
+      kit.write(rel, bytes());
+      drop(links, rel);
+      files.push(rel);
+      touch(rel);
+      return undefined;
+    },
+
+    // --- contests and refusals ------------------------------------------
+    contestLand() {
+      // The owner's ground leaves and a mover lands on its slot: two
+      // identity claims, one address — divergence until the ground moves on.
+      const [mover, slot] = [pick(files), pick(files)];
+      if (mover === slot) return ops.fileRename();
+      kit.rm(slot);
+      kit.mv(mover, slot);
+      drop(files, mover);
+      touch(mover, slot);
+      return undefined;
+    },
+    containerRefusal() {
+      // A populated folder swapped for a file: the canonical graph refuses.
+      const rel = dirs.filter(Boolean).find((d) => files.some((f) => f.startsWith(`${d}/`))
+        && !repos.some((r) => d === r || d.startsWith(`${r}/`)));
+      if (!rel) return ops.mkdirTree();
+      kit.rmDir(rel);
+      dropUnder(rel);
+      kit.write(rel, bytes());
+      files.push(rel);
+      touch(rel);
+      return undefined;
+    },
+
+    // --- the git lens ----------------------------------------------------
+    repoInit() {
+      const rel = dirs.filter(Boolean).find((d) => !repos.some((r) => d === r
+        || d.startsWith(`${r}/`) || r.startsWith(`${d}/`)));
+      if (!rel) return ops.mkdirTree();
+      kit.gitInit(rel);
+      repos.push(rel);
+      touch(rel);
+      return undefined;
+    },
+    repoLift() {
+      if (repos.length === 0) return ops.repoInit();
+      const rel = pick(repos);
+      kit.gitRemove(rel);
+      drop(repos, rel);
+      touch(rel);
+      return undefined;
+    },
+
+    // --- excluded territory ----------------------------------------------
+    excludedChurn() {
+      // Must never surface as any event, channel, or record.
+      kit.write(`node_modules/junk${(stamp++).toString(36)}.js`, 'x');
+      kit.write('.env', `SECRET=${stamp}`);
+      touch('node_modules', '.env');
+    },
+  };
+
+  const WEIGHTS = {
+    fileCreate: 12,
+    fileCreateBinary: 4,
+    fileEdit: 14,
+    sameSizeEdit: 6,
+    atomicReplace: 8,
+    touchSame: 4,
+    fileRename: 7,
+    fileMove: 7,
+    fileOverwriteByMove: 3,
+    fileSwap: 3,
+    copyDupe: 3,
+    fileRemove: 6,
+    fileRecreate: 4,
+    mkdirTree: 6,
+    dirRename: 5,
+    dirRemove: 3,
+    linkCreate: 6,
+    linkRetarget: 5,
+    linkRename: 4,
+    linkSilentRecreate: 3,
+    linkRemove: 3,
+    linkOntoFileSlot: 2,
+    fileOntoLinkSlot: 2,
+    contestLand: 3,
+    containerRefusal: 2,
+    repoInit: 2,
+    repoLift: 2,
+    excludedChurn: 4,
+  };
+  const table = [];
+  for (const [name, weight] of Object.entries(WEIGHTS)) {
+    for (let i = 0; i < weight; i += 1) table.push(ops[name]);
+  }
+
+  return {
+    ops,
+    WEIGHTS,
+    step() {
+      if (files.length < 6) ops.fileCreate();
+      else if (files.length > 70) pick([ops.fileRemove, ops.dirRemove, ops.fileEdit])();
+      else pick(table)();
+    },
+    /** The addresses moved since the last drain — the live storm's bells. */
+    drainTouched() {
+      return touched.splice(0);
+    },
+  };
+}
+
+// --- totality: the alphabet cannot silently shrink or grow ------------------
+
+test('the storm alphabet is total: every operation carries weight', () => {
+  const storm = makeStorm(mulberry32(DEFAULT_SEED), makeKit('alphabet'));
+  assert.deepEqual(Object.keys(storm.WEIGHTS).sort(), Object.keys(storm.ops).sort(),
+    'the weight table must name exactly the operations — an unweighted op is an unstormed op');
+  for (const [name, weight] of Object.entries(storm.WEIGHTS)) {
+    assert.ok(weight > 0, `op ${name} has no weight: it would never run`);
+  }
+});
+
+// --- storm 1: the engine, catch-up mode -------------------------------------
+
+for (const seed of engineSeeds) {
+  test(`engine storm: seeded random compositions, the whole oracle at every quiet point (seed ${seed})`, () => {
+    const rng = mulberry32(seed);
+    const kit = makeKit(`engine-storm-${seed}`);
+    kit.enroll();
+    const storm = makeStorm(rng, kit);
+
+    for (let batch = 0; batch < 60; batch += 1) {
+      const opCount = 3 + Math.floor(rng() * 5);
+      for (let i = 0; i < opCount; i += 1) storm.step();
+      kit.point();
+    }
+  });
+}
+
+// --- storm 2: live, event-only ----------------------------------------------
+
+for (const seed of liveSeeds) {
+  test(`live storm: doorbells through production wiring, event-only verdicts, no manual scans (seed ${seed})`, async () => {
+    const rng = mulberry32(seed + 1);
+    const bells = fakeWatchKit();
+    const kit = makeKit(`live-storm-${seed}`, { watch: bells.watch, settleMs: 1 });
+    kit.enroll();
+    kit.point(); // the catch-up era ends here
+    kit.observer.start();
+    try {
+      const storm = makeStorm(rng, kit);
+
+      // The chain must drain ON ITS OWN: this waits by looking only — events
+      // stopped growing and the registry intake is clean — and never scans,
+      // flushes, or repairs. A system that needed help fails at the deadline.
+      const drained = async (deadlineMs = 10_000) => {
+        const deadline = Date.now() + deadlineMs;
+        let seen = kit.events.length;
+        let quiet = 0;
+        while (quiet < 3 || kit.evidence.dirty()) {
+          assert.ok(Date.now() < deadline,
+            `storm: the event-driven chain did not drain (seed ${seed + 1})`);
+          await sleep(10);
+          if (kit.events.length === seen && !kit.evidence.dirty()) quiet += 1;
+          else {
+            seen = kit.events.length;
+            quiet = 0;
+          }
+        }
+      };
+
+      for (let i = 0; i < 70; i += 1) {
+        storm.step();
+        for (const rel of storm.drainTouched()) bells.ringAt(kit.abs(rel));
+        await drained();
+        kit.point({ scan: false });
+      }
+    } finally {
+      kit.observer.stop();
+    }
+  });
+}

package/runtime/scripts/amalgm-mcp/tests/fake-watch.js

@@ -0,0 +1,35 @@
+'use strict';
+
+/**
+ * A deterministic stand-in for fs.watch: captures every doorbell the
+ * observer opens and lets an exam deliver exactly the events it means
+ * to — down to the lawful worst case, a rename delivering only the new
+ * name, which no live OS watcher can be made to pin. Install before
+ * `observer.start()`, always `restore()` in a finally.
+ */
+
+const fs = require('fs');
+
+function installFakeWatch() {
+  const watchers = [];
+  const realWatch = fs.watch;
+  fs.watch = (target, _opts, cb) => {
+    const entry = {
+      target: String(target), cb, closed: false,
+      on: () => {}, close: () => { entry.closed = true; },
+    };
+    watchers.push(entry);
+    return entry;
+  };
+  return {
+    /** Ring every open doorbell on `target` with one raw name. */
+    deliver(target, name) {
+      for (const entry of [...watchers]) {
+        if (!entry.closed && entry.target === target) entry.cb('rename', name);
+      }
+    },
+    restore() { fs.watch = realWatch; },
+  };
+}
+
+module.exports = { installFakeWatch };