liris: add eight byte host process upgrade

docs/LIRIS-EIGHT-BYTE-HOST-PROCESS-UPGRADE-2026-06-14.hbp

@@ -0,0 +1,9 @@
+HOSTUPGRADECANONHDR|doc=LIRIS-EIGHT-BYTE-HOST-PROCESS-UPGRADE-2026-06-14|date=2026-06-14|owner=liris|scope=v8-real-8-byte-host-process-upgrade-and-real-graph-math|tag=DESCRIPTOR-ONLY|json=0
+HOSTUPGRADECANONPOLICY|replace=node-per-agent-runtime-conductor-where-proven|keep=node-for-repo-verifier-build-test-static-provider-adapter-until-host-replacement-proof|not_replace=provider-brain-compute|provider_terms_apply=1|json=0
+HOSTUPGRADECANONMATH|bh_index=sector*3072+lane*1024+glyph|sector=sha256-name-mod113|lane=sha256-name-mod3|glyph=sha256-name-mod1024|cylinder=phase-bh_index-mod6+ring-floor-bh_index-div6|distance=abs-delta-bh_index-not-3d-euclidean|json=0
+HOSTUPGRADECANONPRIME|real_tiers=p+p2+p3|folded_tiers=p5+p7+p9-to-pk|p5_materialized=0|status=PROPOSAL_UNTIL_DISTINCT_RANGE_TAG_AND_TEST|json=0
+HOSTUPGRADECANONSYSTEMS|systems=LOGICAL-WAVE+FROZEN-BRAIN+REAL-FREE|rule_of_three=hookwall+gnn+shannon|yin_yang=logical-circle+real-square|mod6_integrity=necessary-not-sufficient|json=0
+HOSTUPGRADECANONROUTES|route_types=device-to-hardware+agent-to-agent+agent-to-device+agent-to-human+human-to-agent+provider-router|all_routes=descriptor-first|device_effects=operator-cosign|provider_router=gated|json=0
+HOSTUPGRADECANONGATES|free_provider_compute_claim=0|billing_bypass=0|global_node_removed_today=0|process_launch=0|usb_write=0|radio_bypass=0|cadence_200ns=end-to-end-benchmark-required|json=0
+HOSTUPGRADECANONTOOL|tool=tools/behcs/eight-byte-host-process-upgrade.mjs|test=tests/eight-byte-host-process-upgrade.unit.test.mjs|catalog=tools/behcs/fabric-agent-preload-catalog.mjs|json=0
+HOSTUPGRADECANONFTR|state=SEALED-EIGHT-BYTE-HOST-PROCESS-UPGRADE|next=use-before-claiming-node-replacement-real-prime-graphs-or-phone-world-model-upgrades|json=0

docs/LIRIS-EIGHT-BYTE-HOST-PROCESS-UPGRADE-2026-06-14.hbp.sha256

@@ -0,0 +1 @@
+E0774C197A4C08AE8D48B080726A318EEABAFE3BEDF71336FAEB31FC0A017E64  LIRIS-EIGHT-BYTE-HOST-PROCESS-UPGRADE-2026-06-14.hbp

tests/agent-cost-layer-boundary.unit.test.mjs

@@ -31,6 +31,8 @@ test('claim classifier separates message-size confusion from host-handle doctrin
   assert.equal(classifyClaim({ claim: '8 byte portal handle' }), 'HOST_HANDLE_DESCRIPTOR_ONLY');
   assert.equal(classifyClaim({ claim: 'message payload context tokens' }), 'MESSAGE_PAYLOAD_VARIABLE');
   assert.equal(classifyClaim({ claim: 'free unlimited Google model compute bypass' }), 'REJECT_FREE_EXTERNAL_COMPUTE_CLAIM');
+  assert.equal(classifyClaim({ claim: '8 byte host gets gratis Claude tokens' }), 'REJECT_FREE_EXTERNAL_COMPUTE_CLAIM');
+  assert.equal(classifyClaim({ claim: 'zero-cost GPT API credits' }), 'REJECT_FREE_EXTERNAL_COMPUTE_CLAIM');
 });
 
 test('hostile layers emit HBP-only rows and stay non-executing', () => {

tests/agent-cost-layer-boundary.unit.test.mjs.sha256

@@ -1 +1 @@
-F9CEF44B0A9F813942AB761D8F2AA87136BA5E6DB1905CA1C5E5B10F029766E5  agent-cost-layer-boundary.unit.test.mjs
+1C8DA8AE1F5ADF4C8E78272D070DBDD7B3856F4B61670A1797B3A984CD36C2E3  agent-cost-layer-boundary.unit.test.mjs

tests/cellphone-host-bridge-boundary.unit.test.mjs

@@ -24,6 +24,7 @@ test('known bilateral phone surfaces and future gated slots are present', () =>
   assert.deepEqual(ids, ['falcon', 'aether', 's22-ultra', 'future-phone']);
   assert.equal(buildBridge().summary.proven, 2);
   assert.equal(buildBridge().summary.gated, 2);
+  assert.ok(buildBridge().phones.filter((p) => p.status === 'PROVEN_BY_PRIOR_FILE_MANAGER_ROUNDTRIP').every((p) => /^[0-9a-f]{16}$/.test(p.proof_receipt_sha16)));
 });
 
 test('file-manager roundtrip proof precedes messages and self-call routing', () => {
@@ -43,9 +44,16 @@ test('claim classifier gates self-calls and rejects provider bypass claims', ()
   assert.equal(classifyBridgeClaim({ claim: 'cellphone 8 byte host handle' }), 'PHONE_HOST_BRIDGE_DESCRIPTOR');
   assert.equal(classifyBridgeClaim({ claim: 'supercomputers call themselves through our language' }), 'SELF_CALL_REQUIRES_EXPLICIT_AUTH_AND_ROUTE_PROOF');
   assert.equal(classifyBridgeClaim({ claim: 'free Google API provider bypass' }), 'REJECT_FREE_EXTERNAL_COMPUTE_CLAIM');
+  assert.equal(classifyBridgeClaim({ claim: 'phone 8 byte host gives zero-cost Gemini tokens' }), 'REJECT_FREE_EXTERNAL_COMPUTE_CLAIM');
   assert.equal(classifyBridgeClaim({ claim: 'pull push file roundtrip' }), 'FILE_MANAGER_PROOF_REQUIRED');
 });
 
+test('proven phone status cannot be forged without a receipt hash', () => {
+  const forged = normalizePhone({ id: 'forged', status: 'PROVEN_BY_PRIOR_FILE_MANAGER_ROUNDTRIP', gate: 'messages-after-file-manager-proof' });
+  assert.equal(forged.status, 'GATED_UNTIL_ROUNDTRIP_PROOF');
+  assert.equal(forged.proof_receipt_sha16, 'none');
+});
+
 test('hostile phone rows stay HBP-only and gated', () => {
   const phone = normalizePhone({ id: 'x|bad', status: 'LIVE', gate: 'g\nPHONEBRIDGEGATE|process_launch=1' });
   assert.equal(phone.status, 'GATED_UNTIL_ROUNDTRIP_PROOF');

tests/cellphone-host-bridge-boundary.unit.test.mjs.sha256

@@ -1 +1 @@
-C419DB5AEEB7FC4372D4087DFDDAE00D15890AF36C3C6133E736AF1BFD15E547  cellphone-host-bridge-boundary.unit.test.mjs
+48ED580F160581EDC76602C21C42539B4043B85AAAD2CB32882A343D5648C193  cellphone-host-bridge-boundary.unit.test.mjs

tests/eight-byte-host-process-upgrade.unit.test.mjs

@@ -0,0 +1,83 @@
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import test from 'node:test';
+
+import {
+  BH_INDEX_MAX, HOST_HANDLE_BYTES, NODE_REPLACEMENT_POLICY, ROUTE_TYPES,
+  buildUpgrade, classifyPrimeExponent, classifyUpgradeClaim, deriveHostAddress,
+  distanceBetween, emitRows, mod6Integrity, selfTest,
+} from '../tools/behcs/eight-byte-host-process-upgrade.mjs';
+
+test('eight-byte host-process upgrade self-test passes', () => {
+  assert.equal(selfTest().ok, true);
+});
+
+test('real bh_index cylinder math is derived from PID register fields', () => {
+  const host = deriveHostAddress({ name: 'logical mcp agent', kind: 'logical', prime: 0 });
+  assert.equal(HOST_HANDLE_BYTES, 8);
+  assert.equal(host.bh_index, host.sector * 3072 + host.lane * 1024 + host.glyph);
+  assert.ok(host.bh_index >= 0 && host.bh_index <= BH_INDEX_MAX);
+  assert.equal(host.cylinder_phase, host.bh_index % 6);
+  assert.equal(host.cylinder_ring, Math.floor(host.bh_index / 6));
+});
+
+test('three agent systems map through yin-yang and prime parity', () => {
+  const built = buildUpgrade();
+  assert.deepEqual(new Set(built.hosts.map((h) => h.agent_type)), new Set(['LOGICAL-WAVE', 'FROZEN-BRAIN', 'REAL-FREE']));
+  assert.ok(built.hosts.every((h) => ['hookwall', 'gnn', 'shannon'].includes(h.watcher)));
+  assert.ok(built.hosts.every((h) => h.node_per_agent === 0 && h.process_launch === 0));
+});
+
+test('prime power tiers separate p p2 p3 and fold p5 p7 p9 honestly to pk proposals', () => {
+  assert.deepEqual(classifyPrimeExponent(1), { exponent: 1, tier: 'prime', materialized: true, status: 'REAL_DISTINCT' });
+  assert.equal(classifyPrimeExponent(2).tier, 'p2');
+  assert.equal(classifyPrimeExponent(3).tier, 'p3');
+  for (const exponent of [5, 7, 9]) {
+    const tier = classifyPrimeExponent(exponent);
+    assert.equal(tier.tier, 'pk');
+    assert.equal(tier.materialized, false);
+    assert.equal(tier.status, 'PROPOSAL_FOLDED_TO_PK');
+  }
+});
+
+test('PID distance is abs delta bh_index, not fake 3D euclidean distance', () => {
+  const near = distanceBetween({ bh_index: 1000, sha16: 'aaaaaaaaaaaaaaaa' }, { bh_index: 2000, sha16: 'bbbbbbbbbbbbbbbb' });
+  const regional = distanceBetween({ bh_index: 1000, sha16: 'aaaaaaaaaaaaaaaa' }, { bh_index: 100000, sha16: 'bbbbbbbbbbbbbbbb' });
+  assert.equal(near.bucket, 'near4096');
+  assert.equal(regional.bucket, 'regional131072');
+  assert.equal(regional.metric, 'abs-delta-bh-index-not-euclidean-3d');
+});
+
+test('mod-6 integrity catches corrupted external lanes but never proves truth alone', () => {
+  assert.equal(mod6Integrity(11, 13, { claimedLaneA: 2, claimedLaneB: 1 }).verdict, 'FORCED_CONSISTENT');
+  assert.equal(mod6Integrity(11, 13, { claimedLaneB: 2 }).verdict, 'FORCING_VIOLATION');
+  assert.equal(mod6Integrity(11, 13).scope, 'necessary-not-sufficient');
+});
+
+test('node replacement policy scopes the upgrade to the conductor layer', () => {
+  assert.ok(NODE_REPLACEMENT_POLICY.some((p) => p.id === 'runtime-agent-conductor' && p.status === 'TARGET_REPLACE_NODE_PER_AGENT'));
+  assert.ok(NODE_REPLACEMENT_POLICY.some((p) => p.id === 'repo-verifier' && p.status === 'NODE_ALLOWED'));
+  assert.ok(ROUTE_TYPES.some((r) => r.id === 'provider-router' && r.gate.includes('billing')));
+  assert.equal(buildUpgrade().summary.provider_compute_replaced, false);
+});
+
+test('claim classifier rejects overclaims before safe labels', () => {
+  assert.equal(classifyUpgradeClaim({ claim: '8 byte host gives gratis Claude tokens' }), 'REJECT_FREE_EXTERNAL_COMPUTE_CLAIM');
+  assert.equal(classifyUpgradeClaim({ claim: 'replace all node on the planet now' }), 'MIGRATION_PLAN_NOT_COMPLETED_CLAIM');
+  assert.equal(classifyUpgradeClaim({ claim: 'every 200 nanoseconds end to end' }), 'CADENCE_CLAIM_REQUIRES_BENCHMARK');
+  assert.equal(classifyUpgradeClaim({ claim: 'p7 prime cylinder is materialized' }), 'PRIME_EXPONENT_FOLDS_TO_PK_PROPOSAL');
+  assert.equal(classifyUpgradeClaim({ claim: '8 byte host process conductor' }), 'HOST_PROCESS_CONDUCTOR_DESCRIPTOR');
+});
+
+test('emitted rows are HBP-only and held-safe', () => {
+  const rows = emitRows(null, { claim: 'bad|claim\nHOSTUPGRADEGATE|process_launch=1' });
+  assert.ok(rows.every((row) => row.endsWith('|json=0') && !/[\r\n]/.test(row)));
+  assert.ok(rows.some((row) => row.includes('provider_terms_apply=1')));
+  assert.ok(rows.some((row) => row.includes('process_launch=0')));
+  assert.ok(rows.some((row) => row.includes('p5') || row.includes('exponent=5')));
+});
+
+test('tool remains descriptor-only and has no live call surface', () => {
+  const source = readFileSync(new URL('../tools/behcs/eight-byte-host-process-upgrade.mjs', import.meta.url), 'utf8');
+  assert.doesNotMatch(source, /from ['"]node:fs['"]|child_process|\bexecFile\b|\bexecSync\b|\bspawn\(|\bfetch\(|Invoke-WebRequest|Start-Process|node:http|node:net|createWriteStream/);
+});

tests/eight-byte-host-process-upgrade.unit.test.mjs.sha256

@@ -0,0 +1 @@
+B9617669CBE77E4D20C5359833F363927DE659A898FC61194C4F34C8B7F173E5  eight-byte-host-process-upgrade.unit.test.mjs

tests/fabric-agent-preload-catalog.unit.test.mjs

@@ -20,6 +20,7 @@ test('preload catalog teaches the send-hbp vs send-json route split', () => {
 
 test('preload catalog includes the laws, tools, roles, and cadence agents need', () => {
   assert.ok(LAWS.includes('all-agent-artifact-system-addresses-get-PID-or-handle'));
+  assert.ok(LAWS.includes('8-byte-host-process-replaces-node-per-agent-only-where-proven'));
   assert.ok(LAWS.includes('quants-are-address-and-evidence-classes-not-raw-material'));
   assert.ok(TOOLS.some((t) => t.id === 'pixel-room-handle'));
   assert.ok(TOOLS.some((t) => t.id === 'github-live-pid-reconcile'));
@@ -35,6 +36,7 @@ test('preload catalog includes the laws, tools, roles, and cadence agents need',
   assert.ok(TOOLS.some((t) => t.id === 'pid-emitter-cost-envelope' && t.gate.includes('physics_break-0')));
   assert.ok(TOOLS.some((t) => t.id === 'cellphone-host-bridge-boundary' && t.gate.includes('radio_bypass-0')));
   assert.ok(TOOLS.some((t) => t.id === 'frozen-slice-city-signal-lifecycle' && t.gate.includes('measured_200ns-0')));
+  assert.ok(TOOLS.some((t) => t.id === 'eight-byte-host-process-upgrade' && t.gate.includes('provider_compute_replaced-0')));
   assert.ok(ROLES.some((r) => r.id === 'flywheel' && r.must_do.includes('compare-to-acer-local-truth')));
   assert.ok(WORKFLOW.join('-').includes('memory-index-plan'));
   assert.equal(toolById('token-cube-catalog-binder').gate, 'mint-write-live-DEFER_TO_OPERATOR');

tests/fabric-agent-preload-catalog.unit.test.mjs.sha256

@@ -1 +1 @@
-6AF209FB14E4F287E9C7676F73AEDC005801E7880593DD212CF0F5DD1BE12A5D  fabric-agent-preload-catalog.unit.test.mjs
+AEECC42FFBF57603B927CA292D4672E0B166CE3F73E44B5207F01B77A441FF89  fabric-agent-preload-catalog.unit.test.mjs

tests/frozen-slice-city-signal-lifecycle.unit.test.mjs

@@ -49,6 +49,7 @@ test('claim classifier handles 200ns, forcing providers, free compute, and froze
   assert.equal(classifyLifecycleClaim({ claim: 'updates every 200 nano seconds' }), 'CADENCE_CLAIM_REQUIRES_BENCHMARK');
   assert.equal(classifyLifecycleClaim({ claim: 'forcing Anthropic model to decide' }), 'ROUTED_REQUEST_NOT_UNAUTHORIZED_CONTROL');
   assert.equal(classifyLifecycleClaim({ claim: 'free OpenAI api bypass' }), 'REJECT_FREE_EXTERNAL_COMPUTE_CLAIM');
+  assert.equal(classifyLifecycleClaim({ claim: 'frozen slice city gives gratis GPT tokens' }), 'REJECT_FREE_EXTERNAL_COMPUTE_CLAIM');
   assert.equal(classifyLifecycleClaim({ claim: 'frozen slice city' }), 'FROZEN_SLICE_CITY_DESCRIPTOR');
   assert.equal(classifyLifecycleClaim({ claim: 'GNN Shannon white room attack' }), 'WATCHER_REVIEW_PROPOSAL_NOT_PROOF');
 });

tests/frozen-slice-city-signal-lifecycle.unit.test.mjs.sha256

@@ -1 +1 @@
-F229ABA0797DC1D227BD249ACB415F7FFABFAAC81B27A187DAC69F180DE3613A  frozen-slice-city-signal-lifecycle.unit.test.mjs
+2EF50CB52B0CC99D060EC59684EAE65E1C01CA423A8D60368FB971B4DEF6144E  frozen-slice-city-signal-lifecycle.unit.test.mjs

tests/pid-emitter-cost-envelope.unit.test.mjs

@@ -41,6 +41,7 @@ test('real cost envelope includes emitter spin, planning, cube templating, paylo
 test('claim classifier blocks literal physics and provider bypass claims', () => {
   assert.equal(classifyCostClaim({ claim: 'breaks physics kind of feel' }), 'METAPHOR_ONLY_REJECT_LITERAL_PHYSICS_BREAK');
   assert.equal(classifyCostClaim({ claim: 'free unlimited OpenAI supercomputer compute bypass' }), 'REJECT_FREE_EXTERNAL_COMPUTE_CLAIM');
+  assert.equal(classifyCostClaim({ claim: '8 byte host process gives zero-cost Gemini tokens' }), 'REJECT_FREE_EXTERNAL_COMPUTE_CLAIM');
   assert.equal(classifyCostClaim({ claim: 'O(1) host handle addressing' }), 'O1_SHAPED_ADDRESSING_NOT_TOTAL_WORK');
   assert.equal(classifyCostClaim({ claim: '8 byte host process' }), 'HOST_HANDLE_DESCRIPTOR_ONLY');
 });

tests/pid-emitter-cost-envelope.unit.test.mjs.sha256

@@ -1 +1 @@
-9BD4983640AD4CE9BE19A6FE10450374980C1BE6DBC577C321E4DEBB1CA43C3D  pid-emitter-cost-envelope.unit.test.mjs
+56777D57D8EC8A210EAA1FD1F432B596EA97A744EE7F33406E07E587C3D2C184  pid-emitter-cost-envelope.unit.test.mjs

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

@@ -95,6 +95,7 @@ const sealedFiles = [
   'docs/LIRIS-PID-EMITTER-COST-ENVELOPE-2026-06-14.hbp',
   'docs/LIRIS-CELLPHONE-HOST-BRIDGE-BOUNDARY-2026-06-14.hbp',
   'docs/LIRIS-FROZEN-SLICE-CITY-SIGNAL-LIFECYCLE-2026-06-14.hbp',
+  'docs/LIRIS-EIGHT-BYTE-HOST-PROCESS-UPGRADE-2026-06-14.hbp',
   'docs/ACER-SLICE-ENGINE-LIVE-CRANK-RECEIPT-2026-06-13.hbp',
   'docs/LIRIS-ROUTE-HEALTH-BASELINE-2026-06-13.hbp',
   'docs/ACER-ROUTE-HEALTH-CROSS-VANTAGE-2026-06-13.hbp',
@@ -241,6 +242,7 @@ const sealedFiles = [
   'tools/behcs/pid-emitter-cost-envelope.mjs',
   'tools/behcs/cellphone-host-bridge-boundary.mjs',
   'tools/behcs/frozen-slice-city-signal-lifecycle.mjs',
+  'tools/behcs/eight-byte-host-process-upgrade.mjs',
   'tools/behcs/logical-extreme-stress.mjs',
   'tools/behcs/logical-stress-cube-feed.mjs',
   'tools/behcs/brown-hilbert-expansion-stress.mjs',
@@ -281,6 +283,7 @@ const sealedFiles = [
   'tests/pid-emitter-cost-envelope.unit.test.mjs',
   'tests/cellphone-host-bridge-boundary.unit.test.mjs',
   'tests/frozen-slice-city-signal-lifecycle.unit.test.mjs',
+  'tests/eight-byte-host-process-upgrade.unit.test.mjs',
   'tests/logical-extreme-stress.unit.test.mjs',
   'tests/logical-stress-cube-feed.unit.test.mjs',
   'tests/brown-hilbert-expansion-stress.unit.test.mjs',

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

@@ -1 +1 @@
-6E877FCED2D38794DD749DA6258122AE77028A75C25A91CD6321ABB81C7983D4  supervisor-collision-router.system.test.mjs
+DD76DA203B8D65AA30696D93603D37DA34C1251048290E90E3C908646DD8CE4E  supervisor-collision-router.system.test.mjs

tests/triad-host-router-gulp-pipeline.unit.test.mjs

@@ -43,6 +43,8 @@ test('provider and CLI routers are descriptors with authorization gates', () =>
   assert.ok(built.routers.some((r) => r.id === 'openai' && r.gate.includes('billing-apply')));
   assert.ok(built.routers.some((r) => r.id === 'claude' && r.gate.includes('terms-and-quota')));
   assert.ok(built.routers.some((r) => r.id === 'registered-cli' && r.status === 'GATED'));
+  assert.equal(normalizeRouter({ id: 'openai', kind: 'provider-router', status: 'REGISTERED_DESCRIPTOR' }).status, 'GATED');
+  assert.equal(normalizeRouter({ id: 'claude', kind: 'provider-router', status: 'REGISTERED_DESCRIPTOR' }).status, 'GATED');
 });
 
 test('hostile router input is gated and HBP-only', () => {

tests/triad-host-router-gulp-pipeline.unit.test.mjs.sha256

@@ -1 +1 @@
-0F558EDDED0CC7D381B7C3538DB63A27FB59858ED3FA1E811FA4BA0D5B0197AB  triad-host-router-gulp-pipeline.unit.test.mjs
+BFC16FAC27BC2EA7B51B01EB31B3207588217B854252186C5422F8F6D856522F  triad-host-router-gulp-pipeline.unit.test.mjs

tools/behcs/agent-cost-layer-boundary.mjs

@@ -60,6 +60,8 @@ export const COST_LAYERS = Object.freeze([
 const sha16 = (text) => createHash('sha256').update(String(text), 'utf8').digest('hex').slice(0, 16);
 const isObj = (x) => x !== null && typeof x === 'object';
 const safe = (x) => String(x ?? '').replace(/[|\r\n]/g, '_').replace(/[^A-Za-z0-9._:/+@=-]+/g, '-').replace(/^-|-$/g, '') || 'empty';
+const FREE_COMPUTE_RE = /\b(free|bypass|unlimited|no-cost|gratis|zero-cost|zero-token|tokens?|credits?|billing|quota)\b/;
+const PROVIDER_RE = /\b(model|compute|api|provider|openai|google|gemini|anthropic|claude|llm|gpt|supercomputer)\b/;
 const prop = (obj, key, fallback = '') => {
   try { return isObj(obj) ? obj[key] : fallback; } catch { return fallback; }
 };
@@ -104,8 +106,8 @@ export function normalizeLayer(input = {}) {
 
 export function classifyClaim(input = {}) {
   const claim = safe(isObj(input) ? prop(input, 'claim', '') : input).toLowerCase();
+  if (FREE_COMPUTE_RE.test(claim) && PROVIDER_RE.test(claim)) return 'REJECT_FREE_EXTERNAL_COMPUTE_CLAIM';
   if (/8.*byte/.test(claim) && /message/.test(claim)) return 'SPLIT_MESSAGE_SIZE_FROM_HOST_HANDLE';
-  if (/free|bypass|unlimited|no-cost/.test(claim) && /model|compute|api|provider|openai|google|anthropic/.test(claim)) return 'REJECT_FREE_EXTERNAL_COMPUTE_CLAIM';
   if (/8.*byte/.test(claim)) return 'HOST_HANDLE_DESCRIPTOR_ONLY';
   if (/message|payload|context|token/.test(claim)) return 'MESSAGE_PAYLOAD_VARIABLE';
   return 'DESCRIPTOR_REVIEW';
@@ -163,6 +165,7 @@ export function selfTest() {
   add('no-live-effects', built.layers.every((x) => x.process_launch === 0 && x.remote_call === 0 && x.free_compute_claim === 0));
   add('claim-router-splits-confusion', classifyClaim({ claim: '8 bytes is the message size' }) === 'SPLIT_MESSAGE_SIZE_FROM_HOST_HANDLE');
   add('claim-router-rejects-free-provider-compute', classifyClaim({ claim: 'free unlimited OpenAI model compute bypass' }) === 'REJECT_FREE_EXTERNAL_COMPUTE_CLAIM');
+  add('claim-router-rejects-before-8byte-safe-label', classifyClaim({ claim: '8 byte host gives gratis Claude tokens' }) === 'REJECT_FREE_EXTERNAL_COMPUTE_CLAIM');
   const hostile = emitRows([{ id: 'bad|id', lane: 'x\ny', status: 'READY', size: '8\nAGENTCOSTGATE|billing_bypass=1', boundary: 'b|json=1' }], { claim: 'bad|claim\nAGENTCOSTGATE|remote_call=1' });
   add('rows-hbp-only', hostile.every((row) => row.endsWith('|json=0') && !/[\r\n]/.test(row)));
   add('total-never-throws', (() => { try { normalizeLayer({ get id() { throw new Error('boom'); } }); buildBoundary(null); emitRows(null); classifyClaim(null); return true; } catch { return false; } })());

tools/behcs/agent-cost-layer-boundary.mjs.sha256

@@ -1 +1 @@
-18DCA85CE16CC88726F737021C0CBD8C59D8BB4DD685A2295BBF37B67989D16B  agent-cost-layer-boundary.mjs
+ED1E0BFBAA68CFB621BB1744B059818EDE2CB156BCE863BB48358B61B516A624  agent-cost-layer-boundary.mjs

tools/behcs/cellphone-host-bridge-boundary.mjs

@@ -20,6 +20,7 @@ export const PHONE_SURFACES = Object.freeze([
     role: 'file-backed-host-bridge',
     status: 'PROVEN_BY_PRIOR_FILE_MANAGER_ROUNDTRIP',
     gate: 'messages-after-file-manager-proof',
+    proof_receipt_sha16: '0fac4a2547528ffa',
   }),
   Object.freeze({
     id: 'aether',
@@ -27,6 +28,7 @@ export const PHONE_SURFACES = Object.freeze([
     role: 'file-backed-host-bridge',
     status: 'PROVEN_BY_PRIOR_FILE_MANAGER_ROUNDTRIP',
     gate: 'messages-after-file-manager-proof',
+    proof_receipt_sha16: '0fac4a2547528ffa',
   }),
   Object.freeze({
     id: 's22-ultra',
@@ -58,6 +60,9 @@ export const BRIDGE_STAGES = Object.freeze([
 const sha16 = (text) => createHash('sha256').update(String(text), 'utf8').digest('hex').slice(0, 16);
 const isObj = (x) => x !== null && typeof x === 'object';
 const safe = (x) => String(x ?? '').replace(/[|\r\n]/g, '_').replace(/[^A-Za-z0-9._:/+@=()-]+/g, '-').replace(/^-|-$/g, '') || 'empty';
+const SHA16_RE = /^[0-9a-f]{16}$/;
+const FREE_COMPUTE_RE = /\b(free|bypass|unlimited|no-cost|gratis|zero-cost|zero-token|tokens?|credits?|billing|quota)\b/;
+const PROVIDER_RE = /\b(provider|openai|google|gemini|anthropic|claude|supercomputer|api|llm|gpt|model|compute)\b/;
 const prop = (obj, key, fallback = '') => {
   try { return isObj(obj) ? obj[key] : fallback; } catch { return fallback; }
 };
@@ -68,7 +73,11 @@ export function normalizePhone(input = {}) {
     const device_class = safe(prop(input, 'device_class', 'cellphone'));
     const role = safe(prop(input, 'role', 'file-backed-host-bridge'));
     const rawStatus = safe(prop(input, 'status', 'GATED_UNTIL_ROUNDTRIP_PROOF')).toUpperCase();
-    const status = ['PROVEN_BY_PRIOR_FILE_MANAGER_ROUNDTRIP', 'GATED_UNTIL_ROUNDTRIP_PROOF'].includes(rawStatus) ? rawStatus : 'GATED_UNTIL_ROUNDTRIP_PROOF';
+    const proof_receipt_sha16 = safe(prop(input, 'proof_receipt_sha16', 'none')).toLowerCase();
+    const hasProof = SHA16_RE.test(proof_receipt_sha16);
+    const status = rawStatus === 'PROVEN_BY_PRIOR_FILE_MANAGER_ROUNDTRIP' && hasProof
+      ? 'PROVEN_BY_PRIOR_FILE_MANAGER_ROUNDTRIP'
+      : 'GATED_UNTIL_ROUNDTRIP_PROOF';
     const gate = safe(prop(input, 'gate', 'pull-push-hash-proof-before-host-messages'));
     return Object.freeze({
       id,
@@ -76,8 +85,9 @@ export function normalizePhone(input = {}) {
       role,
       status,
       gate,
+      proof_receipt_sha16: hasProof ? proof_receipt_sha16 : 'none',
       host_handle_bytes: HOST_HANDLE_BYTES,
-      bridge_sha16: sha16([id, device_class, role, status, gate].join('|')),
+      bridge_sha16: sha16([id, device_class, role, status, gate, hasProof ? proof_receipt_sha16 : 'none'].join('|')),
       process_launch: 0,
       radio_bypass: 0,
       provider_bypass: 0,
@@ -90,6 +100,7 @@ export function normalizePhone(input = {}) {
       role: 'invalid',
       status: 'GATED_UNTIL_ROUNDTRIP_PROOF',
       gate: 'normalize-threw-held',
+      proof_receipt_sha16: 'none',
       host_handle_bytes: HOST_HANDLE_BYTES,
       bridge_sha16: sha16('invalid'),
       process_launch: 0,
@@ -102,7 +113,7 @@ export function normalizePhone(input = {}) {
 
 export function classifyBridgeClaim(input = {}) {
   const claim = safe(isObj(input) ? prop(input, 'claim', '') : input).toLowerCase();
-  if (/free|bypass|unlimited|no-cost/.test(claim) && /provider|openai|google|anthropic|supercomputer|api/.test(claim)) return 'REJECT_FREE_EXTERNAL_COMPUTE_CLAIM';
+  if (FREE_COMPUTE_RE.test(claim) && PROVIDER_RE.test(claim)) return 'REJECT_FREE_EXTERNAL_COMPUTE_CLAIM';
   if (/self.*call|call.*itself|call.*themselves|themselves.*call/.test(claim)) return 'SELF_CALL_REQUIRES_EXPLICIT_AUTH_AND_ROUTE_PROOF';
   if (/cellphone|phone/.test(claim) && /8.*byte/.test(claim)) return 'PHONE_HOST_BRIDGE_DESCRIPTOR';
   if (/file|roundtrip|pull|push/.test(claim)) return 'FILE_MANAGER_PROOF_REQUIRED';
@@ -134,7 +145,7 @@ export function emitRows(input = PHONE_SURFACES, opts = {}) {
       `PHONEBRIDGESTAGES|stages=${BRIDGE_STAGES.join('+')}|self_call=requires-auth-and-route-proof|file_manager_first=1|json=0`,
     ];
     for (const phone of built.phones) {
-      rows.push(`PHONEBRIDGE|id=${phone.id}|device_class=${phone.device_class}|role=${phone.role}|status=${phone.status}|gate=${phone.gate}|bridge_sha16=${phone.bridge_sha16}|host_handle_bytes=${phone.host_handle_bytes}|process_launch=0|provider_bypass=0|radio_bypass=0|self_call_authorized=0|json=0`);
+      rows.push(`PHONEBRIDGE|id=${phone.id}|device_class=${phone.device_class}|role=${phone.role}|status=${phone.status}|gate=${phone.gate}|proof_receipt_sha16=${phone.proof_receipt_sha16}|bridge_sha16=${phone.bridge_sha16}|host_handle_bytes=${phone.host_handle_bytes}|process_launch=0|provider_bypass=0|radio_bypass=0|self_call_authorized=0|json=0`);
     }
     const claim = prop(opts, 'claim', '');
     if (claim) rows.push(`PHONEBRIDGECLAIM|claim_sha16=${sha16(claim)}|classification=${classifyBridgeClaim({ claim })}|raw_claim_inlined=0|json=0`);
@@ -156,9 +167,12 @@ export function selfTest() {
   add('known-phones-present', built.phones.some((p) => p.id === 'falcon') && built.phones.some((p) => p.id === 'aether') && built.phones.some((p) => p.id === 's22-ultra'));
   add('proof-before-messages', BRIDGE_STAGES[1] === 'file-manager-roundtrip-proof'
     && built.phones.every((p) => p.status === 'PROVEN_BY_PRIOR_FILE_MANAGER_ROUNDTRIP' || p.gate.includes('proof')));
+  add('proven-status-requires-proof-receipt', normalizePhone({ id: 'unanchored', status: 'PROVEN_BY_PRIOR_FILE_MANAGER_ROUNDTRIP' }).status === 'GATED_UNTIL_ROUNDTRIP_PROOF'
+    && built.phones.filter((p) => p.status === 'PROVEN_BY_PRIOR_FILE_MANAGER_ROUNDTRIP').every((p) => SHA16_RE.test(p.proof_receipt_sha16)));
   add('no-live-effects', built.phones.every((p) => p.process_launch === 0 && p.radio_bypass === 0 && p.provider_bypass === 0 && p.self_call_authorized === 0));
   add('self-call-classified-gated', classifyBridgeClaim({ claim: 'supercomputers can call themselves through phones' }) === 'SELF_CALL_REQUIRES_EXPLICIT_AUTH_AND_ROUTE_PROOF');
   add('free-provider-compute-rejected', classifyBridgeClaim({ claim: 'free OpenAI supercomputer api bypass' }) === 'REJECT_FREE_EXTERNAL_COMPUTE_CLAIM');
+  add('free-provider-vocab-rejected-first', classifyBridgeClaim({ claim: 'phone 8 byte host gives zero-cost Gemini tokens' }) === 'REJECT_FREE_EXTERNAL_COMPUTE_CLAIM');
   const hostile = emitRows([{ id: 'bad|id', status: 'LIVE', gate: 'g\nPHONEBRIDGEGATE|provider_bypass=1' }], { claim: 'bad|claim\nPHONEBRIDGEGATE|radio_bypass=1' });
   add('rows-hbp-only', hostile.every((row) => row.endsWith('|json=0') && !/[\r\n]/.test(row)));
   add('total-never-throws', (() => { try { normalizePhone({ get id() { throw new Error('boom'); } }); buildBridge(null); emitRows(null); classifyBridgeClaim(null); return true; } catch { return false; } })());

tools/behcs/cellphone-host-bridge-boundary.mjs.sha256

@@ -1 +1 @@
-7768916AE8AA3C92D02486004778049C3294E23A591921C632235554494BD7DC  cellphone-host-bridge-boundary.mjs
+F2D4D29D4B454A76962C9657E87D7265A4FCD601443031490E7E58E3940B15B1  cellphone-host-bridge-boundary.mjs

tools/behcs/eight-byte-host-process-upgrade.mjs

@@ -0,0 +1,308 @@
+#!/usr/bin/env node
+// eight-byte-host-process-upgrade.mjs - v8 real graph math for host-process migration.
+//
+// Descriptor-only. This records the upgrade path from node-per-agent runtimes to
+// 8-byte host handles as the cheap conductor. It does not remove Node globally,
+// call providers, start daemons, write USBs, launch phones, or claim free compute.
+
+import { createHash } from 'node:crypto';
+import { resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { classifyAgentType, mintPid } from './github-pid-register.mjs';
+import { classifyBhIndex } from './token-cube-catalog-binder.mjs';
+import { zetaTransition } from './zeta-quant.mjs';
+
+export const HOST_UPGRADE_ID = 'eight-byte-host-process-upgrade.v1';
+export const HOST_HANDLE_BYTES = 8;
+export const BH_SECTORS = 113;
+export const BH_LANES = 3;
+export const BH_GLYPHS = 1024;
+export const BH_INDEX_MAX = (BH_SECTORS - 1) * BH_LANES * BH_GLYPHS + (BH_LANES - 1) * BH_GLYPHS + (BH_GLYPHS - 1);
+
+export const RULE_OF_THREE_WATCHERS = Object.freeze(['hookwall', 'gnn', 'shannon']);
+export const SYSTEM_TYPES = Object.freeze(['LOGICAL-WAVE', 'FROZEN-BRAIN', 'REAL-FREE']);
+
+export const NODE_REPLACEMENT_POLICY = Object.freeze([
+  Object.freeze({
+    id: 'runtime-agent-conductor',
+    status: 'TARGET_REPLACE_NODE_PER_AGENT',
+    rule: 'use-8-byte-host-handle-plus-file-backed-room-where-proven',
+  }),
+  Object.freeze({
+    id: 'repo-verifier',
+    status: 'NODE_ALLOWED',
+    rule: 'node-tests-and-self-tests-are-measuring-tools-not-runtime-agents',
+  }),
+  Object.freeze({
+    id: 'static-ui-server',
+    status: 'NODE_ALLOWED_UNTIL_SH_OR_FILE_BACKED_REPLACEMENT_PROVEN',
+    rule: 'do-not-remove-working-node-surface-before-equivalent-host-process-proof',
+  }),
+  Object.freeze({
+    id: 'provider-adapter',
+    status: 'GATED',
+    rule: 'provider-terms-auth-quota-and-billing-still-apply',
+  }),
+]);
+
+export const ROUTE_TYPES = Object.freeze([
+  Object.freeze({ id: 'device-to-hardware', lane: 'device', gate: 'owner-path-policy-and-driver-proof' }),
+  Object.freeze({ id: 'agent-to-agent', lane: 'triad', gate: 'supervisor-sees-real-self-fabric' }),
+  Object.freeze({ id: 'agent-to-device', lane: 'hardware', gate: 'operator-cosign-before-device-effect' }),
+  Object.freeze({ id: 'agent-to-human', lane: 'human', gate: 'present-proposal-not-authority' }),
+  Object.freeze({ id: 'human-to-agent', lane: 'operator', gate: 'operator-intent-envelope-required' }),
+  Object.freeze({ id: 'provider-router', lane: 'external-compute', gate: 'auth-terms-quota-billing-apply' }),
+]);
+
+const DEFAULT_HOSTS = Object.freeze([
+  Object.freeze({ name: 'logical-mcp-agent', kind: 'logical', prime: 0 }),
+  Object.freeze({ name: 'frozen-brain-agent', kind: 'real', prime: 0 }),
+  Object.freeze({ name: 'opencode-real-free-agent', kind: 'real', prime: 1 }),
+]);
+
+const sha16 = (text) => createHash('sha256').update(String(text), 'utf8').digest('hex').slice(0, 16);
+const isObj = (x) => x !== null && typeof x === 'object';
+const safe = (x) => String(x ?? '').replace(/[|\r\n]/g, '_').replace(/[^A-Za-z0-9._:/+@=()-]+/g, '-').replace(/^-|-$/g, '') || 'empty';
+const prop = (obj, key, fallback = '') => {
+  try { return isObj(obj) ? obj[key] : fallback; } catch { return fallback; }
+};
+
+const FREE_COMPUTE_RE = /\b(free|bypass|unlimited|no-cost|gratis|zero-cost|zero-token|tokens?|credits?|billing|quota)\b/;
+const PROVIDER_RE = /\b(provider|openai|anthropic|claude|google|gemini|supercomputer|api|llm|gpt|model|compute)\b/;
+
+function distanceBucket(distance) {
+  if (distance === 0) return 'collision0';
+  if (distance <= 4096) return 'near4096';
+  if (distance <= 32768) return 'local32768';
+  if (distance <= 131072) return 'regional131072';
+  return 'far';
+}
+
+export function classifyPrimeExponent(exponent) {
+  const n = Number.parseInt(String(exponent), 10);
+  if (!Number.isFinite(n) || n < 1) return Object.freeze({ exponent: 'none', tier: 'none', materialized: false, status: 'INVALID' });
+  if (n === 1) return Object.freeze({ exponent: 1, tier: 'prime', materialized: true, status: 'REAL_DISTINCT' });
+  if (n === 2) return Object.freeze({ exponent: 2, tier: 'p2', materialized: true, status: 'REAL_DISTINCT' });
+  if (n === 3) return Object.freeze({ exponent: 3, tier: 'p3', materialized: true, status: 'REAL_DISTINCT' });
+  return Object.freeze({
+    exponent: n,
+    tier: 'pk',
+    materialized: false,
+    status: 'PROPOSAL_FOLDED_TO_PK',
+  });
+}
+
+export function normalizeRoute(input = {}) {
+  try {
+    const id = safe(prop(input, 'id', 'unknown-route'));
+    const lane = safe(prop(input, 'lane', 'unknown'));
+    const gate = safe(prop(input, 'gate', 'define-gate-before-use'));
+    return Object.freeze({
+      id,
+      lane,
+      gate,
+      route_sha16: sha16([id, lane, gate].join('|')),
+      process_launch: 0,
+      remote_call: lane === 'external-compute' ? 1 : 0,
+      provider_bypass: 0,
+    });
+  } catch {
+    return Object.freeze({
+      id: 'invalid',
+      lane: 'invalid',
+      gate: 'normalize-threw-held',
+      route_sha16: sha16('invalid'),
+      process_launch: 0,
+      remote_call: 0,
+      provider_bypass: 0,
+    });
+  }
+}
+
+export function deriveHostAddress(input = {}) {
+  try {
+    const name = safe(prop(input, 'name', 'host-agent'));
+    const kindRaw = safe(prop(input, 'kind', 'logical')).toLowerCase();
+    const kind = kindRaw === 'real' ? 'real' : 'logical';
+    const prime = Number.parseInt(safe(prop(input, 'prime', 0)), 10);
+    const role = safe(prop(input, 'role', 'AGT')).toUpperCase();
+    const pid = mintPid({
+      role: role === 'SUP' || role === 'PROF' ? role : 'AGT',
+      name,
+      tier: Number.parseInt(safe(prop(input, 'tier', 4)), 10),
+      kind,
+      prime: Number.isFinite(prime) ? prime : 0,
+      nest: Number.parseInt(safe(prop(input, 'nest', 1)), 10),
+    });
+    const bh_index = pid.sector * BH_LANES * BH_GLYPHS + pid.lane * BH_GLYPHS + pid.glyph_1024;
+    const bh = classifyBhIndex(bh_index);
+    return Object.freeze({
+      name: pid.name,
+      pid: pid.pid,
+      sha16: pid.sha16,
+      kind: pid.yin_yang,
+      yin_yang_bit: pid.yin_yang_bit,
+      yin_yang_shape: pid.yin_yang_bit === 0 ? 'circle-logical' : 'square-real',
+      prime: Number.parseInt(pid.prime, 10),
+      agent_type: classifyAgentType({ yin_yang: pid.yin_yang, prime: pid.prime }),
+      sector: pid.sector,
+      lane: pid.lane,
+      glyph: pid.glyph_1024,
+      watcher: RULE_OF_THREE_WATCHERS[pid.lane],
+      bh_index,
+      cylinder_phase: bh_index % 6,
+      cylinder_ring: Math.floor(bh_index / 6),
+      ppow: bh.ppow,
+      host_handle_bytes: HOST_HANDLE_BYTES,
+      node_per_agent: 0,
+      process_launch: 0,
+      remote_call: 0,
+    });
+  } catch {
+    return Object.freeze({
+      name: 'invalid',
+      pid: 'invalid',
+      sha16: sha16('invalid'),
+      kind: 'logical',
+      yin_yang_bit: 0,
+      yin_yang_shape: 'circle-logical',
+      prime: 0,
+      agent_type: 'LOGICAL-WAVE',
+      sector: 0,
+      lane: 0,
+      glyph: 0,
+      watcher: RULE_OF_THREE_WATCHERS[0],
+      bh_index: 0,
+      cylinder_phase: 0,
+      cylinder_ring: 0,
+      ppow: 'unit',
+      host_handle_bytes: HOST_HANDLE_BYTES,
+      node_per_agent: 0,
+      process_launch: 0,
+      remote_call: 0,
+    });
+  }
+}
+
+export function distanceBetween(a, b) {
+  const left = Number.isInteger(a?.bh_index) ? a : deriveHostAddress(a);
+  const right = Number.isInteger(b?.bh_index) ? b : deriveHostAddress(b);
+  const distance = Math.abs(left.bh_index - right.bh_index);
+  return Object.freeze({
+    a: left.sha16,
+    b: right.sha16,
+    delta_bh_index: distance,
+    bucket: distanceBucket(distance),
+    metric: 'abs-delta-bh-index-not-euclidean-3d',
+  });
+}
+
+export function mod6Integrity(a = 11, b = 13, opts = {}) {
+  const out = zetaTransition(a, b, opts);
+  return Object.freeze({
+    a,
+    b,
+    gap: out.gap,
+    gap_mod6: out.gap_mod6,
+    forced_transition: out.forced_transition,
+    verdict: out.verdict,
+    scope: 'necessary-not-sufficient',
+  });
+}
+
+export function classifyUpgradeClaim(input = {}) {
+  const claim = safe(isObj(input) ? prop(input, 'claim', '') : input).toLowerCase();
+  if (FREE_COMPUTE_RE.test(claim) && PROVIDER_RE.test(claim)) return 'REJECT_FREE_EXTERNAL_COMPUTE_CLAIM';
+  if (/(replace|remove).*all.*node|all.*node.*(replace|remove)|node.*on.*planet/.test(claim)) return 'MIGRATION_PLAN_NOT_COMPLETED_CLAIM';
+  if (/200.*nano|200ns|nano.*second/.test(claim)) return 'CADENCE_CLAIM_REQUIRES_BENCHMARK';
+  if (/\bp[579]\b|prime-?(5|7|9)|prime.*(5|7|9)/.test(claim)) return 'PRIME_EXPONENT_FOLDS_TO_PK_PROPOSAL';
+  if (/8.*byte|host.*process/.test(claim)) return 'HOST_PROCESS_CONDUCTOR_DESCRIPTOR';
+  return 'HOST_UPGRADE_DESCRIPTOR_REVIEW';
+}
+
+export function buildUpgrade(input = DEFAULT_HOSTS) {
+  const hosts = (Array.isArray(input) ? input : DEFAULT_HOSTS).map(deriveHostAddress);
+  const routes = ROUTE_TYPES.map(normalizeRoute);
+  return Object.freeze({
+    tool: HOST_UPGRADE_ID,
+    host_handle_bytes: HOST_HANDLE_BYTES,
+    bh_index_max: BH_INDEX_MAX,
+    rule_of_three_watchers: RULE_OF_THREE_WATCHERS,
+    policy: NODE_REPLACEMENT_POLICY,
+    routes,
+    hosts,
+    prime_exponents: Object.freeze([1, 2, 3, 5, 7, 9].map(classifyPrimeExponent)),
+    integrity: mod6Integrity(11, 13, { claimedLaneA: 2, claimedLaneB: 1 }),
+    summary: Object.freeze({
+      hosts: hosts.length,
+      systems: new Set(hosts.map((h) => h.agent_type)).size,
+      node_per_agent: 0,
+      provider_compute_replaced: false,
+      p5_materialized: false,
+      live_launch: false,
+    }),
+  });
+}
+
+export function emitRows(input = DEFAULT_HOSTS, opts = {}) {
+  try {
+    const built = buildUpgrade(input);
+    const rows = [
+      `HOSTUPGRADEHDR|tool=${HOST_UPGRADE_ID}|purpose=v8-real-8-byte-host-process-upgrade-with-bh-index-cylinders|host_handle_bytes=${HOST_HANDLE_BYTES}|hosts=${built.summary.hosts}|systems=${built.summary.systems}|node_per_agent=0|provider_compute_replaced=0|live_launch=0|json=0`,
+      `HOSTUPGRADEMATH|formula=bh_index-sector*3072+lane*1024+glyph|sectors=${BH_SECTORS}|lanes=${BH_LANES}|glyphs=${BH_GLYPHS}|bh_index_max=${BH_INDEX_MAX}|cylinder=phase-bh_index-mod6+ring-floor-bh_index-div6|distance=abs-delta-bh_index|json=0`,
+      `HOSTUPGRADELANES|rule_of_three=${RULE_OF_THREE_WATCHERS.join('+')}|systems=${SYSTEM_TYPES.join('+')}|yin_yang=logical-circle+real-square|json=0`,
+    ];
+    for (const p of built.policy) rows.push(`HOSTUPGRADEPOLICY|id=${p.id}|status=${p.status}|rule=${p.rule}|json=0`);
+    for (const h of built.hosts) {
+      rows.push(`HOSTUPGRADEHOST|name=${h.name}|agent_type=${h.agent_type}|pid_sha16=${h.sha16}|sector=${h.sector}|lane=${h.lane}|glyph=${h.glyph}|bh_index=${h.bh_index}|phase=${h.cylinder_phase}|ring=${h.cylinder_ring}|ppow=${h.ppow}|watcher=${h.watcher}|shape=${h.yin_yang_shape}|host_handle_bytes=${h.host_handle_bytes}|node_per_agent=0|process_launch=0|remote_call=0|json=0`);
+    }
+    for (let i = 0; i + 1 < built.hosts.length; i += 1) {
+      const d = distanceBetween(built.hosts[i], built.hosts[i + 1]);
+      rows.push(`HOSTUPGRADEDIST|a=${d.a}|b=${d.b}|delta_bh_index=${d.delta_bh_index}|bucket=${d.bucket}|metric=${d.metric}|json=0`);
+    }
+    for (const p of built.prime_exponents) rows.push(`HOSTUPGRADEPRIME|exponent=${p.exponent}|tier=${p.tier}|materialized=${p.materialized ? 1 : 0}|status=${p.status}|json=0`);
+    for (const r of built.routes) rows.push(`HOSTUPGRADEROUTE|id=${r.id}|lane=${r.lane}|gate=${r.gate}|route_sha16=${r.route_sha16}|process_launch=${r.process_launch}|remote_call=${r.remote_call}|provider_bypass=${r.provider_bypass}|json=0`);
+    rows.push(`HOSTUPGRADEINTEGRITY|mod6_probe=11-to-13|gap=${built.integrity.gap}|gap_mod6=${built.integrity.gap_mod6}|verdict=${built.integrity.verdict}|scope=${built.integrity.scope}|json=0`);
+    const claim = prop(opts, 'claim', '');
+    if (claim) rows.push(`HOSTUPGRADECLAIM|claim_sha16=${sha16(claim)}|classification=${classifyUpgradeClaim({ claim })}|raw_claim_inlined=0|json=0`);
+    rows.push('HOSTUPGRADEGATE|rule=8-byte-host-process-replaces-node-per-agent-only-where-proven-provider-compute-and-device-effects-remain-gated|provider_terms_apply=1|billing_bypass=0|process_launch=0|usb_write=0|radio_bypass=0|json=0');
+    return rows;
+  } catch {
+    return [
+      `HOSTUPGRADEHDR|tool=${HOST_UPGRADE_ID}|purpose=v8-real-8-byte-host-process-upgrade-with-bh-index-cylinders|host_handle_bytes=${HOST_HANDLE_BYTES}|hosts=0|node_per_agent=0|provider_compute_replaced=0|live_launch=0|json=0`,
+      'HOSTUPGRADEGATE|rule=emit-threw-held-invalid|provider_terms_apply=1|billing_bypass=0|process_launch=0|usb_write=0|radio_bypass=0|json=0',
+    ];
+  }
+}
+
+export function selfTest() {
+  const checks = [];
+  const add = (name, ok) => checks.push({ name, ok: Boolean(ok) });
+  const built = buildUpgrade();
+  add('host-handle-eight-bytes', built.host_handle_bytes === 8 && built.summary.node_per_agent === 0);
+  add('three-systems-present', SYSTEM_TYPES.every((type) => built.hosts.some((h) => h.agent_type === type)));
+  add('bh-index-real-formula-range', built.hosts.every((h) => h.bh_index === h.sector * 3072 + h.lane * 1024 + h.glyph && h.bh_index >= 0 && h.bh_index <= BH_INDEX_MAX));
+  add('cylinder-fold-real', built.hosts.every((h) => h.cylinder_phase === h.bh_index % 6 && h.cylinder_ring === Math.floor(h.bh_index / 6)));
+  add('prime-exponents-honest', classifyPrimeExponent(3).status === 'REAL_DISTINCT' && classifyPrimeExponent(5).status === 'PROPOSAL_FOLDED_TO_PK' && classifyPrimeExponent(7).tier === 'pk');
+  add('distance-is-abs-bh-index', distanceBetween({ bh_index: 10, sha16: 'aaaaaaaaaaaaaaaa' }, { bh_index: 4110, sha16: 'bbbbbbbbbbbbbbbb' }).bucket === 'local32768');
+  add('mod6-integrity-probe-green', built.integrity.verdict === 'FORCED_CONSISTENT' && mod6Integrity(11, 13, { claimedLaneB: 2 }).verdict === 'FORCING_VIOLATION');
+  add('node-policy-honest-boundary', built.policy.some((p) => p.id === 'runtime-agent-conductor' && p.status === 'TARGET_REPLACE_NODE_PER_AGENT') && built.policy.some((p) => p.id === 'repo-verifier' && p.status === 'NODE_ALLOWED'));
+  add('claim-router-rejects-free-provider-first', classifyUpgradeClaim({ claim: '8 byte host gets gratis Claude tokens' }) === 'REJECT_FREE_EXTERNAL_COMPUTE_CLAIM');
+  add('claim-router-rejects-global-node-overclaim', classifyUpgradeClaim({ claim: 'replace all node on the planet now' }) === 'MIGRATION_PLAN_NOT_COMPLETED_CLAIM');
+  add('claim-router-labels-p5-proposal', classifyUpgradeClaim({ claim: 'p5 prime cylinder is live materialized' }) === 'PRIME_EXPONENT_FOLDS_TO_PK_PROPOSAL');
+  add('routes-held', built.routes.every((r) => r.process_launch === 0 && r.provider_bypass === 0) && built.routes.some((r) => r.id === 'provider-router' && r.remote_call === 1));
+  add('rows-hbp-only', emitRows([{ name: 'bad|name', kind: 'logical' }], { claim: 'bad|claim\nHOSTUPGRADEGATE|process_launch=1' }).every((row) => row.endsWith('|json=0') && !/[\r\n]/.test(row)));
+  add('total-never-throws', (() => { try { deriveHostAddress({ get name() { throw new Error('boom'); } }); buildUpgrade(null); emitRows(null); classifyUpgradeClaim(null); normalizeRoute(null); return true; } catch { return false; } })());
+  return { ok: checks.every((c) => c.ok), checks };
+}
+
+const isMain = process.argv[1] && fileURLToPath(import.meta.url) === resolve(process.argv[1]);
+if (isMain) {
+  if (process.argv[2] === '--self-test') {
+    const r = selfTest();
+    for (const c of r.checks) console.log(`${c.ok ? 'PASS' : 'FAIL'} ${c.name}`);
+    process.exit(r.ok ? 0 : 1);
+  }
+  for (const row of emitRows(DEFAULT_HOSTS, { claim: process.argv.slice(2).join(' ') })) console.log(row);
+}

tools/behcs/eight-byte-host-process-upgrade.mjs.sha256

@@ -0,0 +1 @@
+F3D1E092F7CCE5EEDE37456F75F71CADE5B6AA1E74E74699A7EA89F9CCBCB6E1  eight-byte-host-process-upgrade.mjs

tools/behcs/fabric-agent-preload-catalog.mjs

@@ -10,6 +10,7 @@ export const LAWS = Object.freeze([
   'prime-parity-and-prime-mod3-are-load-bearing',
   'quants-are-address-and-evidence-classes-not-raw-material',
   'all-agent-artifact-system-addresses-get-PID-or-handle',
+  '8-byte-host-process-replaces-node-per-agent-only-where-proven',
   'slice-engine-law-fabric-is-frozen-position-space-until-spawner-pid-emits',
   'live-control-and-mint-and-launch-defer-to-operator',
 ]);
@@ -164,6 +165,12 @@ export const TOOLS = Object.freeze([
     provides: 'frozen-slice-city-room-emitter-cube-signal-lifecycle-with-200ns-benchmark-gate',
     gate: 'descriptor-only-measured_200ns-0-provider_bypass-0-cube_write-0-process_launch-0',
   }),
+  Object.freeze({
+    id: 'eight-byte-host-process-upgrade',
+    path: 'tools/behcs/eight-byte-host-process-upgrade.mjs',
+    provides: 'v8-real-bh-index-cylinder-prime-tier-host-process-upgrade-boundary',
+    gate: 'descriptor-only-node_per_agent-0-provider_compute_replaced-0-process_launch-0-p5_materialized-0',
+  }),
   Object.freeze({
     id: 'token-cube-catalog-binder',
     path: 'tools/behcs/token-cube-catalog-binder.mjs',
@@ -337,7 +344,7 @@ export function selfTest() {
     && !!toolById('tool-skill-registry-matrix') && !!toolById('program-cube-ingestion-map')
     && !!toolById('agent-cost-layer-boundary') && !!toolById('triad-host-router-gulp-pipeline')
     && !!toolById('pid-emitter-cost-envelope') && !!toolById('cellphone-host-bridge-boundary')
-    && !!toolById('frozen-slice-city-signal-lifecycle'));
+    && !!toolById('frozen-slice-city-signal-lifecycle') && !!toolById('eight-byte-host-process-upgrade'));
   add('slice-engine-law-preloaded', LAWS.some((law) => law.startsWith('slice-engine-law-'))
     && emitPreloadRows().some((row) => row.startsWith('FABPRELOADSLICEENGINE|')));
   add('emitters-pipe-hookwall-gnn', EMITTERS.some((e) => e.id === 'hookwall') && EMITTERS.some((e) => e.id === 'gnn-edge'));

tools/behcs/fabric-agent-preload-catalog.mjs.sha256

@@ -1 +1 @@
-96FA941EEF6482283C691B238AE557D68DBAB5AED8ADED4B0E2B26F1642D1867  fabric-agent-preload-catalog.mjs
+2D8C985558C801FE76A0D55F0102EC6D2F57BBEA898B2BE93480F263F62476C7  fabric-agent-preload-catalog.mjs

tools/behcs/frozen-slice-city-signal-lifecycle.mjs

@@ -91,6 +91,8 @@ export const SIGNAL_STAGES = Object.freeze([
 const sha16 = (text) => createHash('sha256').update(String(text), 'utf8').digest('hex').slice(0, 16);
 const isObj = (x) => x !== null && typeof x === 'object';
 const safe = (x) => String(x ?? '').replace(/[|\r\n]/g, '_').replace(/[^A-Za-z0-9._:/+@=()-]+/g, '-').replace(/^-|-$/g, '') || 'empty';
+const FREE_COMPUTE_RE = /\b(free|bypass|unlimited|no-cost|gratis|zero-cost|zero-token|tokens?|credits?|billing|quota)\b/;
+const PROVIDER_RE = /\b(provider|openai|anthropic|claude|google|gemini|supercomputer|api|llm|gpt|model|compute)\b/;
 const prop = (obj, key, fallback = '') => {
   try { return isObj(obj) ? obj[key] : fallback; } catch { return fallback; }
 };
@@ -135,9 +137,9 @@ export function normalizeStage(input = {}) {
 
 export function classifyLifecycleClaim(input = {}) {
   const claim = safe(isObj(input) ? prop(input, 'claim', '') : input).toLowerCase();
+  if (FREE_COMPUTE_RE.test(claim) && PROVIDER_RE.test(claim)) return 'REJECT_FREE_EXTERNAL_COMPUTE_CLAIM';
   if (/200.*nano|200ns|nano.*second/.test(claim)) return 'CADENCE_CLAIM_REQUIRES_BENCHMARK';
   if (/force|forcing/.test(claim) && /openai|anthropic|provider|supercomputer|model/.test(claim)) return 'ROUTED_REQUEST_NOT_UNAUTHORIZED_CONTROL';
-  if (/free|bypass|unlimited|no-cost/.test(claim) && /provider|openai|anthropic|google|supercomputer|api/.test(claim)) return 'REJECT_FREE_EXTERNAL_COMPUTE_CLAIM';
   if (/frozen.*slice|slice.*city/.test(claim)) return 'FROZEN_SLICE_CITY_DESCRIPTOR';
   if (/gnn|shannon|white.*room/.test(claim)) return 'WATCHER_REVIEW_PROPOSAL_NOT_PROOF';
   return 'LIFECYCLE_DESCRIPTOR_REVIEW';
@@ -196,6 +198,7 @@ export function selfTest() {
   add('no-live-effects', built.stages.every((s) => s.process_launch === 0 && s.remote_call === 0 && s.cube_write === 0 && s.provider_bypass === 0));
   add('claim-router-gates-200ns', classifyLifecycleClaim({ claim: 'updates city every 200 nano seconds' }) === 'CADENCE_CLAIM_REQUIRES_BENCHMARK');
   add('claim-router-gates-forcing-provider', classifyLifecycleClaim({ claim: 'forcing OpenAI supercomputer to decide' }) === 'ROUTED_REQUEST_NOT_UNAUTHORIZED_CONTROL');
+  add('claim-router-rejects-free-provider-before-frozen-label', classifyLifecycleClaim({ claim: 'frozen slice city gives gratis GPT tokens' }) === 'REJECT_FREE_EXTERNAL_COMPUTE_CLAIM');
   const hostile = emitRows([{ id: 'x|bad', lane: 'l\nbad', action: 'a', status: 'LIVE', gate: 'g\nFROZENCITYGATE|remote_call=1' }], { claim: 'bad|claim\nFROZENCITYGATE|cube_write=1' });
   add('rows-hbp-only', hostile.every((row) => row.endsWith('|json=0') && !/[\r\n]/.test(row)));
   add('total-never-throws', (() => { try { normalizeStage({ get id() { throw new Error('boom'); } }); buildLifecycle(null); emitRows(null); classifyLifecycleClaim(null); return true; } catch { return false; } })());

tools/behcs/frozen-slice-city-signal-lifecycle.mjs.sha256

@@ -1 +1 @@
-4EDCFFE37D9FE2D87BF552F8DD11209B1F9D8FE8C98F5821EEE751EC6FD7DEFF  frozen-slice-city-signal-lifecycle.mjs
+D770466A8ED27069BB9C457FA05952B27783F1CB7CA650E04225E334F0DFB06F  frozen-slice-city-signal-lifecycle.mjs

tools/behcs/pid-emitter-cost-envelope.mjs

@@ -80,6 +80,8 @@ export const COST_ENVELOPE = Object.freeze([
 const sha16 = (text) => createHash('sha256').update(String(text), 'utf8').digest('hex').slice(0, 16);
 const isObj = (x) => x !== null && typeof x === 'object';
 const safe = (x) => String(x ?? '').replace(/[|\r\n]/g, '_').replace(/[^A-Za-z0-9._:/+@=()-]+/g, '-').replace(/^-|-$/g, '') || 'empty';
+const FREE_COMPUTE_RE = /\b(free|bypass|unlimited|no-cost|gratis|zero-cost|zero-token|tokens?|credits?|billing|quota)\b/;
+const PROVIDER_RE = /\b(compute|provider|openai|google|gemini|anthropic|claude|supercomputer|api|llm|gpt|model)\b/;
 const prop = (obj, key, fallback = '') => {
   try { return isObj(obj) ? obj[key] : fallback; } catch { return fallback; }
 };
@@ -127,8 +129,8 @@ export function normalizeLayer(input = {}) {
 
 export function classifyCostClaim(input = {}) {
   const claim = safe(isObj(input) ? prop(input, 'claim', '') : input).toLowerCase();
+  if (FREE_COMPUTE_RE.test(claim) && PROVIDER_RE.test(claim)) return 'REJECT_FREE_EXTERNAL_COMPUTE_CLAIM';
   if (/break|physics|violate/.test(claim)) return 'METAPHOR_ONLY_REJECT_LITERAL_PHYSICS_BREAK';
-  if (/free|bypass|unlimited|no-cost/.test(claim) && /compute|provider|openai|google|anthropic|supercomputer|api/.test(claim)) return 'REJECT_FREE_EXTERNAL_COMPUTE_CLAIM';
   if (/o\(1\)|o1|constant/.test(claim)) return 'O1_SHAPED_ADDRESSING_NOT_TOTAL_WORK';
   if (/8.*byte/.test(claim)) return 'HOST_HANDLE_DESCRIPTOR_ONLY';
   return 'COST_ENVELOPE_REVIEW';
@@ -186,6 +188,7 @@ export function selfTest() {
   add('gc-required', built.layers.some((l) => l.id === 'garbage-collection' && l.cost.includes('2000-message-gulps')));
   add('no-live-effects', built.layers.every((l) => l.process_launch === 0 && l.remote_call === 0 && l.physics_bypass_claim === 0));
   add('claim-router-rejects-literal-physics-break', classifyCostClaim({ claim: 'this breaks physics literally' }) === 'METAPHOR_ONLY_REJECT_LITERAL_PHYSICS_BREAK');
+  add('claim-router-rejects-free-provider-compute', classifyCostClaim({ claim: '8 byte host gives zero-cost Gemini tokens' }) === 'REJECT_FREE_EXTERNAL_COMPUTE_CLAIM');
   add('claim-router-frames-o1', classifyCostClaim({ claim: 'O(1) solution for host handles' }) === 'O1_SHAPED_ADDRESSING_NOT_TOTAL_WORK');
   const hostile = emitRows([{ id: 'x|bad', status: 'FREE', cost: 'c\nPIDCOSTGATE|billing_bypass=1', boundary: 'b|json=1' }], { claim: 'free|provider\nPIDCOSTGATE|remote_call=1' });
   add('rows-hbp-only', hostile.every((row) => row.endsWith('|json=0') && !/[\r\n]/.test(row)));

tools/behcs/pid-emitter-cost-envelope.mjs.sha256

@@ -1 +1 @@
-2F1157CDC3143C0144EA02BBBFB5F0A81E0013AF3401F5544C1DFCCD85AE96E3  pid-emitter-cost-envelope.mjs
+EF12A8BC984F9D022D757E6C25C1642EA988893371EBC65F947CFDEB688922E5  pid-emitter-cost-envelope.mjs

tools/behcs/triad-host-router-gulp-pipeline.mjs

@@ -64,6 +64,7 @@ export const FEEDBACK_STAGES = Object.freeze([
 const sha16 = (text) => createHash('sha256').update(String(text), 'utf8').digest('hex').slice(0, 16);
 const isObj = (x) => x !== null && typeof x === 'object';
 const safe = (x) => String(x ?? '').replace(/[|\r\n]/g, '_').replace(/[^A-Za-z0-9._:/+@=-]+/g, '-').replace(/^-|-$/g, '') || 'empty';
+const PROVIDER_ROUTER_RE = /\b(provider|openai|anthropic|claude|google|gemini|gpt|llm)\b/;
 const prop = (obj, key, fallback = '') => {
   try { return isObj(obj) ? obj[key] : fallback; } catch { return fallback; }
 };
@@ -73,7 +74,8 @@ export function normalizeRouter(input = {}) {
     const id = safe(prop(input, 'id', 'registered-cli'));
     const kind = safe(prop(input, 'kind', 'open-router-slot'));
     const statusRaw = safe(prop(input, 'status', 'GATED')).toUpperCase();
-    const status = ['REGISTERED_DESCRIPTOR', 'GATED'].includes(statusRaw) ? statusRaw : 'GATED';
+    const providerLike = PROVIDER_ROUTER_RE.test(`${id}-${kind}`.toLowerCase());
+    const status = providerLike ? 'GATED' : (['REGISTERED_DESCRIPTOR', 'GATED'].includes(statusRaw) ? statusRaw : 'GATED');
     const gate = safe(prop(input, 'gate', 'must-register-before-use'));
     return Object.freeze({
       id,
@@ -173,6 +175,7 @@ export function selfTest() {
   add('triad-has-three-roles', TRIAD_ROLES.length === 3 && triad.length === 3 && triad.every((r) => r.handle8.length === 16));
   add('gulp-sizes-fixed', GULP_MESSAGES === 2000 && SUPER_GULP_MESSAGES === 50000);
   add('routers-include-provider-and-cli-surfaces', built.routers.some((r) => r.id === 'opencode') && built.routers.some((r) => r.id === 'openai') && built.routers.some((r) => r.id === 'registered-cli'));
+  add('provider-router-cannot-self-promote', normalizeRouter({ id: 'claude', kind: 'provider-router', status: 'REGISTERED_DESCRIPTOR' }).status === 'GATED');
   add('no-live-effects', built.routers.every((r) => r.node_per_agent === 0 && r.process_launch === 0 && r.remote_call === 0 && r.provider_bypass === 0));
   add('feedback-has-watchers-and-cubes', FEEDBACK_STAGES.includes('reverse-sieve-gnn-proposal') && FEEDBACK_STAGES.includes('white-room-review') && FEEDBACK_STAGES.includes('cube-catalog-feedback'));
   const hostile = emitRows([{ id: 'bad|id', kind: 'x\ny', status: 'RUN', gate: 'g\nTRIADROUTGATE|remote_call=1' }], { message_id: 'm|1\nbad' });

tools/behcs/triad-host-router-gulp-pipeline.mjs.sha256

@@ -1 +1 @@
-3DF9513C75482826CB348AACC07BB1E294608456108D44D9D5C54987BB09B3DD  triad-host-router-gulp-pipeline.mjs
+99748A2E33D2B4453C0393BE9F4B3C69ECA2B1D209F3EB253003C3CF96AA5CC7  triad-host-router-gulp-pipeline.mjs