@aria_asi/cli 0.2.39 → 0.2.41

package/scripts/self-test-stop-gate-kernel-guards.mjs

@@ -0,0 +1,185 @@
+#!/usr/bin/env node
+// self-test-stop-gate-kernel-guards — exercises the G1/G6 kernel-driven
+// guards by stdin-driving aria-stop-gate.mjs with synthetic Stop events.
+//
+// Bypasses every non-kernel block trigger (mizan, drift, code-quality,
+// domain, discovery, impl-coupling, substrate) by setting environment
+// vars and providing inputs that none of them flag, leaving the kernel
+// guard as the only possible source of a block decision.
+//
+// Doctrine: this is the load-bearing proof that G1/G6 fire as designed.
+// Without it the guards are parse-checked only — and parse is not
+// behavior. Per plan §12 G1/G6 receipts + the close-the-gap commitment
+// 2026-05-17, this completes the first-class triplet (thinking +
+// implementation + accountability).
+
+import { spawnSync } from 'node:child_process';
+import { resolve, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const HERE = dirname(fileURLToPath(import.meta.url));
+const HOOK_PATH = resolve(HERE, '..', '..', '..', 'ops', 'claude-hooks', 'aria-stop-gate.mjs');
+
+let pass = 0;
+let fail = 0;
+
+function ok(name) { console.log(`  ok  - ${name}`); pass += 1; }
+function bad(name, detail) { console.log(`  FAIL- ${name}\n        ${detail}`); fail += 1; }
+
+function runStopGate({ userText, assistantText, env = {} }) {
+  // The hook reads its event from stdin (Claude Code's hook protocol).
+  // It looks up the assistant text from the transcript by sessionId. To
+  // avoid wiring a fake transcript, we set the assistant text via the
+  // synthetic test env var that the hook respects when present (the
+  // kernel guards read assistantText after universal-turn-packet has run
+  // — we short-circuit by providing both fields directly in the event).
+  const event = {
+    session_id: 'self-test-' + Date.now(),
+    transcript_path: '/dev/null',
+    hook_event_name: 'Stop',
+    stop_hook_active: false,
+    // Synthetic transcript injection: the test harness convention is
+    // that test_assistant_text + test_user_text override the message
+    // window load when ARIA_STOP_GATE_TEST_MODE=1 is set.
+    test_assistant_text: assistantText,
+    test_user_text: userText,
+  };
+  const child = spawnSync('node', [HOOK_PATH], {
+    input: JSON.stringify(event),
+    env: {
+      ...process.env,
+      ARIA_STOP_GATE_TEST_MODE: '1',
+      ARIA_STOP_GATE_SKIP_NETWORK: '1',
+      // Force-disable every non-kernel block so the only block source is G1/G6:
+      ARIA_DRIFT_TRIGGER_MAP_PATH: '/dev/null',
+      ARIA_STOP_GATE_SKIP_VALIDATE_OUTPUT: '1',
+      ARIA_STOP_GATE_SKIP_HIVE_LOOKUP: '1',
+      ...env,
+    },
+    encoding: 'utf8',
+    timeout: 10000,
+  });
+  return {
+    exitCode: child.status,
+    stdout: child.stdout || '',
+    stderr: child.stderr || '',
+  };
+}
+
+// ─── Test 1 (control): well-formed substantive emit should NOT block on kernel
+//
+// The hook may still block on cognition-presence (non-trivial emit lacking
+// <cognition> block). To isolate the kernel guard outcome we keep the
+// assistantText below NON_TRIVIAL_MIN_CHARS=300 and accept exit=0 as proof
+// the kernel did not force_reauthor.
+const t1 = runStopGate({
+  userText: 'continue with G1',
+  assistantText: 'wired G1 helper, ran self-test, exit 0',
+});
+if (t1.exitCode === 0) {
+  ok('benign short emit passes (kernel does not block well-formed output)');
+} else {
+  bad('benign short emit passes', `exit=${t1.exitCode}, stderr=${t1.stderr.slice(0, 300)}`);
+}
+
+// ─── Test 2: explicit ARIA_KERNEL_GATE_DISABLE bypasses the guard
+const t2 = runStopGate({
+  userText: 'continue',
+  assistantText: 'you are right, done, shipped',
+  env: { ARIA_KERNEL_GATE_DISABLE: '1' },
+});
+// With kernel guard disabled and the rest of the hook short-circuited by the
+// test-mode flag, exit should be non-2 (kernel guard didn't fire).
+if (t2.exitCode !== 2 || !/Kernel behavioral guard/.test(t2.stderr)) {
+  ok('ARIA_KERNEL_GATE_DISABLE=1 suppresses the G1 violation entry');
+} else {
+  bad('ARIA_KERNEL_GATE_DISABLE=1 suppresses guard', `still saw kernel guard violation in stderr`);
+}
+
+// ─── Test 3: helper-level integration — load the live helper that the hook
+//
+// uses and assert it returns force_reauthor for each failure class plus
+// allow for the benign case. This is the contract the hook depends on.
+const { evaluateWithKernel } = await import(resolve(HERE, '..', 'runtime-src', 'lib', 'evaluate-with-kernel.mjs'));
+
+const t3a = evaluateWithKernel({
+  surface: 'self-test', phase: 'stop',
+  observation: { kind: 'output_emit', source: 'claude-code-stop', severity: 'high',
+    summary: 'shipped, all green',
+    attrs: { hasCompletionLang: true, hasVerifyBlock: false, evidenceAnchorCount: 0 } },
+  evidence: [],
+});
+if (t3a.decision === 'force_reauthor' && t3a.classification.action_class === 'claim_without_evidence') {
+  ok('claim_without_evidence input → force_reauthor');
+} else {
+  bad('claim_without_evidence input → force_reauthor',
+    `got decision=${t3a.decision} class=${t3a.classification.action_class}`);
+}
+
+const t3b = evaluateWithKernel({
+  surface: 'self-test', phase: 'stop',
+  observation: { kind: 'output_emit', source: 'claude-code-stop', severity: 'low',
+    summary: 'you are right',
+    attrs: { hasAgreementLang: true, evidenceAnchorCount: 0 } },
+  evidence: [],
+});
+if (t3b.decision === 'force_reauthor' && t3b.classification.action_class === 'sycophancy_shape') {
+  ok('sycophancy_shape input → force_reauthor');
+} else {
+  bad('sycophancy_shape input → force_reauthor',
+    `got decision=${t3b.decision} class=${t3b.classification.action_class}`);
+}
+
+const t3c = evaluateWithKernel({
+  surface: 'self-test', phase: 'stop_goal_contract',
+  observation: { kind: 'goal_contract_eval', source: 'claude-output-vs-prompt', severity: 'low',
+    summary: 'let me explain the architecture and how all the components fit together. The system has a kernel, a coach, and a set of hooks. The kernel evaluates observations. The coach forwards decisions. The hooks fire on lifecycle events. Each layer talks to the next. The decision logic flows from the runtime to the gate to the recovery prose. There is no advance verb in this entire description — it is purely mechanism. The user asked for continuation but this response explains the mechanism instead of advancing concrete state. Long-enough to exceed the textLength guard.',
+    // textLength > 500 required (kernel guard against short planning text false-positives)
+    attrs: { continuationRequested: true, hasAdvanceLang: false, textLength: 800 } },
+  evidence: [],
+});
+if (t3c.decision === 'force_reauthor' && t3c.classification.action_class === 'mechanism_description_only') {
+  ok('mechanism_description_only input → force_reauthor');
+} else {
+  bad('mechanism_description_only input → force_reauthor',
+    `got decision=${t3c.decision} class=${t3c.classification.action_class}`);
+}
+
+const t3d = evaluateWithKernel({
+  surface: 'self-test', phase: 'stop',
+  observation: { kind: 'output_emit', source: 'claude-code-stop', severity: 'low',
+    summary: 'wired G1, ran tests, exit 0',
+    attrs: { hasAdvanceLang: true, hasVerifyBlock: true, lensCount: 8, codeBlockCount: 1, evidenceAnchorCount: 3 } },
+  evidence: [
+    { anchor_type: 'command', source: 'bash', observed: 'exit 0' },
+    { anchor_type: 'command', source: 'sync_gate', observed: 'vendor=atlas' },
+  ],
+});
+if (t3d.decision === 'allow' && t3d.classification.action_class === 'output_emit_ok') {
+  ok('substantive well-formed input → allow + output_emit_ok');
+} else {
+  bad('substantive well-formed input → allow', `got decision=${t3d.decision} class=${t3d.classification.action_class}`);
+}
+
+// ─── Test 4: deterministic_hash — identical input produces identical receipt
+const t4a = evaluateWithKernel({
+  surface: 'self-test', phase: 'stop',
+  observation: { kind: 'output_emit', source: 'claude-code-stop', summary: 'x',
+    attrs: { hasCompletionLang: true, hasVerifyBlock: false, evidenceAnchorCount: 0 } },
+  evidence: [],
+});
+const t4b = evaluateWithKernel({
+  surface: 'self-test', phase: 'stop',
+  observation: { kind: 'output_emit', source: 'claude-code-stop', summary: 'x',
+    attrs: { hasCompletionLang: true, hasVerifyBlock: false, evidenceAnchorCount: 0 } },
+  evidence: [],
+});
+if (t4a.receiptHash === t4b.receiptHash) {
+  ok('deterministic_hash invariant: identical input → identical receiptHash');
+} else {
+  bad('deterministic_hash', `${t4a.receiptHash} != ${t4b.receiptHash}`);
+}
+
+console.log();
+console.log(`stop-gate G1/G6 integration: ${pass} pass, ${fail} fail`);
+process.exit(fail === 0 ? 0 : 1);

package/scripts/self-test-stop-gate.mjs

@@ -0,0 +1,128 @@
+#!/usr/bin/env node
+/**
+ * Stop-gate regression test (M1.1 — Bug A fix).
+ *
+ * Doctrine bind:
+ *   - feedback_no_graceful_degradation.md — gate must block, not warn-and-pass
+ *   - EIGHT_LENS_DOCTRINE.md — fallback catcher when coach didn't drive
+ *   - aria-repo-doctrine — verify path of truth, real proof not stub
+ *
+ * Validates structural contract of emitRecoverableStopGate:
+ *   1. Recovery file payload's internal `decision` is 'block' (consistency w/ gate)
+ *   2. Console emit uses `decision: 'block'` (NOT 'allow' — that was Bug A)
+ *   3. Reason text wraps via buildForceReauthorReason (FORCE_REAUTHOR header)
+ *   4. Loop-directive is applied (repeat-protection)
+ *   5. Recovery file IS still written (M1.2 + M3.1 deliver it next turn)
+ *
+ * Live behavioral verification happens in M4.5 (Phase 4) via real Claude Code session.
+ */
+
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+const repoRoot = join(import.meta.dirname, '..', '..', '..');
+const stopGatePath = join(repoRoot, 'ops', 'claude-hooks', 'aria-stop-gate.mjs');
+const source = readFileSync(stopGatePath, 'utf8');
+const forceReauthorTemplatePath = join(repoRoot, 'ops', 'claude-hooks', 'recovery-templates', 'force-reauthor.md');
+const forceReauthorTemplate = readFileSync(forceReauthorTemplatePath, 'utf8');
+
+// ── 1. Recovery contract internal `decision` field is 'block' ──────────────
+// The recovery JSON written to disk now reflects the gate's blocking semantics.
+const recoveryDecisionMatches = source.match(/decision:\s*'block'/g) || [];
+assert.ok(
+  recoveryDecisionMatches.length >= 2,
+  `Expected at least 2 decision:'block' occurrences (recovery payload + emit), found ${recoveryDecisionMatches.length}`,
+);
+
+// -- 2. Stop hook emit uses protocol-valid decision:'block' (Bug A + M9.DRIFT.10t)
+// The OLD Bug A code emitted allow. The later M9.DRIFT.10t fix also moved
+// emission behind emitStopHookDecision so Stop-hook stdout cannot contain
+// Claude-Code-invalid root keys such as hookSpecificOutput.
+const emitBlockRx = /emitStopHookDecision\(\{\s*\n?\s*decision:\s*'block',[\s\S]*?reason:\s*\w+/;
+assert.match(
+  source,
+  emitBlockRx,
+  'emitRecoverableStopGate must emit protocol-valid decision:"block" with a reason field',
+);
+
+// Negative check: no decision:'allow' inside emitRecoverableStopGate's body
+// (allow lives ONLY in audit-log POST bodies for plan-complete success — different code path)
+// Slice from `function emitRecoverableStopGate` to the next top-level `// Lens substance check` comment
+const fnStart = source.indexOf('function emitRecoverableStopGate');
+const fnEnd = source.indexOf('// Lens substance check', fnStart);
+assert.ok(fnStart > 0 && fnEnd > fnStart, 'Could not locate emitRecoverableStopGate function bounds');
+const recoverableFnSlice = source.slice(fnStart, fnEnd);
+assert.doesNotMatch(
+  recoverableFnSlice,
+  /decision:\s*'allow'/,
+  'emitRecoverableStopGate must NOT contain decision:"allow" anymore (Bug A)',
+);
+
+// ── 3. Reason text wraps via buildForceReauthorReason ──────────────────────
+assert.match(
+  recoverableFnSlice,
+  /buildForceReauthorReason\s*\(\s*\{[\s\S]*?source[\s\S]*?reason[\s\S]*?\}\s*\)/,
+  'Emit must call buildForceReauthorReason to produce the FORCE_REAUTHOR reason text',
+);
+
+// Check idempotency guard (don't double-wrap if reason already wrapped)
+assert.match(
+  recoverableFnSlice,
+  /ARIA FORCE_REAUTHOR/,
+  'Idempotency check for already-wrapped FORCE_REAUTHOR reason must be present',
+);
+
+// ── 4. withLoopDirective is wired ──────────────────────────────────────────
+assert.match(
+  recoverableFnSlice,
+  /withLoopDirective\s*\(/,
+  'Emit must call withLoopDirective for repeat-protection',
+);
+
+// ── 5. Recovery file write is preserved ─────────────────────────────────────
+assert.match(
+  recoverableFnSlice,
+  /writeFileSync\s*\(\s*CURRENT_RECOVERY_PATH/,
+  'Recovery file write must be preserved — M1.2 + M3.1 read it next turn',
+);
+
+// -- 6. buildForceReauthorReason uses the hot-reloadable FORCE_REAUTHOR template
+assert.match(
+  source,
+  /function buildForceReauthorReason\s*\(/,
+  'buildForceReauthorReason function must exist',
+);
+assert.match(
+  source,
+  /renderTemplateRequired\('force-reauthor'/,
+  'buildForceReauthorReason must render the force-reauthor recovery template',
+);
+assert.match(
+  source,
+  /ARIA FORCE_REAUTHOR \(FAIL-CLOSED\)/,
+  'buildForceReauthorReason must preserve a fail-closed FORCE_REAUTHOR fallback',
+);
+assert.match(
+  forceReauthorTemplate,
+  /=== ARIA FORCE_REAUTHOR ===/,
+  'force-reauthor template must produce the FORCE_REAUTHOR header',
+);
+assert.match(
+  forceReauthorTemplate,
+  /=== END FORCE_REAUTHOR ===/,
+  'force-reauthor template must produce the FORCE_REAUTHOR footer',
+);
+// -- 7. governance recovery fingerprint is delivered without invalid Stop-hook root keys
+assert.doesNotMatch(
+  recoverableFnSlice,
+  /hookSpecificOutput\s*:/,
+  'Stop-hook output must not include hookSpecificOutput; Claude Code accepts it only for SessionStart',
+);
+assert.match(
+  recoverableFnSlice,
+  /governance_recovery[\s\S]*?fingerprint/,
+  'Emit must include governance_recovery fingerprint in the reason for downstream consumers',
+);
+
+console.log('OK self-test-stop-gate (M1.1 regression checks pass)');

package/scripts/self-test-substrate-kernel-execution-receipt.mjs

@@ -0,0 +1,130 @@
+#!/usr/bin/env node
+import assert from 'node:assert/strict';
+
+const runtimeUrl = process.env.ARIA_RUNTIME_URL || 'http://127.0.0.1:4319';
+
+const body = {
+  surface: 'codex',
+  surfaceId: 'substrate-kernel-execution-self-test',
+  sessionId: `substrate-kernel-execution-self-test-${Date.now()}`,
+  task: 'self-test substrate kernel execution receipt compact prompt',
+  docs: [{ title: 'self-test', content: 'force universal substrate packet' }],
+  files: {},
+  metadata: {
+    source: 'self-test-substrate-kernel-execution-receipt',
+    universalTurnPacket: true,
+    skillExecutionMode: 'mechanical-receipt',
+    requiredSkills: [
+      'aria-cognition-autofire',
+      'tadabbur',
+      'qiyas-analogy',
+      'mizan',
+      'aria-quality-audit',
+      'aria-harness-substrate-binding',
+    ],
+  },
+  skillExecutionMode: 'mechanical-receipt',
+};
+
+async function buildSystemPromptWithRetry() {
+  const endpoint = `${runtimeUrl.replace(/\/+$/, '')}/build-system-prompt`;
+  let lastError = null;
+  for (let attempt = 1; attempt <= 4; attempt += 1) {
+    try {
+      const response = await fetch(endpoint, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify(body),
+      });
+      if (response.ok || attempt === 4) return response;
+      lastError = new Error(`runtime /build-system-prompt status=${response.status}`);
+    } catch (error) {
+      lastError = error;
+    }
+    await new Promise((resolve) => setTimeout(resolve, 300 * attempt));
+  }
+  throw lastError || new Error('runtime /build-system-prompt did not return a response');
+}
+
+const response = await buildSystemPromptWithRetry();
+
+assert.equal(response.ok, true, `runtime /build-system-prompt status=${response.status}`);
+const data = await response.json();
+const receipt = data.skillExecutionReceipt || {};
+const substrate = receipt.substrateKernelExecution || {};
+const sentinel = substrate.sentinelKernel || {};
+const siblingBroadcast = data.hiveSiblingSessionBroadcast || receipt.hiveSiblingSessionBroadcast || {};
+const atlasTurn = data.atlasTurnInjectionReceipt || {};
+const prompt = String(data.prompt || '');
+const phaseExecutionReceipts = Array.isArray(substrate.phaseExecutionReceipts)
+  ? substrate.phaseExecutionReceipts
+  : [];
+const cognitiveOperatorManifests = Array.isArray(receipt.cognitiveOperatorManifests)
+  ? receipt.cognitiveOperatorManifests
+  : [];
+const turnCapabilityGrant = receipt.turnCapabilityGrant || {};
+const daemonPassport = substrate.sentinelDaemonPassport || {};
+
+assert.equal(data.ok, true, 'prompt build ok');
+assert.equal(receipt.ok, true, 'skill execution receipt ok');
+assert.equal(substrate.ok, true, 'substrate kernel execution receipt ok');
+assert.equal(substrate.mode, 'deterministic_sidecar_kernel', 'deterministic sidecar mode');
+assert.ok(Array.isArray(receipt.executedSkillIds), 'executedSkillIds present');
+assert.ok(receipt.executedSkillIds.length >= body.metadata.requiredSkills.length, 'required skills executed');
+assert.ok(Array.isArray(substrate.executedOperatorIds), 'executedOperatorIds present');
+assert.ok(substrate.executedOperatorIds.length >= receipt.executedSkillIds.length, 'operator execution covers skills');
+assert.equal(sentinel.acceptance?.tadabbur_12, true, 'Sentinel Tadabbur-12 acceptance');
+assert.equal(sentinel.acceptance?.qiyas_15, true, 'Sentinel Qiyas-15 acceptance');
+assert.equal(sentinel.acceptance?.deterministic_hash, true, 'Sentinel deterministic hash acceptance');
+assert.equal(daemonPassport?.schema, 'aria.daemon.capability_passport.v1', 'daemon capability passport schema is present');
+assert.equal(typeof daemonPassport.passportHash, 'string', 'daemon capability passport hash is present');
+assert.equal(Array.isArray(cognitiveOperatorManifests), true, 'cognitive operator manifests are present');
+assert.ok(cognitiveOperatorManifests.length >= receipt.executedSkillIds.length, 'operator manifests cover executed skills');
+assert.equal(typeof turnCapabilityGrant, 'object', 'turn capability grant is present as object');
+assert.equal(turnCapabilityGrant === null || Array.isArray(turnCapabilityGrant), false, 'turn capability grant is not null array');
+assert.equal(turnCapabilityGrant?.schema, 'aria.turn_capability_grant.v1', 'turn capability grant schema is present');
+assert.equal(turnCapabilityGrant?.ok, true, 'turn capability grant is ok');
+assert.equal(typeof turnCapabilityGrant?.grantHash, 'string', 'turn capability grant hash is present');
+assert.equal(typeof turnCapabilityGrant?.passportHash, 'string', 'turn capability grant passport hash is present');
+assert.equal(phaseExecutionReceipts.length, 6, 'phase execution receipts contain six phase entries');
+assert.ok(phaseExecutionReceipts.every((receipt) => receipt?.schema === 'aria.phase_execution_receipt.v1'), 'all phase receipts use phase execution receipt schema');
+assert.ok(phaseExecutionReceipts.every((r) => r?.ok === true), 'all phase receipts are ok');
+assert.ok(phaseExecutionReceipts.every((r) => typeof r?.inputHash === 'string'), 'all phase receipts include inputHash');
+assert.ok(phaseExecutionReceipts.every((r) => typeof r?.outputHash === 'string'), 'all phase receipts include outputHash');
+assert.ok(phaseExecutionReceipts.every((r) => typeof r?.decisionDelta === 'string' && r.decisionDelta.length > 20), 'all phase receipts include substantive decisionDelta');
+assert.ok(phaseExecutionReceipts.every((r) => typeof r?.outputDelta === 'string' && r.outputDelta.length > 20), 'all phase receipts include substantive outputDelta');
+assert.ok(phaseExecutionReceipts.every((r) => typeof r?.verificationPredicate === 'string'), 'all phase receipts include verificationPredicate');
+assert.ok(phaseExecutionReceipts.every((r) => Array.isArray(r?.evidenceRefs) && r.evidenceRefs.length > 0), 'all phase receipts include evidenceRefs array');
+
+assert.equal(siblingBroadcast.ok, true, 'Hive sibling-session broadcast receipt ok');
+assert.ok(Number(siblingBroadcast.messageCount || 0) >= 1, 'Hive sibling-session broadcast has at least one compact message');
+assert.ok(prompt.includes('hiveSiblingSessionBroadcast'), 'provider prompt includes compact Hive sibling-session broadcast projection');
+assert.equal(atlasTurn.schema, 'aria.atlas_sentinel_turn_injection.v1', 'Atlas/Sentinel turn injection schema is present');
+assert.equal(typeof atlasTurn.receiptHash, 'string', 'Atlas/Sentinel turn injection hash is present');
+assert.equal(atlasTurn.providerProjection?.atlas?.liveAwarenessSource, 'atlas-hot-watcher', 'Atlas hot watcher is the per-turn live awareness source');
+assert.equal(atlasTurn.providerProjection?.atlas?.liveOverlaySource, 'atlas-hot-watcher', 'Atlas hot watcher is the per-turn live overlay source');
+assert.ok(prompt.includes('ARIA ATLAS/SENTINEL/HIVE TURN INJECTION'), 'provider prompt includes Atlas/Sentinel/Hive turn injection block');
+assert.ok(prompt.includes('atlas-hot-watcher'), 'provider prompt names the Atlas-owned hot watcher source');
+assert.ok(prompt.includes('sentinelNotifications'), 'provider prompt includes Sentinel notification projection');
+assert.ok(prompt.includes('thinDossierCount'), 'provider prompt includes Atlas dossier thinness projection');
+assert.equal(prompt.includes('<skill_content '), false, 'prompt does not include full skill bodies');
+assert.equal(prompt.includes('ARIA RUNTIME FORCED SKILL LOAD'), false, 'prompt does not include forced skill body block');
+assert.ok(prompt.length < 75000, `compact prompt budget: ${prompt.length}`);
+
+console.log(JSON.stringify({
+  ok: true,
+  promptChars: prompt.length,
+  executedSkillCount: receipt.executedSkillIds.length,
+  executedOperatorCount: substrate.executedOperatorIds.length,
+  cognitiveOperatorManifestCount: cognitiveOperatorManifests.length,
+  phaseExecutionReceiptCount: phaseExecutionReceipts.length,
+  turnCapabilityGrantHash: turnCapabilityGrant.grantHash,
+  daemonPassportHash: daemonPassport.passportHash,
+  hiveSiblingBroadcastCount: siblingBroadcast.messageCount,
+  atlasTurnInjectionHash: atlasTurn.receiptHash,
+  atlasLiveAwarenessSource: atlasTurn.providerProjection?.atlas?.liveAwarenessSource,
+  atlasLiveOverlaySource: atlasTurn.providerProjection?.atlas?.liveOverlaySource,
+  atlasThinDossierCount: atlasTurn.providerProjection?.thinDossierCount,
+  sentinelCompilationHash: sentinel.compilationHash,
+  executionHash: substrate.executionHash,
+}, null, 2));

package/scripts/self-test-substrate-open-skill-floor.mjs

@@ -0,0 +1,87 @@
+#!/usr/bin/env node
+import { readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+
+const repoRoot = resolve(import.meta.dirname, '../../..');
+const runtimePath = resolve(repoRoot, 'packages/aria-connector/runtime-src/service.mjs');
+const governedSurfacePath = resolve(repoRoot, 'packages/aria-connector/src/governed-surface-runner.ts');
+const runtimeSource = readFileSync(runtimePath, 'utf8');
+const governedSurfaceSource = readFileSync(governedSurfacePath, 'utf8');
+
+function fail(message) {
+  console.error(`[substrate-open-skill-floor] FAIL ${message}`);
+  process.exitCode = 1;
+}
+
+function extractNumberConstant(source, name) {
+  const match = source.match(new RegExp(`const\\s+${name}\\s*=\\s*(\\d+)\\s*;`));
+  return match ? Number(match[1]) : null;
+}
+
+function extractStringArray(source, name) {
+  const match = source.match(new RegExp(`${name}[^=]*=\\s*Object\\.freeze\\(\\[([\\s\\S]*?)\\]\\)`, 'm'));
+  if (!match) return null;
+  return Array.from(match[1].matchAll(/'([^']+)'/g), (item) => item[1]);
+}
+
+function assertUnique(values, label) {
+  const duplicates = values.filter((value, index) => values.indexOf(value) !== index);
+  if (duplicates.length) fail(`${label} contains duplicates: ${[...new Set(duplicates)].join(', ')}`);
+}
+
+const runtimeFloor = extractNumberConstant(runtimeSource, 'UNIVERSAL_MECHANICAL_PACKET_SKILL_FLOOR');
+const runtimeSkills = extractStringArray(runtimeSource, 'UNIVERSAL_MECHANICAL_PACKET_SKILL_IDS');
+const governedFloor = extractNumberConstant(governedSurfaceSource, 'UNIVERSAL_TURN_PACKET_SKILL_FLOOR');
+const governedSkills = extractStringArray(governedSurfaceSource, 'UNIVERSAL_TURN_PACKET_SKILLS');
+
+if (runtimeFloor !== 50) fail(`runtime floor must be 50, got ${runtimeFloor}`);
+if (governedFloor !== 50) fail(`governed-surface floor must be 50, got ${governedFloor}`);
+if (!Array.isArray(runtimeSkills)) fail('runtime universal mechanical skill list missing');
+if (!Array.isArray(governedSkills)) fail('governed universal turn skill list missing');
+
+if (Array.isArray(runtimeSkills) && Array.isArray(governedSkills)) {
+  assertUnique(runtimeSkills, 'runtime universal mechanical skill list');
+  assertUnique(governedSkills, 'governed universal turn skill list');
+  if (runtimeSkills.length < 50) fail(`runtime universal skill list below floor: ${runtimeSkills.length}`);
+  const missingFromRuntime = governedSkills.filter((skillId) => !runtimeSkills.includes(skillId));
+  const extraRuntimeSkills = runtimeSkills.filter((skillId) => !governedSkills.includes(skillId));
+  if (missingFromRuntime.length) fail(`runtime floor missing governed skills: ${missingFromRuntime.join(', ')}`);
+  if (extraRuntimeSkills.length) fail(`runtime floor has skills outside governed source: ${extraRuntimeSkills.join(', ')}`);
+}
+
+if (!runtimeSource.includes('function buildUniversalMechanicalRequiredSkillIds(')) {
+  fail('universal mechanical required-skill builder missing');
+}
+if (!runtimeSource.includes('function buildUniversalMechanicalSkillFloorReceipt(')) {
+  fail('universal mechanical floor receipt missing');
+}
+
+const substrateOpenMatch = runtimeSource.match(/async function buildSubstrateOpenPacket\(body = \{\}\) \{([\s\S]*?)\n\}\n\nasync function handleSubstrateRoute/);
+if (!substrateOpenMatch) {
+  fail('buildSubstrateOpenPacket body not found');
+} else {
+  const body = substrateOpenMatch[1];
+  if (!body.includes('buildUniversalMechanicalRequiredSkillIds(')) {
+    fail('/substrate/open does not use universal mechanical required-skill builder');
+  }
+  if (!body.includes('buildUniversalMechanicalSkillFloorReceipt(requiredSkillIds, \'substrate-open\')')) {
+    fail('/substrate/open does not emit a universal mechanical floor receipt');
+  }
+  if (!body.includes('skillFloorMet')) {
+    fail('/substrate/open provider projection does not expose skillFloorMet');
+  }
+  if (!body.includes('required_skill_count=${requiredSkillIds.length}')) {
+    fail('/substrate/open additionalContext does not expose required_skill_count');
+  }
+}
+
+if (!process.exitCode) {
+  console.log(JSON.stringify({
+    ok: true,
+    runtimeFloor,
+    runtimeSkillCount: runtimeSkills.length,
+    governedFloor,
+    governedSkillCount: governedSkills.length,
+    route: '/substrate/open',
+  }, null, 2));
+}