Hugging Face's logo

Jessedbrown
/
ASOLARIA-AS-NEURAL-NETWORK

Model card Files
xet
 Community
ASOLARIA-AS-NEURAL-NETWORK / tools /behcs /github-pid-register.mjs
Kevin Crutt
acer: close pixel room catches and pid reconcile
68d4c6a
Raw History Blame Contribute Delete
10.3 kB
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']);
export const KIND_BITS = Object.freeze({ logical: 0, real: 1 });
export const RUNTIMES = Object.freeze(['claude', 'codex', 'deepseek', 'opencode', 'gemini']);
export const AGENT_TYPES = Object.freeze(['LOGICAL-WAVE', 'FROZEN-BRAIN', 'REAL-FREE']);
export const REGISTER_AGENT_TUPLE_ID = 'github-pid-register-agent-tuple.v1';
export const UNIT_SEPARATOR = '\x1f';
const sha256 = (t) => createHash('sha256').update(String(t), 'utf8').digest('hex');
const u32 = (hex8) => parseInt(hex8, 16);
const safeTuplePart = (field, value) => {
const s = String(value ?? '');
if (!s) throw new Error(`${field}-required`);
if (/[|\r\n\x1f]/.test(s)) throw new Error(`${field}-contains-hbp-or-tuple-delimiter`);
return s;
};
export function tuplePreimage(parts) {
return [REGISTER_AGENT_TUPLE_ID, ...parts].map((part, i) => {
const s = safeTuplePart(`tuple_${i}`, part);
return `${Buffer.byteLength(s, 'utf8')}:${s}`;
}).join(UNIT_SEPARATOR);
}
// 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)
yin_yang_bit: KIND_BITS[kind],
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}|yin_yang_bit=${p.yin_yang_bit}|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`,
];
}
// Separation law:
// logical -> LOGICAL-WAVE (1e200-style reasoning agents: Claude/Codex/DeepSeek/etc.)
// real + even prime -> FROZEN-BRAIN (deterministic local slice, e.g. frozen Gemma)
// real + odd prime -> REAL-FREE (deterministic shelless scale sweep)
export function classifyAgentType({ yin_yang, prime }) {
if (yin_yang === 'logical') return 'LOGICAL-WAVE';
const n = Number.parseInt(String(prime), 10);
return Number.isFinite(n) && n % 2 === 1 ? 'REAL-FREE' : 'FROZEN-BRAIN';
}
// Open runtime registry: known models are first-class, but any model name is accepted.
export function registerAgent({ runtime, name, role = 'AGT', tier = 4, kind = 'logical', prime = 0, nest = 1 }) {
const rt = String(runtime || '').toLowerCase().replace(/[^a-z0-9.-]+/g, '-').replace(/^-|-$/g, '');
if (!rt) throw new Error('runtime-required-accepts-any-model-name');
const rawName = safeTuplePart('name', name);
const safeName = rawName.toUpperCase().replace(/[^A-Z0-9]+/g, '-').replace(/^-|-$/g, '');
if (!safeName) throw new Error('name-required-after-sanitize');
const agentType = classifyAgentType({ yin_yang: kind, prime });
const identityPreimage = tuplePreimage(['REGISTER_AGENT', rt, agentType, rawName, kind, String(prime)]);
const identitySha16 = sha256(identityPreimage).slice(0, 16);
const p = mintPid({ role, name: `${rt.toUpperCase()}-${agentType}-${safeName}-G${identitySha16.slice(0, 8).toUpperCase()}`, tier, kind, prime, nest });
return {
...p,
runtime: rt,
known_runtime: RUNTIMES.includes(rt),
agent_type: agentType,
register_identity_sha16: identitySha16,
};
}
export function emitAgentRow(a) {
return `AGENTPID|runtime=${a.runtime}|known_runtime=${a.known_runtime ? 1 : 0}|agent_type=${a.agent_type}|pid=${a.pid}|register_identity_sha16=${a.register_identity_sha16 || 'none'}|tier=${a.tier}|yin_yang=${a.yin_yang}|yin_yang_bit=${a.yin_yang_bit}|lane_mod3=${a.lane}|quad_mod4=${a.quad}|sector=${a.sector}|cube_bh=${a.cube_bh}|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));
add('yin-yang-bit', a.yin_yang === 'logical' && a.yin_yang_bit === 0);
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')));
add('separation-logical-wave', classifyAgentType({ yin_yang: 'logical', prime: 0 }) === 'LOGICAL-WAVE');
add('separation-frozen-brain', classifyAgentType({ yin_yang: 'real', prime: 0 }) === 'FROZEN-BRAIN');
add('separation-real-free', classifyAgentType({ yin_yang: 'real', prime: 1 }) === 'REAL-FREE');
add('known-runtimes-register', RUNTIMES.every((rt) => registerAgent({ runtime: rt, name: 'x' }).runtime === rt));
add('gemini-is-known', RUNTIMES.includes('gemini'));
add('any-model-registers', (() => {
const model = registerAgent({ runtime: 'mistral.next', name: 'x' });
return model.runtime === 'mistral.next' && model.known_runtime === false && AGENT_TYPES.includes(model.agent_type);
})());
add('kind-load-bearing-in-agent-pid', registerAgent({ runtime: 'claude', name: 'worker', kind: 'logical' }).pid
!== registerAgent({ runtime: 'claude', name: 'worker', kind: 'real' }).pid);
add('register-agent-preimage-no-hyphen-collision', registerAgent({ runtime: 'claude', name: 'LOGICAL-WAVE-WORKER', kind: 'logical' }).pid
!== registerAgent({ runtime: 'claude-logical-wave', name: 'WORKER', kind: 'logical' }).pid);
add('register-identity-sha16', /^[0-9a-f]{16}$/.test(registerAgent({ runtime: 'claude', name: 'worker' }).register_identity_sha16));
add('empty-runtime-rejected', (() => { try { registerAgent({ runtime: '', name: 'x' }); return false; } catch { return true; } })());
add('agent-row-hbp', emitAgentRow(registerAgent({ runtime: 'claude', name: 'x' })).endsWith('|json=0'));
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);
}