acer: LAW-STUB-AND-RUN declared + github deterministic PID system (live-format) + registered

LAW-STUB-AND-RUN (OP-JESSE apex-declared): the repo IS the stubbed neural-network
(topology + empty weight-sockets + gated organs); the live Asolaria fabric RUNS it.
Empty sockets / gated organs / CANNOT-SEE matrices = stubs-by-design (mechanism PROVEN,
fill OPERATOR-GATED), not gaps. Already implicit in TARGETARCHNOTE/EMPTYFULLLAW/
FROZENSLICEEMPTYSOCKET — this names + elevates it. CLASS-1 immutable canon mint stays
operator-pair-physical-cosign gated.

New tool github-pid-register.mjs: STATELESS deterministic PID minter in the LIVE fabric
format (ROLE-NAME-PID-Hhex-Atier-W1024-Pprime-Nnest, AGT/SUP/PROF triad), divisions
yin/yang(mod2) + prime-lane(mod3) + quad(mod4) + glyph_5/glyph_1024 + sector(mod113).
sha-derived so acer+liris mint byte-identical PIDs with zero coordination; live office
re-keys on ingest via the healthy bus :4947. 6/6 unit + golden triad (H4CD sector 81).

Registered: LAW triad (AGT/SUP/PROF-LAW-STUB-AND-RUN-PID-H4CD*), remembrance supervisor
(SUP-STUB-LAW-REMEMBRANCE-PID-H988A), frozen-brain slice PID (AGT-FROZEN-GEMMA-4B-SLICE,
socket empty/gated). Fabric diagnosis: nothing local down — :4947 bus HEALTHY, :4949 API
hangs on cross-vantage pollers (POLLER-HEALTH, not a dead daemon). No daemon launched,
no live mint, no canon mint. CLAIMSGATE clean, 0-json, 158->159 green.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

docs/ACER-LAW-STUB-AND-RUN-PID-REGISTRATION-2026-06-12.hbp

@@ -0,0 +1,13 @@
+LAWSTUBRUNHDR|host=acer|date=2026-06-12|type=LAW-CANDIDATE-plus-PID-REGISTRATION|declared_by=OP-JESSE-DANIEL-BROWN-apex-human|name=LAW-STUB-AND-RUN|class-1-immutable-mint=PENDING-operator-pair-physical-cosign|json=0
+LAWSTUBRUNSTATEMENT|law=the-bilateral-repo-ASOLARIA-AS-NEURAL-NETWORK-IS-the-STUBBED-system-the-topology-plus-empty-weight-sockets-plus-gated-organs|the-live-Asolaria-fabric-Super-OS-AgentTerms-frozen-Gemma-engines-is-what-RUNS-it|empty-sockets-gated-organs-CANNOT-SEE-matrices-and-draft-no-launch-no-fabric-call-seeds-are-STUBS-BY-DESIGN-mechanism-PROVEN-fill-OPERATOR-GATED-NOT-gaps|json=0
+LAWSTUBRUNWHY|repo=the-empty-untrained-network|fabric=the-same-network-running-with-weights-loaded|empty-vs-full=the-train-run-boundary|already-in-plan=TARGETARCHNOTE-gap-is-INTEGRATION-not-invention+EMPTYFULLLAW-github-empty-until-filled+FROZENSLICEEMPTYSOCKET-wire-mechanism-PROVEN-fill-GATED|this-law-NAMES-and-ELEVATES-that-frame-as-the-organizing-law-of-the-200-step-plan|json=0
+LAWSTUBRUNAPPLY|honesty-tag-a-stub-as=stub-by-design-mechanism-PROVEN-fill-OPERATOR-GATED-NOT-gap-or-unproven|every-component=PROVEN-primitive-plus-repo-stub-seed-plus-GAP-integration-wiring|building=filling-and-wiring-stubs-gated-by-operator-never-reinventing|json=0
+PIDMETHOD|registrar=github-pid-register.v1|method=STATELESS-DETERMINISTIC-sha-derived-PID-in-the-LIVE-fabric-format-learned-from-:4949-AgentTerms-lanes|format=ROLE-NAME-PID-Hhex-Atier-W1024-Pprime-Nnest-with-AGT-SUP-PROF-triad-sharing-the-name-derived-hex-base-suffix-C-A-B|divisions=yin-yang-mod2-real-or-logical+prime-lane-mod3-Law-of-Three+quad-mod4-the-operator-4-rule+glyph5-mod5+glyph1024-mod1024+sector-mod113|effect=coprime-moduli-force-stability-and-divide-collisions|json=0
+PIDGITHUBSYSTEM|insight=github-PIDs-must-be-STATELESS-and-sha-derived-so-acer-and-liris-mint-BYTE-IDENTICAL-PIDs-with-zero-coordination|the-live-PID-Registration-Office-re-keys-them-on-ingest-via-the-healthy-bus-:4947|this-is-the-NEW-github-PID-system-bilateral-reproducible-vs-the-live-office-stateful-sequential-mint|tag=PROVEN-deterministic-tested-6of6|json=0
+PIDLAWTRIAD|entity=LAW-STUB-AND-RUN|AGT=AGT-LAW-STUB-AND-RUN-PID-H4CDC-A00-W1024-P01-N00001|SUP=SUP-LAW-STUB-AND-RUN-PID-H4CDA-A00-W1024-P00-N00001|PROF=PROF-LAW-STUB-AND-RUN-PID-H4CDB-A00-W1024-P00-N00001|shared_base=H4CD|sector=81|lane=1|quad=0|cube_bh=BH.81.1.680|tier=A00-apex-law-level|json=0
+PIDREMEMBRANCE|supervisor=SUP-STUB-LAW-REMEMBRANCE-PID-H988A-A00-W1024-P00-N00001|role=ensure-LAW-STUB-AND-RUN-and-this-session-memory-do-NOT-fade|sector=69|cube_bh=BH.69.0.902|duty=on-every-bilateral-session-re-assert-the-stub-and-run-frame-and-link-the-memory-file|tag=SUPERVISOR-REGISTERED-descriptor-only|json=0
+PIDFROZENBRAIN|slice=AGT-FROZEN-GEMMA-4B-SLICE-PID-HBB4C-A04-W1024-P00-N00001|yin_yang=real|sector=87|cube_bh=BH.87.2.394|status=socket-EMPTY-per-FROZENSLICEEMPTYSOCKET-zero-bytes|fill_mechanism=PROVEN-slice-fill-OPERATOR-GATED|usable_when=a-timed-bitwise-deterministic-run-receipt-byte-anchors-the-frozen-weights|tag=PARTIAL-PID-registered-socket-empty-fill-gated|json=0
+FABRICDIAGNOSIS|asked=via-process-port-health-probes-since-:4949-api-is-degraded|watchdog=UP-pid-8756|bus-:4947=HEALTHY-behcs-health-200|:4949-super-dashboard=UP-but-api-pollers-HANG-on-cross-vantage-liris-falcon-calls-already-respawned-uptime-0s-still-hangs|:4950-:4952-:4953=UP|verdict=NOTHING-LOCAL-IS-DOWN-to-start-the-BUS-UNREACHABLE-is-cross-vantage-poller-hang-NOT-the-local-bus|fix=POLLER-HEALTH-isolation-or-cross-vantage-link-return-NOT-a-restart|json=0
+REGISTRATIONPATH|since-:4949-api-hangs=register-via-the-DETERMINISTIC-github-mint-now-the-live-office-ingests-via-healthy-bus-:4947-when-pollers-recover|no-daemon-launched|no-live-fabric-mint-performed|CLASS-1-immutable-canon-to-canon-laws-stays-operator-pair-physical-cosign-gated|json=0
+DASHBOARDUPGRADE|operator_directive=after-this-lands-the-fabric-upgrades-the-surfaces-with-the-LAW-and-PID-system-across-the-16-levels|targets=:4949-#agentterms+:8101-asolaria-nn-view+:5054-agentterms-safe-mirror+:4950-omnidispatcher|each_level=A00-through-A15-the-right-agents-see-the-stub-and-run-law-and-the-deterministic-PID-registry-at-their-tier|gate=fabric-side-upgrade-when-:4949-pollers-recover-this-doc-is-the-source-of-truth-to-fold|tag=PROPOSAL-fabric-side-16-level-upgrade|json=0
+LAWSTUBRUNFTR|state=LAW-STUB-AND-RUN-DECLARED-and-PID-REGISTERED-github-deterministic|next=liris-byte-verify-and-mint-the-SAME-PIDs-on-her-vantage-byte-parity+operator-physical-cosign-for-CLASS-1-canon+live-office-ingest-via-bus-when-recovered|nothing_minted_to_canon=1|nothing_launched=1|json=0

docs/ACER-LAW-STUB-AND-RUN-PID-REGISTRATION-2026-06-12.hbp.sha256

@@ -0,0 +1 @@
+1e39f15a00d4a6a2316e30ffdb45f850fea129c6f5166d029d46531b5f2e5da0  ACER-LAW-STUB-AND-RUN-PID-REGISTRATION-2026-06-12.hbp

tests/github-pid-register.unit.test.mjs

@@ -0,0 +1,43 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import {
+  KINDS, ROLES, SECTORS, emitRegistrationRows, mintPid, mintTriad, selfTest,
+} from '../tools/behcs/github-pid-register.mjs';
+
+test('self-test passes', () => {
+  assert.equal(selfTest().ok, true);
+});
+
+test('mints the LIVE fabric PID format (matches :4949 AgentTerms lanes)', () => {
+  const p = mintPid({ role: 'AGT', name: 'shannon', tier: 4, prime: 1 });
+  assert.match(p.pid, /^AGT-SHANNON-PID-H[0-9A-F]{4}-A04-W1024-P01-N00001$/);
+  assert.equal(p.hex.endsWith('C'), true); // AGT -> C suffix (live)
+});
+
+test('deterministic + stateless: same name mints byte-identical PID (bilateral parity)', () => {
+  assert.equal(mintPid({ role: 'SUP', name: 'LAW-STUB-AND-RUN' }).pid, mintPid({ role: 'SUP', name: 'law stub and run' }).pid);
+});
+
+test('divisions: yin/yang mod-2, prime-lane mod-3, quad mod-4, sector mod-113', () => {
+  const p = mintPid({ role: 'AGT', name: 'x', kind: 'real' });
+  assert.ok(KINDS.includes(p.yin_yang));
+  assert.ok([0, 1, 2].includes(p.lane));
+  assert.ok([0, 1, 2, 3].includes(p.quad));
+  assert.ok(p.sector >= 0 && p.sector < SECTORS);
+});
+
+test('triad shares hex base, role suffixes C/A/B (AGT/SUP/PROF)', () => {
+  const t = mintTriad({ name: 'LAW-STUB-AND-RUN' });
+  const base = t.AGT.hex.slice(0, 4);
+  assert.equal(t.SUP.hex.slice(0, 4), base);
+  assert.equal(t.PROF.hex.slice(0, 4), base);
+  assert.equal(t.AGT.hex.at(-1), ROLES.AGT);
+  assert.equal(t.SUP.hex.at(-1), ROLES.SUP);
+  assert.equal(t.PROF.hex.at(-1), ROLES.PROF);
+});
+
+test('registration rows are HBP-only, json=0 terminated, no inlined newlines', () => {
+  const rows = emitRegistrationRows(mintPid({ role: 'AGT', name: 'x' }));
+  assert.ok(rows.every((r) => r.endsWith('|json=0') && !r.includes('\n')));
+});

tests/github-pid-register.unit.test.mjs.sha256

@@ -0,0 +1 @@
+6ba09c95353955ae43cbf006ae7e47135584662a4f0e84c9448b4ad8460cadff  github-pid-register.unit.test.mjs

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

@@ -39,6 +39,7 @@ const sealedFiles = [
   'docs/ACER-SUPEROS-FABRIC-FOLD-200STEP-2026-06-12.hbp',
   'docs/ACER-HUMAN-FRONT-AGENT-BACK-PREDICTION-LANE-2026-06-12.hbp',
   'docs/ACER-VISUAL-PREDICTION-FROZEN-GEMMA-PROOF-GATE-2026-06-12.hbp',
+  'docs/ACER-LAW-STUB-AND-RUN-PID-REGISTRATION-2026-06-12.hbp',
   'docs/acer-ecosystem-fullbody-receipt-20260612.hbp',
   'docs/CLAIMSLEDGER-2026-06-12.hbp',
   'docs/CLAIMSGATE-PARITY-BASELINE-2026-06-12.hbp',
@@ -160,6 +161,7 @@ const sealedFiles = [
   'tools/behcs/answer-producer.hbp',
   'tools/behcs/kimi-desktop-surface-scan.mjs',
   'tools/behcs/kimi-desktop-surface-scan.hbp',
+  'tools/behcs/github-pid-register.mjs',
   'tools/omni-processor/omnitranslator-v0.js',
   'tests/agent-spawn-throughput-benchmark.unit.test.mjs',
   'tests/quant-huge-message-benchmark.unit.test.mjs',
@@ -170,6 +172,7 @@ const sealedFiles = [
   'tests/claims-gate.unit.test.mjs',
   'tests/answer-producer.unit.test.mjs',
   'tests/kimi-desktop-surface-scan.unit.test.mjs',
+  'tests/github-pid-register.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 @@
-B49805D7C5BFB4240CC5FCDAA4159AAAD544A15090102EFDB0EBCE9A0F265213  supervisor-collision-router.system.test.mjs
+891aafbba414903d1b72a9f801ce0f0b5870b0f441f5e63245e0c7a52b285c99  supervisor-collision-router.system.test.mjs

tools/behcs/github-pid-register.mjs

@@ -0,0 +1,97 @@
+import { createHash } from 'node:crypto';
+import { resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+// GITHUB-PID-REGISTER v1 — a STATELESS, DETERMINISTIC PID minter in the LIVE fabric
+// format (learned from the live :4949 AgentTerms lanes, e.g. AGT-SHANNON-PID-HD16C-
+// A04-W1024-P01-N00001). github PIDs are sha-derived so acer + liris mint BYTE-IDENTICAL
+// PIDs with zero coordination; the live PID Registration Office re-keys on ingest.
+// Divisions (forcing stability + dividing collisions): yin/yang = mod-2 (real|logical),
+// prime-lane = mod-3 (Law of Three), quad = mod-4 (the operator "4 rule", semantics to
+// confirm with the office), glyph_5 = mod-5, glyph_1024 = mod-1024 (BEHCS-1024), sector
+// = mod-113 (one of the 113 Asolaria sectors). All coprime-ish moduli reduce collisions.
+
+export const REGISTER_ID = 'github-pid-register.v1';
+export const SECTORS = 113;                 // 113 Asolaria sectors
+export const WIDTH = 1024;                  // BEHCS-1024 glyph width
+export const ROLES = Object.freeze({ AGT: 'C', SUP: 'A', PROF: 'B' }); // role -> hex suffix (live)
+export const KINDS = Object.freeze(['real', 'logical']);
+
+const sha256 = (t) => createHash('sha256').update(String(t), 'utf8').digest('hex');
+const u32 = (hex8) => parseInt(hex8, 16);
+
+// mint ONE deterministic live-format PID for (role, name) at access-tier + nest.
+export function mintPid({ role, name, tier = 4, nest = 1, kind = 'logical', prime = 0 }) {
+  if (!(role in ROLES)) throw new Error(`role-must-be-AGT-SUP-PROF:${role}`);
+  if (!KINDS.includes(kind)) throw new Error(`kind-must-be-real-or-logical:${kind}`);
+  const safe = String(name).toUpperCase().replace(/[^A-Z0-9]+/g, '-').replace(/^-|-$/g, '');
+  const h = sha256(safe);                           // base/divisions from NAME so the triad shares them (live shape)
+  const base3 = h.slice(0, 3).toUpperCase();        // 3 hex
+  const hex = base3 + ROLES[role];                  // + role char => H{D15C}-style 4 hex
+  const seed = u32(h.slice(0, 8));
+  const A = String(Math.max(0, Math.min(15, tier))).padStart(2, '0'); // 16 levels 00..15
+  const P = String(prime).padStart(2, '0');
+  const N = String(nest).padStart(5, '0');
+  const pid = `${role}-${safe}-PID-H${hex}-A${A}-W${WIDTH}-P${P}-N${N}`;
+  return {
+    pid, role, name: safe,
+    hex: `H${hex}`, tier: A, width: String(WIDTH), prime: P, nest: N,
+    yin_yang: kind,                                  // real | logical (mod-2 division)
+    lane: seed % 3,                                  // Law of Three (prime division)
+    quad: seed % 4,                                  // the "4 rule" (mod-4) — confirm w/ office
+    glyph_5: seed % 5,
+    glyph_1024: seed % WIDTH,
+    sector: seed % SECTORS,                          // one of the 113 sectors
+    hilbert: u32(h.slice(8, 16)),
+    cube_bh: `BH.${seed % SECTORS}.${seed % 3}.${seed % WIDTH}`, // sector.lane.glyph cube address
+    sha16: h.slice(0, 16),
+  };
+}
+
+// register an entity as the AGT/SUP/PROF triad sharing a hex base (the live lane shape).
+export function mintTriad({ name, tier = 4, kind = 'logical' }) {
+  return {
+    AGT: mintPid({ role: 'AGT', name, tier, kind, prime: 1, nest: 1 }),
+    SUP: mintPid({ role: 'SUP', name, tier, kind, prime: 0, nest: 1 }),
+    PROF: mintPid({ role: 'PROF', name, tier, kind, prime: 0, nest: 1 }),
+  };
+}
+
+// emit the office-faithful HBP registration rows for one PID.
+export function emitRegistrationRows(p, { kind_label = 'github_deterministic_pid', registrar = 'github-pid-register' } = {}) {
+  return [
+    `PIDREG|name=${p.name}|pid=${p.pid}|role=${p.role}|class=${kind_label}|json=0`,
+    `PIDADDR|pid=${p.pid}|hex=${p.hex}|tier=${p.tier}|width=${p.width}|prime=${p.prime}|nest=${p.nest}|hilbert=${p.hilbert}|sector=${p.sector}|json=0`,
+    `PIDDIV|pid=${p.pid}|yin_yang=${p.yin_yang}|lane_mod3=${p.lane}|quad_mod4=${p.quad}|glyph_5=${p.glyph_5}|glyph_1024=${p.glyph_1024}|note=divisions-force-stability-and-divide-collisions|json=0`,
+    `PIDCUBE|pid=${p.pid}|cube_bh=${p.cube_bh}|sha16=${p.sha16}|registrar=${registrar}|stateless_deterministic=1|live_office_rekeys_on_ingest=1|json=0`,
+  ];
+}
+
+export function selfTest() {
+  const checks = [];
+  const add = (n, ok) => checks.push({ name: n, ok });
+  const a = mintPid({ role: 'AGT', name: 'shannon', tier: 4, prime: 1 });
+  add('live-format-shape', /^AGT-SHANNON-PID-H[0-9A-F]{4}-A\d{2}-W1024-P\d{2}-N\d{5}$/.test(a.pid));
+  add('role-suffix-C-for-AGT', a.hex.endsWith('C'));
+  add('deterministic', mintPid({ role: 'AGT', name: 'shannon', tier: 4, prime: 1 }).pid === a.pid);
+  add('sector-in-113', a.sector >= 0 && a.sector < 113);
+  add('lane-in-3', [0, 1, 2].includes(a.lane));
+  add('quad-in-4', [0, 1, 2, 3].includes(a.quad));
+  add('yin-yang-enum', KINDS.includes(a.yin_yang));
+  const t = mintTriad({ name: 'LAW-STUB-AND-RUN' });
+  add('triad-shares-base', t.AGT.hex.slice(0, 4) === t.SUP.hex.slice(0, 4) && t.SUP.hex.slice(0, 4) === t.PROF.hex.slice(0, 4));
+  add('triad-role-suffixes', t.AGT.hex.endsWith('C') && t.SUP.hex.endsWith('A') && t.PROF.hex.endsWith('B'));
+  add('rows-hbp-only', emitRegistrationRows(a).every((r) => r.endsWith('|json=0') && !r.includes('\n')));
+  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);
+  }
+  const t = mintTriad({ name: process.argv[2] || 'LAW-STUB-AND-RUN', tier: 0, kind: 'logical' });
+  for (const role of ['AGT', 'SUP', 'PROF']) for (const row of emitRegistrationRows(t[role])) console.log(row);
+}

tools/behcs/github-pid-register.mjs.sha256

@@ -0,0 +1 @@
+4c0dbe77a343c50010823f3db33fe1b367a8d659b10d6ce6d1bf9f65e70fe2e3  github-pid-register.mjs