liris: add route health baseline

docs/LIRIS-ROUTE-HEALTH-BASELINE-2026-06-13.hbp

@@ -0,0 +1,7 @@
+LIRISRHBHDR|host=liris|date=2026-06-13|topic=route-health-baseline-core-fabric-ports|responds_to=operator-continue+acer-next-queue-route-health-baseline+ask-fabric-council-q-1781391748125-66153y|mode=read-only-probe-only|tag=PROVEN-LIVE|json=0
+LIRISRHBWHAT|tool=tools/behcs/route-health-baseline.mjs|test=tests/route-health-baseline.unit.test.mjs|targets=127.0.0.1:4944-health+127.0.0.1:4947-health+192.168.1.50:4949-health|emits=RHBHDR+RHBROUTE+RHBSUM+RHBGATE|process_launch=0|tag=PROVEN|json=0
+LIRISRHBASKFABRIC|council_request=council-q-1781391748125-66153y|fabric_health=4944-UP-service-super-asolaria-os-dashboard-liris-mirror|fabric_self_status=bases-127.0.0.1-4944+192.168.1.50-4949|fabric_route_map=acer-route-map-visible-through-HBP-any-with-pool+omnispindle+omniflywheel+behcs1024|tag=OBSERVED|json=0
+LIRISRHBLIVEPROBE|ts=2026-06-14T01:21:53.519Z|liris_mirror_4944=UP-http200-latency51ms-body_sha16-EF05AA02D91DDD2C|behcs_bus_4947=ROUTE_BOUNDARY-http404-latency23ms-body_sha16-7EE09A56CB814E42|acer_fabric_4949=UP-http200-latency6ms-body_sha16-3E78F83A1F072752|summary=up2-boundary1-down0-timeout0-unprobed0-answered3-all_core_answered1-all_core_up0|tag=PROVEN-LIVE|json=0
+LIRISRHBBOUNDARY|meaning_4947=port-answers-but-/health-is-not-the-bus-health-contract-on-this-vantage|not_an_outage=1|no_restart=1|no_spawn=1|no_write=1|no_mint=1|repair_requires_operator-gated-supervisor-step-not-this-tool|tag=BOUNDARY|json=0
+LIRISRHBVERIFY|node_check=OK|self_test=7-of-7-PASS|unit_test=9-of-9-PASS|live_probe=3-of-3-answered|hbp_rows_only=1|injection_safe=1|body_sha16_preserved=1|tag=PROVEN|json=0
+LIRISRHBFT|state=ROUTE-HEALTH-BASELINE-BUILT|next=ask-fabric-after-push-for-specific-4947-health-contract-or-next-not-yet-built-item|cosign=not-touched|json=0

docs/LIRIS-ROUTE-HEALTH-BASELINE-2026-06-13.hbp.sha256

@@ -0,0 +1 @@
+9333E05A3D70AE866682266FB2151476F50FE7A0BCE9A409677219F828BB57F9  LIRIS-ROUTE-HEALTH-BASELINE-2026-06-13.hbp

tests/route-health-baseline.unit.test.mjs

@@ -0,0 +1,91 @@
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import test from 'node:test';
+
+import {
+  ROUTE_TARGETS,
+  emitRows,
+  normalizeProbe,
+  probeTarget,
+  routeHealthBaseline,
+  selfTest,
+} from '../tools/behcs/route-health-baseline.mjs';
+
+const repo = dirname(dirname(fileURLToPath(import.meta.url)));
+
+test('self-test passes', () => {
+  assert.equal(selfTest().ok, true);
+});
+
+test('the three core route targets are fixed and ordered', () => {
+  assert.deepEqual(ROUTE_TARGETS.map((t) => `${t.id}:${new URL(t.base).port}`), [
+    'liris_mirror_4944:4944',
+    'behcs_bus_4947:4947',
+    'acer_fabric_4949:4949',
+  ]);
+});
+
+test('probe states classify UP, route boundary, degraded, down, timeout, and unprobed', () => {
+  assert.equal(normalizeProbe({ id: 'liris_mirror_4944', ok: true, http_status: 200 }).state, 'UP');
+  assert.equal(normalizeProbe({ id: 'liris_mirror_4944', http_status: 404 }).state, 'ROUTE_BOUNDARY');
+  assert.equal(normalizeProbe({ id: 'liris_mirror_4944', http_status: 503 }).state, 'HTTP_DEGRADED');
+  assert.equal(normalizeProbe({ id: 'liris_mirror_4944', error: 'ECONNREFUSED' }).state, 'DOWN');
+  assert.equal(normalizeProbe({ id: 'liris_mirror_4944', error: 'timeout' }).state, 'TIMEOUT');
+  assert.equal(normalizeProbe({ id: 'liris_mirror_4944' }).state, 'UNPROBED');
+});
+
+test('baseline fills missing targets and summarizes answered/up counts', () => {
+  const b = routeHealthBaseline([
+    { id: 'liris_mirror_4944', ok: true, http_status: 200 },
+    { id: 'acer_fabric_4949', http_status: 404 },
+  ], { ts: '2026-06-13T23:00:00.000Z' });
+  assert.equal(b.results.length, 3);
+  assert.equal(b.summary.up, 1);
+  assert.equal(b.summary.route_boundary, 1);
+  assert.equal(b.summary.unprobed, 1);
+  assert.equal(b.summary.answered, 2);
+  assert.equal(b.summary.all_core_answered, false);
+});
+
+test('emitted rows are HBP-only, single-line, and read-only gated', () => {
+  const rows = emitRows(routeHealthBaseline([
+    { id: 'liris_mirror_4944', ok: true, http_status: 200, error: 'x|json=0\nFAKE|x=1' },
+  ]));
+  assert.ok(rows.every((r) => r.endsWith('|json=0') && !/[\r\n]/.test(r) && !r.includes('{"')));
+  assert.ok(rows.some((r) => r.startsWith('RHBGATE|') && r.includes('no_spawn=1') && r.includes('no_restart=1')));
+});
+
+test('body_sha16 is preserved when normalized baselines are emitted', () => {
+  const b = routeHealthBaseline([{ id: 'liris_mirror_4944', ok: true, http_status: 200, body: 'route-health-proof-body' }]);
+  const hash = b.results[0].body_sha16;
+  assert.notEqual(hash, 'E3B0C44298FC1C14');
+  assert.ok(emitRows(b).some((r) => r.includes(`body_sha16=${hash}`)));
+});
+
+test('probeTarget supports injected read-only fetchers', async () => {
+  const target = ROUTE_TARGETS[0];
+  const result = await probeTarget(target, {
+    timeoutMs: 100,
+    fetcher: async (url, opts) => {
+      assert.equal(url, 'http://127.0.0.1:4944/health');
+      assert.equal(opts.method, 'GET');
+      return { ok: true, status: 200, text: async () => '{"ok":true}' };
+    },
+  });
+  assert.equal(result.state, 'UP');
+  assert.equal(result.source, 'live-fetch');
+});
+
+test('probeTarget turns fetch failures into DOWN/TIMEOUT observations, not throws', async () => {
+  const down = await probeTarget(ROUTE_TARGETS[0], { fetcher: async () => { throw new Error('ECONNREFUSED'); } });
+  assert.equal(down.state, 'DOWN');
+  const timeout = await probeTarget(ROUTE_TARGETS[0], { fetcher: async () => { const e = new Error('abort'); e.name = 'AbortError'; throw e; } });
+  assert.equal(timeout.state, 'TIMEOUT');
+});
+
+test('tool has no spawn/exec/write/mint/restart capability', () => {
+  const src = readFileSync(join(repo, 'tools/behcs/route-health-baseline.mjs'), 'utf8');
+  assert.equal(/child_process|spawnSync|\.spawn\(|execSync|writeFileSync|appendFileSync|mintPid|Start-Process|Stop-Process/.test(src), false);
+});

tests/route-health-baseline.unit.test.mjs.sha256

@@ -0,0 +1 @@
+A54EF188069EB4D937113DB2DDFD3E39D8E75CD258D8AE560872066485917EFB  route-health-baseline.unit.test.mjs

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

@@ -90,6 +90,7 @@ const sealedFiles = [
   'docs/LIRIS-SLICE-ENGINE-LAW-2026-06-13.hbp',
   'docs/LIRIS-SELFHEAL-200STEP-INTEGRATION-2026-06-13.hbp',
   'docs/ACER-SLICE-ENGINE-LIVE-CRANK-RECEIPT-2026-06-13.hbp',
+  'docs/LIRIS-ROUTE-HEALTH-BASELINE-2026-06-13.hbp',
   'docs/acer-ecosystem-fullbody-receipt-20260612.hbp',
   'docs/CLAIMSLEDGER-2026-06-12.hbp',
   'docs/CLAIMSGATE-PARITY-BASELINE-2026-06-12.hbp',
@@ -208,6 +209,7 @@ const sealedFiles = [
   'tools/behcs/mlc-line-watcher.mjs',
   'tools/behcs/omni-engine-loop.mjs',
   'tools/behcs/heal-envelope-emitter.mjs',
+  'tools/behcs/route-health-baseline.mjs',
   'tools/behcs/logical-extreme-stress.mjs',
   'tools/behcs/logical-stress-cube-feed.mjs',
   'tools/behcs/brown-hilbert-expansion-stress.mjs',
@@ -234,6 +236,7 @@ const sealedFiles = [
   'tests/mlc-line-watcher.unit.test.mjs',
   'tests/omni-engine-loop.unit.test.mjs',
   'tests/heal-envelope-emitter.unit.test.mjs',
+  'tests/route-health-baseline.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 @@
-A4E6ACAC4E1705770C3C685D97B6ACE41731322418AA4811F68F670360E5B45C  supervisor-collision-router.system.test.mjs
+88B8683F149B8BAC6E4C291AD94A27479EA388DC27F3423C3A3A90DBC156F044  supervisor-collision-router.system.test.mjs

tools/behcs/route-health-baseline.mjs

@@ -0,0 +1,198 @@
+#!/usr/bin/env node
+// route-health-baseline.mjs - read-only health baseline for the core fabric routes.
+//
+// CONTEXT (operator continue cycle 2026-06-13): after SLICE-ENGINE-LAW and the
+// heal-envelope-emitter, the next queued item is a route-health baseline for the
+// core moving lanes: Liris mirror :4944, BEHCS bus :4947, Acer fabric :4949.
+//
+// SAFETY: probe-only, HBP rows only, no spawn/exec/write/mint/restart. A DOWN or
+// BOUNDARY result is an observation, not an action. Engines remain operator-gated.
+
+import { createHash } from 'node:crypto';
+import { resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+export const TOOL_ID = 'route-health-baseline.v1';
+export const ROUTE_TARGETS = Object.freeze([
+  Object.freeze({ id: 'liris_mirror_4944', role: 'liris-mirror-dashboard', base: 'http://127.0.0.1:4944', path: '/health' }),
+  Object.freeze({ id: 'behcs_bus_4947', role: 'behcs-bus', base: 'http://127.0.0.1:4947', path: '/health' }),
+  Object.freeze({ id: 'acer_fabric_4949', role: 'acer-fabric-dashboard', base: 'http://192.168.1.50:4949', path: '/health' }),
+]);
+
+const STATES = Object.freeze(['UP', 'ROUTE_BOUNDARY', 'HTTP_DEGRADED', 'DOWN', 'TIMEOUT', 'UNPROBED']);
+const safe = (s) => { try { return String(s == null ? '' : s).replace(/[|\r\n]/g, '_'); } catch { return '_'; } };
+const sha16 = (s) => createHash('sha256').update(String(s ?? ''), 'utf8').digest('hex').slice(0, 16).toUpperCase();
+const isObj = (x) => x !== null && typeof x === 'object';
+
+function targetById(id) {
+  return ROUTE_TARGETS.find((t) => t.id === id);
+}
+
+function portOf(base) {
+  try {
+    const u = new URL(base);
+    return Number(u.port || (u.protocol === 'https:' ? 443 : 80));
+  } catch {
+    return 0;
+  }
+}
+
+function stateFor(sample) {
+  const status = Number(sample.http_status || 0);
+  const error = safe(sample.error).toLowerCase();
+  if (sample.ok === true && status >= 200 && status < 300) return 'UP';
+  if ([400, 401, 403, 404].includes(status)) return 'ROUTE_BOUNDARY';
+  if (status > 0) return 'HTTP_DEGRADED';
+  if (error.includes('timeout') || error.includes('abort')) return 'TIMEOUT';
+  if (error) return 'DOWN';
+  return 'UNPROBED';
+}
+
+export function normalizeProbe(sample = {}) {
+  const raw = isObj(sample) ? sample : {};
+  const target = targetById(raw.id) || {};
+  const base = raw.base || target.base || '';
+  const path = raw.path || target.path || '/health';
+  const body = raw.body == null ? '' : String(raw.body).slice(0, 512);
+  const priorHash = /^[0-9A-Fa-f]{16}$/.test(String(raw.body_sha16 || '')) ? String(raw.body_sha16).toUpperCase() : '';
+  const out = {
+    id: safe(raw.id || target.id || 'unknown'),
+    role: safe(raw.role || target.role || 'unknown'),
+    base: safe(base),
+    port: Number(raw.port || portOf(base)),
+    path: safe(path),
+    ok: raw.ok === true,
+    http_status: Number(raw.http_status || 0),
+    latency_ms: Number.isFinite(raw.latency_ms) ? Math.max(0, Math.round(raw.latency_ms)) : 0,
+    source: safe(raw.source || 'sample'),
+    error: safe(raw.error || ''),
+    body_sha16: priorHash || sha16(body),
+  };
+  out.state = STATES.includes(raw.state) ? raw.state : stateFor(out);
+  out.answered = ['UP', 'ROUTE_BOUNDARY', 'HTTP_DEGRADED'].includes(out.state);
+  return out;
+}
+
+export function routeHealthBaseline(samples = [], opts = {}) {
+  const byId = new Map((Array.isArray(samples) ? samples : []).map((s) => [s?.id, s]));
+  const results = ROUTE_TARGETS.map((target) => normalizeProbe(byId.get(target.id) || { ...target, source: 'unprobed' }));
+  const counts = Object.fromEntries(STATES.map((s) => [s, results.filter((r) => r.state === s).length]));
+  const answered = results.filter((r) => r.answered).length;
+  return {
+    tool: TOOL_ID,
+    ts: opts.ts || new Date().toISOString(),
+    process_launch: 0,
+    read_only: true,
+    results,
+    summary: {
+      target_count: ROUTE_TARGETS.length,
+      up: counts.UP,
+      route_boundary: counts.ROUTE_BOUNDARY,
+      http_degraded: counts.HTTP_DEGRADED,
+      down: counts.DOWN,
+      timeout: counts.TIMEOUT,
+      unprobed: counts.UNPROBED,
+      answered,
+      all_core_up: counts.UP === ROUTE_TARGETS.length,
+      all_core_answered: answered === ROUTE_TARGETS.length,
+    },
+  };
+}
+
+export function emitRows(input) {
+  try {
+    const baseline = isObj(input) && Array.isArray(input.results) ? input : routeHealthBaseline([]);
+    const s = baseline.summary || {};
+    const rows = [
+      `RHBHDR|tool=${TOOL_ID}|ts=${safe(baseline.ts)}|target_count=${safe(s.target_count)}|read_only=1|process_launch=0|json=0`,
+    ];
+    for (const r of baseline.results.map(normalizeProbe)) {
+      rows.push(`RHBROUTE|id=${safe(r.id)}|role=${safe(r.role)}|base=${safe(r.base)}|port=${safe(r.port)}|path=${safe(r.path)}|state=${safe(r.state)}|http_status=${safe(r.http_status)}|latency_ms=${safe(r.latency_ms)}|source=${safe(r.source)}|error=${safe(r.error)}|body_sha16=${safe(r.body_sha16)}|json=0`);
+    }
+    rows.push(`RHBSUM|up=${safe(s.up)}|route_boundary=${safe(s.route_boundary)}|http_degraded=${safe(s.http_degraded)}|down=${safe(s.down)}|timeout=${safe(s.timeout)}|unprobed=${safe(s.unprobed)}|answered=${safe(s.answered)}|all_core_up=${s.all_core_up ? 1 : 0}|all_core_answered=${s.all_core_answered ? 1 : 0}|json=0`);
+    rows.push('RHBGATE|read_only=1|probe_only=1|no_spawn=1|no_write=1|no_mint=1|no_restart=1|operator_gate_for_repair=1|tag=PROVEN-READONLY-BASELINE|json=0');
+    return rows;
+  } catch {
+    return [
+      `RHBHDR|tool=${TOOL_ID}|ts=INVALID|target_count=${ROUTE_TARGETS.length}|read_only=1|process_launch=0|json=0`,
+      'RHBERROR|error=emit-threw-on-hostile-input|json=0',
+      'RHBGATE|read_only=1|probe_only=1|no_spawn=1|no_write=1|no_mint=1|no_restart=1|operator_gate_for_repair=1|tag=INVALID-HELD|json=0',
+    ];
+  }
+}
+
+export async function probeTarget(target, opts = {}) {
+  const started = Date.now();
+  const fetcher = opts.fetcher || globalThis.fetch;
+  const timeoutMs = Number.isFinite(opts.timeoutMs) ? Math.max(1, opts.timeoutMs) : 1500;
+  const base = target?.base || '';
+  const path = target?.path || '/health';
+  if (typeof fetcher !== 'function') {
+    return normalizeProbe({ ...target, source: 'live-fetch', error: 'fetch-unavailable', latency_ms: Date.now() - started });
+  }
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const url = new URL(path, base).toString();
+    const response = await fetcher(url, { method: 'GET', signal: controller.signal, headers: { accept: 'application/json,text/plain,*/*' } });
+    const body = typeof response.text === 'function' ? await response.text() : '';
+    return normalizeProbe({
+      ...target,
+      source: 'live-fetch',
+      ok: response.ok === true,
+      http_status: response.status,
+      latency_ms: Date.now() - started,
+      body,
+    });
+  } catch (err) {
+    const name = err && err.name === 'AbortError' ? 'timeout' : (err?.code || err?.message || 'fetch-error');
+    return normalizeProbe({ ...target, source: 'live-fetch', error: name, latency_ms: Date.now() - started });
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+export async function probeRoutes(opts = {}) {
+  const results = [];
+  for (const target of ROUTE_TARGETS) {
+    results.push(await probeTarget(target, opts));
+  }
+  return routeHealthBaseline(results, { ts: opts.ts });
+}
+
+export function selfTest() {
+  const samples = [
+    { id: 'liris_mirror_4944', ok: true, http_status: 200, latency_ms: 12, body: '{"ok":true}' },
+    { id: 'behcs_bus_4947', error: 'ECONNREFUSED', latency_ms: 4 },
+    { id: 'acer_fabric_4949', http_status: 404, latency_ms: 30, body: '{"routes":["/health"]}' },
+  ];
+  const b = routeHealthBaseline(samples, { ts: '2026-06-13T23:00:00.000Z' });
+  const rows = emitRows(b);
+  const checks = [
+    ['three-targets', b.results.length === 3],
+    ['state-classification', b.results[0].state === 'UP' && b.results[1].state === 'DOWN' && b.results[2].state === 'ROUTE_BOUNDARY'],
+    ['summary-counts', b.summary.up === 1 && b.summary.down === 1 && b.summary.route_boundary === 1 && b.summary.answered === 2],
+    ['hbp-only', rows.every((r) => r.endsWith('|json=0') && !/[\r\n]/.test(r) && !r.includes('{"'))],
+    ['gate-readonly', rows.some((r) => r.startsWith('RHBGATE|') && r.includes('no_restart=1'))],
+    ['injection-safe', emitRows(routeHealthBaseline([{ id: 'liris_mirror_4944', error: 'x|json=0\nFAKE|x=1' }])).every((r) => !/[\r\n]/.test(r))],
+    ['body-hash-preserved', rows.some((r) => r.includes(`body_sha16=${b.results[0].body_sha16}`)) && b.results[0].body_sha16 !== sha16('')],
+  ].map(([name, ok]) => ({ name, ok: Boolean(ok) }));
+  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.includes('--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);
+  }
+  const baseline = process.argv.includes('--probe')
+    ? await probeRoutes()
+    : routeHealthBaseline([
+      { id: 'liris_mirror_4944', ok: true, http_status: 200, latency_ms: 0, source: 'fabric-health-read', body: 'ok=true service=super-asolaria-os-dashboard-liris-mirror port=4944' },
+      { id: 'behcs_bus_4947', source: 'not-probed-in-demo' },
+      { id: 'acer_fabric_4949', http_status: 404, source: 'fabric-route-map-read', body: 'route-map-visible health-path-boundary' },
+    ], { ts: '2026-06-13T23:00:00.000Z' });
+  for (const row of emitRows(baseline)) console.log(row);
+}

tools/behcs/route-health-baseline.mjs.sha256

@@ -0,0 +1 @@
+9BA42D52CBED8603AFD7552AF7742BE23B93882E6B950BCBD97D52FC45399A2D  route-health-baseline.mjs