liris: add cellphone host bridge boundary

docs/LIRIS-CELLPHONE-HOST-BRIDGE-BOUNDARY-2026-06-14.hbp

@@ -0,0 +1,7 @@
+PHONEBRIDGECANONHDR|doc=LIRIS-CELLPHONE-HOST-BRIDGE-BOUNDARY-2026-06-14|date=2026-06-14|owner=liris|scope=cellphones-as-file-backed-8-byte-host-bridges|tag=DESCRIPTOR-ONLY|json=0
+PHONEBRIDGECANONHOST|host_handle_bytes=8|meaning=cellphone-file-backed-host-bridge-or-phone-line-descriptor|not_meaning=message-size-live-execution-or-free-provider-compute|json=0
+PHONEBRIDGECANONDEVICES|known=falcon+aether|planned=s22-ultra+future-phone|proof=file-manager-pull-push-hash-roundtrip-before-messages|json=0
+PHONEBRIDGECANONROUTE|stages=device-detect->file-manager-roundtrip-proof->host-handle-register->language-cube-envelope->phone-line-route->supervisor-gate->message-gulp-gc->receipt-pullback|json=0
+PHONEBRIDGECANONGATE|self_call=requires-auth-and-route-proof|provider_bypass=0|radio_bypass=0|provider_terms_apply=1|radio_policy_apply=1|process_launch=0|json=0
+PHONEBRIDGECANONTOOL|tool=tools/behcs/cellphone-host-bridge-boundary.mjs|test=tests/cellphone-host-bridge-boundary.unit.test.mjs|catalog=tools/behcs/fabric-agent-preload-catalog.mjs|json=0
+PHONEBRIDGECANONFTR|status=SEALED-CELLPHONE-HOST-BRIDGE-BOUNDARY|next=use-before-scaling-phone-host-or-supercomputer-self-call-claims|json=0

docs/LIRIS-CELLPHONE-HOST-BRIDGE-BOUNDARY-2026-06-14.hbp.sha256

@@ -0,0 +1 @@
+F752D1F457694E7153BED0BDA14C52049AC236F29E873A4E9D369AC81CE00029  LIRIS-CELLPHONE-HOST-BRIDGE-BOUNDARY-2026-06-14.hbp

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

@@ -0,0 +1,62 @@
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import test from 'node:test';
+
+import {
+  BRIDGE_STAGES, HOST_HANDLE_BYTES, PHONE_SURFACES,
+  buildBridge, classifyBridgeClaim, emitRows, normalizePhone, selfTest,
+} from '../tools/behcs/cellphone-host-bridge-boundary.mjs';
+
+test('cellphone host bridge boundary self-test passes', () => {
+  assert.equal(selfTest().ok, true);
+});
+
+test('phones are modeled as 8-byte file-backed host bridges, not live execution', () => {
+  const bridge = buildBridge();
+  assert.equal(HOST_HANDLE_BYTES, 8);
+  assert.equal(bridge.summary.live_ready, false);
+  assert.equal(bridge.summary.external_compute_free, false);
+  assert.ok(bridge.phones.every((p) => p.host_handle_bytes === 8 && p.process_launch === 0));
+});
+
+test('known bilateral phone surfaces and future gated slots are present', () => {
+  const ids = buildBridge().phones.map((p) => p.id);
+  assert.deepEqual(ids, ['falcon', 'aether', 's22-ultra', 'future-phone']);
+  assert.equal(buildBridge().summary.proven, 2);
+  assert.equal(buildBridge().summary.gated, 2);
+});
+
+test('file-manager roundtrip proof precedes messages and self-call routing', () => {
+  assert.deepEqual(BRIDGE_STAGES, [
+    'device-detect',
+    'file-manager-roundtrip-proof',
+    'host-handle-register',
+    'language-cube-envelope',
+    'phone-line-route',
+    'supervisor-gate',
+    'message-gulp-gc',
+    'receipt-pullback',
+  ]);
+});
+
+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: 'pull push file roundtrip' }), 'FILE_MANAGER_PROOF_REQUIRED');
+});
+
+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');
+  const rows = emitRows([phone], { claim: 'bad|claim\nPHONEBRIDGEGATE|provider_bypass=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('radio_policy_apply=1')));
+});
+
+test('tool remains descriptor-only and has no live call surface', () => {
+  const source = readFileSync(new URL('../tools/behcs/cellphone-host-bridge-boundary.mjs', import.meta.url), 'utf8');
+  assert.doesNotMatch(source, /from ['"]node:fs['"]|child_process|\bexecFile\b|\bexecSync\b|\bspawn\(|\bfetch\(|Invoke-WebRequest|Start-Process/);
+  assert.equal(PHONE_SURFACES.length, 4);
+});

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

@@ -0,0 +1 @@
+C419DB5AEEB7FC4372D4087DFDDAE00D15890AF36C3C6133E736AF1BFD15E547  cellphone-host-bridge-boundary.unit.test.mjs

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

@@ -33,6 +33,7 @@ test('preload catalog includes the laws, tools, roles, and cadence agents need',
   assert.ok(TOOLS.some((t) => t.id === 'agent-cost-layer-boundary' && t.gate.includes('free_compute_claim-0')));
   assert.ok(TOOLS.some((t) => t.id === 'triad-host-router-gulp-pipeline' && t.gate.includes('provider_bypass-0')));
   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(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 @@
-3FE2031CB3633511F1C45E3F8CAF44EFC2C692691937B6390A68CFF8255741AB  fabric-agent-preload-catalog.unit.test.mjs
+CDD74416F3221A1CC91698D291C5E20F9F72FA8587655CEFF0D1FC77E9EC76E2  fabric-agent-preload-catalog.unit.test.mjs

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

@@ -93,6 +93,7 @@ const sealedFiles = [
   'docs/LIRIS-AGENT-COST-LAYER-BOUNDARY-2026-06-14.hbp',
   'docs/LIRIS-TRIAD-HOST-ROUTER-GULP-PIPELINE-2026-06-14.hbp',
   'docs/LIRIS-PID-EMITTER-COST-ENVELOPE-2026-06-14.hbp',
+  'docs/LIRIS-CELLPHONE-HOST-BRIDGE-BOUNDARY-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',
@@ -237,6 +238,7 @@ const sealedFiles = [
   'tools/behcs/agent-cost-layer-boundary.mjs',
   'tools/behcs/triad-host-router-gulp-pipeline.mjs',
   'tools/behcs/pid-emitter-cost-envelope.mjs',
+  'tools/behcs/cellphone-host-bridge-boundary.mjs',
   'tools/behcs/logical-extreme-stress.mjs',
   'tools/behcs/logical-stress-cube-feed.mjs',
   'tools/behcs/brown-hilbert-expansion-stress.mjs',
@@ -275,6 +277,7 @@ const sealedFiles = [
   'tests/agent-cost-layer-boundary.unit.test.mjs',
   'tests/triad-host-router-gulp-pipeline.unit.test.mjs',
   'tests/pid-emitter-cost-envelope.unit.test.mjs',
+  'tests/cellphone-host-bridge-boundary.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 @@
-099337B92753C6A0EC6A5D693D0355528432CAD73872E73D7538B4C67D64BFA8  supervisor-collision-router.system.test.mjs
+45CEBAB21B3151C75C6AA0A440DFEA86165595D5381DE626709D01A8CC5CE334  supervisor-collision-router.system.test.mjs

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

@@ -0,0 +1,176 @@
+#!/usr/bin/env node
+// cellphone-host-bridge-boundary.mjs - descriptor for phones as 8-byte host bridges.
+//
+// Descriptor-only. This does not drive phones, open radios, call providers, launch agents,
+// or claim free external compute. It records the bridge boundary: cellphones can carry
+// file-backed rooms and host-handle descriptors, but messages require file-manager proof,
+// routing gates, and provider/network authorization.
+
+import { createHash } from 'node:crypto';
+import { resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+export const BRIDGE_ID = 'cellphone-host-bridge-boundary.v1';
+export const HOST_HANDLE_BYTES = 8;
+
+export const PHONE_SURFACES = Object.freeze([
+  Object.freeze({
+    id: 'falcon',
+    device_class: 'cellphone',
+    role: 'file-backed-host-bridge',
+    status: 'PROVEN_BY_PRIOR_FILE_MANAGER_ROUNDTRIP',
+    gate: 'messages-after-file-manager-proof',
+  }),
+  Object.freeze({
+    id: 'aether',
+    device_class: 'cellphone',
+    role: 'file-backed-host-bridge',
+    status: 'PROVEN_BY_PRIOR_FILE_MANAGER_ROUNDTRIP',
+    gate: 'messages-after-file-manager-proof',
+  }),
+  Object.freeze({
+    id: 's22-ultra',
+    device_class: 'cellphone',
+    role: 'planned-host-bridge',
+    status: 'GATED_UNTIL_ROUNDTRIP_PROOF',
+    gate: 'pull-push-hash-proof-before-host-messages',
+  }),
+  Object.freeze({
+    id: 'future-phone',
+    device_class: 'cellphone',
+    role: 'open-host-bridge-slot',
+    status: 'GATED_UNTIL_ROUNDTRIP_PROOF',
+    gate: 'register-device-owner-path-policy-and-roundtrip-proof-before-use',
+  }),
+]);
+
+export const BRIDGE_STAGES = Object.freeze([
+  'device-detect',
+  'file-manager-roundtrip-proof',
+  'host-handle-register',
+  'language-cube-envelope',
+  'phone-line-route',
+  'supervisor-gate',
+  'message-gulp-gc',
+  'receipt-pullback',
+]);
+
+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; }
+};
+
+export function normalizePhone(input = {}) {
+  try {
+    const id = safe(prop(input, 'id', 'unknown-phone'));
+    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 gate = safe(prop(input, 'gate', 'pull-push-hash-proof-before-host-messages'));
+    return Object.freeze({
+      id,
+      device_class,
+      role,
+      status,
+      gate,
+      host_handle_bytes: HOST_HANDLE_BYTES,
+      bridge_sha16: sha16([id, device_class, role, status, gate].join('|')),
+      process_launch: 0,
+      radio_bypass: 0,
+      provider_bypass: 0,
+      self_call_authorized: 0,
+    });
+  } catch {
+    return Object.freeze({
+      id: 'invalid',
+      device_class: 'cellphone',
+      role: 'invalid',
+      status: 'GATED_UNTIL_ROUNDTRIP_PROOF',
+      gate: 'normalize-threw-held',
+      host_handle_bytes: HOST_HANDLE_BYTES,
+      bridge_sha16: sha16('invalid'),
+      process_launch: 0,
+      radio_bypass: 0,
+      provider_bypass: 0,
+      self_call_authorized: 0,
+    });
+  }
+}
+
+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 (/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';
+  return 'BRIDGE_DESCRIPTOR_REVIEW';
+}
+
+export function buildBridge(input = PHONE_SURFACES) {
+  const phones = (Array.isArray(input) ? input : PHONE_SURFACES).map(normalizePhone);
+  return Object.freeze({
+    tool: BRIDGE_ID,
+    host_handle_bytes: HOST_HANDLE_BYTES,
+    stages: BRIDGE_STAGES,
+    phones,
+    summary: Object.freeze({
+      phones: phones.length,
+      proven: phones.filter((p) => p.status === 'PROVEN_BY_PRIOR_FILE_MANAGER_ROUNDTRIP').length,
+      gated: phones.filter((p) => p.status === 'GATED_UNTIL_ROUNDTRIP_PROOF').length,
+      live_ready: false,
+      external_compute_free: false,
+    }),
+  });
+}
+
+export function emitRows(input = PHONE_SURFACES, opts = {}) {
+  try {
+    const built = buildBridge(input);
+    const rows = [
+      `PHONEBRIDGEHDR|tool=${BRIDGE_ID}|purpose=cellphones-as-file-backed-8-byte-host-bridges-for-asolaria-language-routing|host_handle_bytes=${HOST_HANDLE_BYTES}|phones=${built.summary.phones}|proven=${built.summary.proven}|gated=${built.summary.gated}|live_ready=0|process_launch=0|provider_bypass=0|radio_bypass=0|json=0`,
+      `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`);
+    }
+    const claim = prop(opts, 'claim', '');
+    if (claim) rows.push(`PHONEBRIDGECLAIM|claim_sha16=${sha16(claim)}|classification=${classifyBridgeClaim({ claim })}|raw_claim_inlined=0|json=0`);
+    rows.push('PHONEBRIDGEGATE|rule=phone-host-bridge-is-file-backed-routing-surface-not-free-provider-compute|requires=file-manager-roundtrip-proof+owner-policy+route-proof+gc-receipt|provider_terms_apply=1|radio_policy_apply=1|process_launch=0|json=0');
+    return rows;
+  } catch {
+    return [
+      `PHONEBRIDGEHDR|tool=${BRIDGE_ID}|purpose=cellphones-as-file-backed-8-byte-host-bridges-for-asolaria-language-routing|host_handle_bytes=${HOST_HANDLE_BYTES}|phones=0|live_ready=0|process_launch=0|provider_bypass=0|radio_bypass=0|json=0`,
+      'PHONEBRIDGEGATE|rule=emit-threw-held-invalid|provider_terms_apply=1|radio_policy_apply=1|process_launch=0|json=0',
+    ];
+  }
+}
+
+export function selfTest() {
+  const checks = [];
+  const add = (name, ok) => checks.push({ name, ok: Boolean(ok) });
+  const built = buildBridge();
+  add('host-handle-eight-bytes', built.host_handle_bytes === 8);
+  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('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');
+  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; } })());
+  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(PHONE_SURFACES, { claim: process.argv.slice(2).join(' ') })) console.log(row);
+}

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

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

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

@@ -152,6 +152,12 @@ export const TOOLS = Object.freeze([
     provides: 'city-phone-line-router-cost-envelope-for-8-byte-host-handles-and-cubes',
     gate: 'descriptor-only-physics_break-0-billing_bypass-0-provider_terms_apply-1',
   }),
+  Object.freeze({
+    id: 'cellphone-host-bridge-boundary',
+    path: 'tools/behcs/cellphone-host-bridge-boundary.mjs',
+    provides: 'cellphones-as-file-backed-8-byte-host-bridges-with-self-call-and-radio-gates',
+    gate: 'descriptor-only-provider_bypass-0-radio_bypass-0-process_launch-0',
+  }),
   Object.freeze({
     id: 'token-cube-catalog-binder',
     path: 'tools/behcs/token-cube-catalog-binder.mjs',
@@ -324,7 +330,7 @@ export function selfTest() {
     && !!toolById('model-selector-matrix') && !!toolById('project-guide-matrix')
     && !!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('pid-emitter-cost-envelope') && !!toolById('cellphone-host-bridge-boundary'));
   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 @@
-DA7D5EE5F3A582DF450C83D78E2A4EC22990EC5598BFE0A8DA353108661A0E6C  fabric-agent-preload-catalog.mjs
+934A9450CB0246F75EF7F96805912F65D4B3416DCC0E86FA61FB9F962BEFEACE  fabric-agent-preload-catalog.mjs