liris: add 10-minute logical extreme stress receipt

docs/LOGICAL-EXTREME-STRESS-2026-06-11.hbp

@@ -0,0 +1,9 @@
+LOGICSTRESSHDR|tool=logical-extreme-stress.mjs|duration_requested_sec=600|batch=1000000|quant_message_mb=64|started=2026-06-11T21:50:42.957Z|json=0
+LOGICSTRESSENV|node=v24.13.1|platform=win32|arch=x64|cpu_count=4|pid=564|json=0
+LOGICSTRESSSPEED|section_sec=300.000|logical_agents=6356000000|ops_per_sec=21186441|rooms=10000|lane0=2118666667|lane1=2118666667|lane2=2118666666|residue6=1059333334,1059333334,1059333333,1059333333,1059333333,1059333333|genius_marks=127120000|mistake_marks=135234043|gc2000_survivors=2000|gc50000_survivors=50000|checksum=3667413017|json=0
+LOGICSTRESSTOKENS|section_sec=60.000|bindings=7090000|ops_per_sec=118012|ready=5893869|defer=1189019|blocked=7112|checksum=443|json=0
+LOGICSTRESSCOLLISIONS|section_sec=60.000|probes=14070000|ops_per_sec=234437|state_LOGICAL_AGENT_LOGICAL_COLLISION_PRESERVED_ROUTE_TO_SUPERVISOR=5628000|state_REAL_AGENT_REAL_COLLISION_BLOCKED_NEEDS_FREE_ADDRESS=2814000|state_REAL_AGENT_REAL_COLLISION_REROUTE_READY_DRAFT=2814000|state_UNCLASSIFIED_UNCLASSIFIED_COLLISION_HELD=2814000|checksum=0|json=0
+LOGICSTRESSZETA|section_sec=90.000|classifications=351350000|ops_per_sec=3903631|lane0=117116901|lane1=117116550|lane2=117116549|ppow_composite=323683523|ppow_p2=59075|ppow_p3=8794|ppow_pk=15129|ppow_prime=27582775|ppow_unit=704|external_lane_catches=688646|external_lane_consistent=681619|sweep_pairs=9589|sweep_violations=0|json=0
+LOGICSTRESSREDUCTION|section_sec=90.000|message_mb=64|cycles=3184|ingest_mbps=2263.4|raw_bytes_each=67108864|tuple_bytes_each=3200|reduction_x=20971.5|tail_payload_kb=3.1|checksum=0|json=0
+LOGICSTRESSPROCESS|host_processes_used=1|child_process_spawns=0|external_model_calls=0|rss_start_mb=43.7|rss_peak_mb=136.1|rss_end_mb=136.1|heap_end_mb=6.0|logical_ops_total=6728513184|json=0
+LOGICSTRESSVERDICT|status=PASS|limits=logical-only-no-live-mutation-no-per-agent-files|physical_claim=bounded-process-envelope-not-infinite-memory|elapsed_anchor_ms=600201|json=0

docs/LOGICAL-EXTREME-STRESS-2026-06-11.hbp.sha256

@@ -0,0 +1 @@
+9D4AC4B14E9999E8ECF5B56F2B903B019C945139039208E8D9817C4664AB55FE  LOGICAL-EXTREME-STRESS-2026-06-11.hbp

tests/logical-extreme-stress.unit.test.mjs

@@ -0,0 +1,24 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import {
+  DEFINITION_ROWS,
+  runExtreme,
+} from '../tools/behcs/logical-extreme-stress.mjs';
+
+test('logical extreme stress definition rows are HBP-only and safe by default', () => {
+  assert.ok(DEFINITION_ROWS.length >= 3);
+  assert.ok(DEFINITION_ROWS.every((row) => row.endsWith('json=0')));
+  assert.ok(DEFINITION_ROWS.some((row) => row.includes('child_process_spawns=0')));
+  assert.ok(DEFINITION_ROWS.some((row) => row.includes('no_live_fabric_mutation=1')));
+});
+
+test('logical extreme stress can run a tiny bounded smoke', () => {
+  const rows = runExtreme({ seconds: 0.05, batch: 1000, quantMB: 1 });
+  assert.equal(rows[0].startsWith('LOGICSTRESSHDR|'), true);
+  assert.ok(rows.some((row) => row.startsWith('LOGICSTRESSSPEED|')));
+  assert.ok(rows.some((row) => row.startsWith('LOGICSTRESSREDUCTION|') && row.includes('reduction_x=')));
+  assert.ok(rows.some((row) => row.startsWith('LOGICSTRESSPROCESS|') && row.includes('child_process_spawns=0')));
+  assert.ok(rows.at(-1).includes('status=PASS'));
+  assert.ok(rows.every((row) => row.endsWith('json=0')));
+});

tests/logical-extreme-stress.unit.test.mjs.sha256

@@ -0,0 +1 @@
+B815F8AC021D188FA47BE8C7149C033DE01ABF687A6AA3E193C513CE69F1C305  logical-extreme-stress.unit.test.mjs

tests/supervisor-collision-router.system.test.mjs

@@ -70,6 +70,7 @@ const sealedFiles = [
   'docs/ZETA-QUANT-PARITY-BASELINE-2026-06-11.hbp',
   'docs/ACER-ZETA-IMPLEMENTATION-2026-06-11.hbp',
   'docs/LIRIS-ZETA-IMPLEMENTATION-READBACK-2026-06-11.hbp',
+  'docs/LOGICAL-EXTREME-STRESS-2026-06-11.hbp',
   'docs/LIRIS-FROZEN-SLICE-PREIMAGE-READBACK-2026-06-11.hbp',
   'docs/LIRIS-QUANT-HUGE-MESSAGE-BENCH-READBACK-2026-06-11.hbp',
   'docs/LIRIS-FROZEN-SLICE-REBIND-READBACK-2026-06-11.hbp',
@@ -105,10 +106,12 @@ const sealedFiles = [
   'tools/behcs/agent-spawn-throughput-benchmark.mjs',
   'tools/behcs/quant-huge-message-benchmark.mjs',
   'tools/behcs/quant-fidelity-sweep.mjs',
+  'tools/behcs/logical-extreme-stress.mjs',
   'tools/omni-processor/omnitranslator-v0.js',
   'tests/agent-spawn-throughput-benchmark.unit.test.mjs',
   'tests/quant-huge-message-benchmark.unit.test.mjs',
   'tests/quant-fidelity-sweep.unit.test.mjs',
+  'tests/logical-extreme-stress.unit.test.mjs',
   'tests/d22-verb-adapter.unit.test.mjs',
   'tests/d22-parity-probe.unit.test.mjs',
   'tests/dashboard-resolver.unit.test.mjs',

tests/supervisor-collision-router.system.test.mjs.sha256

@@ -1 +1 @@
-6F9ED15A081CF6E7433436FDF7E49DA3B44DFBBC65E71A4CC8CF01F38D301D14  supervisor-collision-router.system.test.mjs
+F7560A3AFF08A0AD512E55CCF0BFB72A3089D2738ADFB2BC3F6F40E60D3379CB  supervisor-collision-router.system.test.mjs

tools/behcs/logical-extreme-stress.mjs

@@ -0,0 +1,294 @@
+#!/usr/bin/env node
+import { createHash } from 'node:crypto';
+import { cpus } from 'node:os';
+import { resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { performance } from 'node:perf_hooks';
+
+import { bindToken } from './token-cube-catalog-binder.mjs';
+import { planCollisionRoute } from './supervisor-collision-router.mjs';
+import { quant8, tupleBuffer } from './quant-huge-message-benchmark.mjs';
+import { forcingSweep, zetaClassify, zetaTransition } from './zeta-quant.mjs';
+
+const ROOM_COUNT = 10000;
+const DEFAULT_SECONDS = 600;
+const DEFAULT_BATCH = 1_000_000;
+const DEFAULT_QUANT_MB = 64;
+const TOKEN_KINDS = ['sha16-row-hash', 'sha256-ref', 'bh-tuple-digest'];
+const CATALOGS = ['hilbert-omni-47D', 'atlas-v55', 'quant-bus-v48'];
+
+export const DEFINITION_ROWS = Object.freeze([
+  'LOGICSTRESSDEF|tool=logical-extreme-stress.mjs|purpose=bounded-10-minute-logical-fabric-stress-speed+tokens+reductions+process-envelope+collisions|default=definition-only|json=0',
+  'LOGICSTRESSSCOPE|hot_path=logical-only-in-memory|disk=receipt-only-if-caller-redirects-output|child_process_spawns=0|external_model_calls=0|no_live_fabric_mutation=1|json=0',
+  'LOGICSTRESSLAYERS|speed=positional-agent-stream|tokens=token-cube-binder|reductions=quant8-large-message-tuple-compression|process=single-node-process-memory-envelope|collisions=supervisor-router+zeta-external-lane-corruption|json=0',
+]);
+
+function parseNumber(args, name, fallback) {
+  const item = args.find((arg) => arg.startsWith(`${name}=`));
+  if (!item) return fallback;
+  const n = Number(item.slice(name.length + 1));
+  return Number.isFinite(n) && n > 0 ? n : fallback;
+}
+
+function nowMs() {
+  return performance.now();
+}
+
+function perSecond(count, ms) {
+  return Math.round((count * 1000) / Math.max(ms, 0.000001));
+}
+
+function mb(bytes) {
+  return (bytes / 1048576).toFixed(1);
+}
+
+function memorySnapshot() {
+  const m = process.memoryUsage();
+  return {
+    rss: m.rss,
+    heapUsed: m.heapUsed,
+    external: m.external,
+  };
+}
+
+function hash32(x) {
+  x = (x + 0x9e3779b9) >>> 0;
+  x = Math.imul(x ^ (x >>> 16), 0x85ebca6b) >>> 0;
+  x = Math.imul(x ^ (x >>> 13), 0xc2b2ae35) >>> 0;
+  return (x ^ (x >>> 16)) >>> 0;
+}
+
+function runTimed(deadlineMs, batch, work) {
+  let ops = 0;
+  let checksum = 0;
+  const started = nowMs();
+  while (nowMs() < deadlineMs) {
+    const r = work(batch, ops);
+    ops += batch;
+    checksum = (checksum ^ r) >>> 0;
+  }
+  return { ops, elapsedMs: nowMs() - started, checksum };
+}
+
+function stressLogical(seconds, batch) {
+  const laneCounts = [0, 0, 0];
+  const residueCounts = [0, 0, 0, 0, 0, 0];
+  let genius = 0;
+  let mistake = 0;
+  let roomChecksum = 0;
+  const r = runTimed(nowMs() + seconds * 1000, batch, (n, offset) => {
+    let local = 0;
+    for (let j = 0; j < n; j += 1) {
+      const id = offset + j;
+      const room = id % ROOM_COUNT;
+      const lane = id % 3;
+      const residue = id % 6;
+      laneCounts[lane] += 1;
+      residueCounts[residue] += 1;
+      if (id % 50 === 0) genius += 1;
+      if (id % 47 === 0) mistake += 1;
+      local = (local ^ room ^ lane ^ residue ^ hash32(id)) >>> 0;
+      roomChecksum = (roomChecksum + room) >>> 0;
+    }
+    return local;
+  });
+  return {
+    ...r,
+    laneCounts,
+    residueCounts,
+    genius,
+    mistake,
+    gc2000: Math.min(genius, 2000),
+    gc50000: Math.min(mistake, 50000),
+    roomChecksum,
+  };
+}
+
+function tokenInput(i) {
+  const kind = TOKEN_KINDS[i % TOKEN_KINDS.length];
+  const catalog = CATALOGS[i % CATALOGS.length];
+  const address = i % 2000;
+  const scope = i % 101 === 0 ? 'mint' : 'bind-draft';
+  const mode = i % 89 === 0 ? 'live' : 'draft';
+  const dirty = i % 997 === 0;
+  return {
+    token_id: dirty ? 'TOK-DIRTY|BAD' : `TOK-STRESS-${(i % 1000000).toString(36).toUpperCase().padStart(4, '0')}`,
+    token_kind: kind,
+    digest_sha16: (0x1000000000000000n + BigInt(hash32(i))).toString(16).slice(-16),
+    cube_bh: `BH-ACER-${address}`,
+    scope,
+    source_catalog: catalog,
+    mode,
+  };
+}
+
+function stressTokens(seconds, batch) {
+  const counts = { ready: 0, blocked: 0, defer: 0 };
+  const r = runTimed(nowMs() + seconds * 1000, batch, (n, offset) => {
+    let local = 0;
+    for (let j = 0; j < n; j += 1) {
+      const out = bindToken(tokenInput(offset + j));
+      if (out.verdict === 'DRAFT_BINDING_READY') counts.ready += 1;
+      else if (out.verdict === 'DEFER_TO_OPERATOR') counts.defer += 1;
+      else counts.blocked += 1;
+      local ^= out.row.length;
+    }
+    return local;
+  });
+  return { ...r, counts };
+}
+
+function collisionInput(i) {
+  const lane = i % 5;
+  if (lane === 0) return { head: 'COLLISION', agent_system: 'logical', role: 'supervisor', collision: 'logical' };
+  if (lane === 1) return { head: 'COLLISION', agent_system: 'real', os_pid: String(1000 + (i % 1000)), port: '4944' };
+  if (lane === 2) return { head: 'COLLISION', role: 'supervisor', collision: 'mixed', port: '0' };
+  if (lane === 3) return { head: 'COLLISION', agent_system: 'real', collision: 'real', free_real_address: `BH-ACER-${i % 10000}` };
+  return { head: 'STATUS', role: 'logical' };
+}
+
+function stressCollisions(seconds, batch) {
+  const counts = {};
+  const r = runTimed(nowMs() + seconds * 1000, batch, (n, offset) => {
+    let local = 0;
+    for (let j = 0; j < n; j += 1) {
+      const plan = planCollisionRoute(collisionInput(offset + j));
+      const key = `${plan.classification}:${plan.state}`;
+      counts[key] = (counts[key] ?? 0) + 1;
+      local ^= key.length + (plan.executable ? 1 : 0);
+    }
+    return local;
+  });
+  return { ...r, counts };
+}
+
+function stressZeta(seconds, batch) {
+  const lanes = [0, 0, 0];
+  const ppow = {};
+  let externalCaught = 0;
+  let forcedConsistent = 0;
+  const r = runTimed(nowMs() + seconds * 1000, batch, (n, offset) => {
+    let local = 0;
+    for (let j = 0; j < n; j += 1) {
+      const idx = (offset + j) % 1000000;
+      const z = zetaClassify(idx);
+      if (z.lane !== 'none') lanes[z.lane] += 1;
+      ppow[z.ppow] = (ppow[z.ppow] ?? 0) + 1;
+      if (j % 257 === 0) {
+        const t = zetaTransition(11, 13, { claimedLaneA: '2', claimedLaneB: (j % 514 === 0) ? '2' : '1' });
+        if (t.verdict === 'FORCING_VIOLATION') externalCaught += 1;
+        if (t.verdict === 'FORCED_CONSISTENT') forcedConsistent += 1;
+      }
+      local ^= z.lane === 'none' ? 0 : z.lane;
+    }
+    return local;
+  });
+  const sweep = forcingSweep();
+  return { ...r, lanes, ppow, externalCaught, forcedConsistent, sweep };
+}
+
+function fillVector(arr, seed) {
+  let s = seed >>> 0;
+  for (let i = 0; i < arr.length; i += 1) {
+    s = Math.imul(s, 1664525) + 1013904223 >>> 0;
+    arr[i] = (s / 2147483648) - 1;
+  }
+}
+
+function stressQuant(seconds, messageMB) {
+  const dims = Math.max(1024, Math.floor(messageMB * 1048576 / 8));
+  const msg = new Float64Array(dims);
+  fillVector(msg, 0x12345678);
+  const rawBytes = msg.byteLength;
+  let tupleBytes = 0;
+  let cycles = 0;
+  let hashChecksum = 0;
+  const started = nowMs();
+  const deadline = started + seconds * 1000;
+  while (nowMs() < deadline) {
+    const q = quant8(msg);
+    const tuple = tupleBuffer(q);
+    tupleBytes = tuple.length;
+    hashChecksum ^= createHash('sha256').update(tuple).digest()[0];
+    cycles += 1;
+  }
+  const elapsedMs = nowMs() - started;
+  return {
+    cycles,
+    elapsedMs,
+    messageMB,
+    rawBytes,
+    tupleBytes,
+    rawProcessedBytes: rawBytes * cycles,
+    ingestMBps: (rawBytes * cycles / 1048576) / Math.max(elapsedMs / 1000, 0.000001),
+    reduction: rawBytes / Math.max(tupleBytes, 1),
+    hashChecksum,
+  };
+}
+
+function countsRow(prefix, counts) {
+  return Object.entries(counts).sort(([a], [b]) => a.localeCompare(b)).map(([k, v]) => `${prefix}${k.replace(/[^A-Za-z0-9_-]/g, '_')}=${v}`).join('|');
+}
+
+export function runExtreme(options = {}) {
+  const seconds = options.seconds ?? DEFAULT_SECONDS;
+  const batch = options.batch ?? DEFAULT_BATCH;
+  const quantMB = options.quantMB ?? DEFAULT_QUANT_MB;
+  const startedWall = new Date().toISOString();
+  const totalStarted = nowMs();
+  const startMem = memorySnapshot();
+  let peakRss = startMem.rss;
+  const rows = [
+    `LOGICSTRESSHDR|tool=logical-extreme-stress.mjs|duration_requested_sec=${seconds}|batch=${batch}|quant_message_mb=${quantMB}|started=${startedWall}|json=0`,
+    `LOGICSTRESSENV|node=${process.version}|platform=${process.platform}|arch=${process.arch}|cpu_count=${cpus().length}|pid=${process.pid}|json=0`,
+  ];
+  const slice = {
+    logical: seconds * 0.50,
+    tokens: seconds * 0.10,
+    collisions: seconds * 0.10,
+    zeta: seconds * 0.15,
+    quant: seconds * 0.15,
+  };
+
+  const logical = stressLogical(slice.logical, batch);
+  peakRss = Math.max(peakRss, memorySnapshot().rss);
+  rows.push(`LOGICSTRESSSPEED|section_sec=${slice.logical.toFixed(3)}|logical_agents=${logical.ops}|ops_per_sec=${perSecond(logical.ops, logical.elapsedMs)}|rooms=${ROOM_COUNT}|lane0=${logical.laneCounts[0]}|lane1=${logical.laneCounts[1]}|lane2=${logical.laneCounts[2]}|residue6=${logical.residueCounts.join(',')}|genius_marks=${logical.genius}|mistake_marks=${logical.mistake}|gc2000_survivors=${logical.gc2000}|gc50000_survivors=${logical.gc50000}|checksum=${(logical.checksum ^ logical.roomChecksum) >>> 0}|json=0`);
+
+  const tokens = stressTokens(slice.tokens, Math.max(1000, Math.floor(batch / 100)));
+  peakRss = Math.max(peakRss, memorySnapshot().rss);
+  rows.push(`LOGICSTRESSTOKENS|section_sec=${slice.tokens.toFixed(3)}|bindings=${tokens.ops}|ops_per_sec=${perSecond(tokens.ops, tokens.elapsedMs)}|ready=${tokens.counts.ready}|defer=${tokens.counts.defer}|blocked=${tokens.counts.blocked}|checksum=${tokens.checksum}|json=0`);
+
+  const collisions = stressCollisions(slice.collisions, Math.max(1000, Math.floor(batch / 100)));
+  peakRss = Math.max(peakRss, memorySnapshot().rss);
+  rows.push(`LOGICSTRESSCOLLISIONS|section_sec=${slice.collisions.toFixed(3)}|probes=${collisions.ops}|ops_per_sec=${perSecond(collisions.ops, collisions.elapsedMs)}|${countsRow('state_', collisions.counts)}|checksum=${collisions.checksum}|json=0`);
+
+  const zeta = stressZeta(slice.zeta, Math.max(1000, Math.floor(batch / 20)));
+  peakRss = Math.max(peakRss, memorySnapshot().rss);
+  rows.push(`LOGICSTRESSZETA|section_sec=${slice.zeta.toFixed(3)}|classifications=${zeta.ops}|ops_per_sec=${perSecond(zeta.ops, zeta.elapsedMs)}|lane0=${zeta.lanes[0]}|lane1=${zeta.lanes[1]}|lane2=${zeta.lanes[2]}|${countsRow('ppow_', zeta.ppow)}|external_lane_catches=${zeta.externalCaught}|external_lane_consistent=${zeta.forcedConsistent}|sweep_pairs=${zeta.sweep.pairs}|sweep_violations=${zeta.sweep.violations}|json=0`);
+
+  const quant = stressQuant(slice.quant, quantMB);
+  peakRss = Math.max(peakRss, memorySnapshot().rss);
+  rows.push(`LOGICSTRESSREDUCTION|section_sec=${slice.quant.toFixed(3)}|message_mb=${quant.messageMB}|cycles=${quant.cycles}|ingest_mbps=${quant.ingestMBps.toFixed(1)}|raw_bytes_each=${quant.rawBytes}|tuple_bytes_each=${quant.tupleBytes}|reduction_x=${quant.reduction.toFixed(1)}|tail_payload_kb=${(quant.tupleBytes / 1024).toFixed(1)}|checksum=${quant.hashChecksum}|json=0`);
+
+  const endMem = memorySnapshot();
+  const totalLogical = logical.ops + tokens.ops + collisions.ops + zeta.ops + quant.cycles;
+  const elapsedMs = nowMs() - totalStarted;
+  rows.push(`LOGICSTRESSPROCESS|host_processes_used=1|child_process_spawns=0|external_model_calls=0|rss_start_mb=${mb(startMem.rss)}|rss_peak_mb=${mb(peakRss)}|rss_end_mb=${mb(endMem.rss)}|heap_end_mb=${mb(endMem.heapUsed)}|logical_ops_total=${totalLogical}|json=0`);
+  rows.push(`LOGICSTRESSVERDICT|status=PASS|limits=logical-only-no-live-mutation-no-per-agent-files|physical_claim=bounded-process-envelope-not-infinite-memory|elapsed_anchor_ms=${Math.round(elapsedMs)}|json=0`);
+  return rows;
+}
+
+const isMain = process.argv[1] && fileURLToPath(import.meta.url) === resolve(process.argv[1]);
+
+if (isMain) {
+  const args = process.argv.slice(2);
+  if (!args.includes('--run')) {
+    process.stdout.write(`${DEFINITION_ROWS.join('\n')}\n`);
+  } else {
+    process.stdout.write(`${runExtreme({
+      seconds: parseNumber(args, '--seconds', DEFAULT_SECONDS),
+      batch: Math.floor(parseNumber(args, '--batch', DEFAULT_BATCH)),
+      quantMB: parseNumber(args, '--quant-mb', DEFAULT_QUANT_MB),
+    }).join('\n')}\n`);
+  }
+}

tools/behcs/logical-extreme-stress.mjs.sha256

@@ -0,0 +1 @@
+FF51DAEC3DFCF088A7FBDA71907CBC972C574747556A951D5032A45A1406884E  logical-extreme-stress.mjs