@aria_asi/cli 0.2.39 → 0.2.41

package/scripts/self-test-universal-turn-packet-entrypoints.mjs

@@ -0,0 +1,252 @@
+import assert from 'node:assert/strict';
+import { mkdtempSync, readFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+
+const repoRoot = path.resolve(import.meta.dirname, '..', '..', '..');
+const packageRoot = path.resolve(repoRoot, 'packages', 'aria-connector');
+const CHILD_TIMEOUT_MS = 60000;
+
+function source(relativePath) {
+  return readFileSync(path.join(packageRoot, relativePath), 'utf8');
+}
+
+function includesAll(label, text, markers) {
+  const missing = markers.filter((marker) => !text.includes(marker));
+  assert.deepEqual(missing, [], `${label} missing markers: ${missing.join(', ')}`);
+}
+
+function smokeHookScript() {
+  const ariaHome = mkdtempSync(path.join(tmpdir(), 'aria-universal-turn-packet-'));
+  const script = path.join(packageRoot, 'hooks', 'aria-universal-turn-packet.mjs');
+  const child = spawnSync(process.execPath, [
+    script,
+    '--surface',
+    'shell',
+    '--session-id',
+    'entrypoint-smoke',
+    '--text',
+    'entrypoint smoke must build the universal 25-skill packet before provider execution',
+  ], {
+    cwd: repoRoot,
+    encoding: 'utf8',
+    timeout: CHILD_TIMEOUT_MS,
+    env: {
+      ...process.env,
+      ARIA_HOME: ariaHome,
+      ARIA_UNIVERSAL_TURN_PACKET_RECEIPT_DIR: path.join(ariaHome, 'receipts'),
+    },
+  });
+  assert.equal(child.status, 0, child.stderr || child.stdout);
+}
+
+function smokeClaudeCoachLiteRuntimeRecovery() {
+  const ariaHome = mkdtempSync(path.join(tmpdir(), 'aria-universal-turn-packet-recovery-'));
+  const script = path.join(packageRoot, 'hooks', 'aria-universal-turn-packet.mjs');
+  const child = spawnSync(process.execPath, [
+    script,
+    '--surface',
+    'claude-code',
+    '--session-id',
+    'entrypoint-recovery',
+    '--text',
+    'entrypoint recovery must preserve native Claude provider execution when runtime packet build is unavailable',
+  ], {
+    cwd: repoRoot,
+    encoding: 'utf8',
+    timeout: CHILD_TIMEOUT_MS,
+    env: {
+      ...process.env,
+      ARIA_HOME: ariaHome,
+      ARIA_RUNTIME_URL: 'http://127.0.0.1:9',
+      ARIA_CLAUDE_HOOK_MODE: 'coach-lite',
+      ARIA_UNIVERSAL_TURN_PACKET_VERBOSE: '1',
+      ARIA_UNIVERSAL_TURN_PACKET_RECEIPT_DIR: path.join(ariaHome, 'receipts'),
+    },
+  });
+  assert.equal(child.status, 0, child.stderr || child.stdout);
+  const stdout = JSON.parse(child.stdout);
+  assert.equal(stdout.ok, false);
+  assert.equal(stdout.degraded, true);
+  assert.equal(stdout.hookMode, 'coach-lite');
+  const receipt = JSON.parse(readFileSync(stdout.receiptPath, 'utf8'));
+  assert.equal(receipt.schema, 'aria.universal_turn_packet.live_entrypoint.v1');
+  assert.equal(receipt.degraded, true);
+  assert.equal(receipt.qa.findings.includes('runtime_unavailable_or_receipt_build_failed'), true);
+}
+
+function smokeClaudeStrictRuntimeBlock() {
+  const ariaHome = mkdtempSync(path.join(tmpdir(), 'aria-universal-turn-packet-strict-'));
+  const script = path.join(packageRoot, 'hooks', 'aria-universal-turn-packet.mjs');
+  const child = spawnSync(process.execPath, [
+    script,
+    '--surface',
+    'claude-code',
+    '--session-id',
+    'entrypoint-strict',
+    '--text',
+    'entrypoint strict mode must block when runtime packet build is unavailable',
+  ], {
+    cwd: repoRoot,
+    encoding: 'utf8',
+    timeout: CHILD_TIMEOUT_MS,
+    env: {
+      ...process.env,
+      ARIA_HOME: ariaHome,
+      ARIA_RUNTIME_URL: 'http://127.0.0.1:9',
+      ARIA_CLAUDE_HOOK_MODE: 'strict',
+      ARIA_UNIVERSAL_TURN_PACKET_RECEIPT_DIR: path.join(ariaHome, 'receipts'),
+    },
+  });
+  assert.notEqual(child.status, 0);
+  assert.match(child.stderr, /universal turn packet failed for claude-code/);
+}
+
+function smokeClaudeHookOffMode() {
+  const ariaHome = mkdtempSync(path.join(tmpdir(), 'aria-universal-turn-packet-off-'));
+  const script = path.join(packageRoot, 'hooks', 'aria-universal-turn-packet.mjs');
+  const child = spawnSync(process.execPath, [
+    script,
+    '--surface',
+    'claude-code',
+    '--session-id',
+    'entrypoint-off',
+    '--text',
+    'entrypoint off mode must leave hooks installed without provider interception',
+  ], {
+    cwd: repoRoot,
+    encoding: 'utf8',
+    timeout: CHILD_TIMEOUT_MS,
+    env: {
+      ...process.env,
+      ARIA_HOME: ariaHome,
+      ARIA_RUNTIME_URL: 'http://127.0.0.1:9',
+      ARIA_CLAUDE_HOOK_MODE: 'off',
+      ARIA_UNIVERSAL_TURN_PACKET_VERBOSE: '1',
+      ARIA_UNIVERSAL_TURN_PACKET_RECEIPT_DIR: path.join(ariaHome, 'receipts'),
+    },
+  });
+  assert.equal(child.status, 0, child.stderr || child.stdout);
+  const stdout = JSON.parse(child.stdout);
+  assert.equal(stdout.ok, true);
+  assert.equal(stdout.disabled, true);
+  assert.equal(stdout.hookMode, 'off');
+  const receipt = JSON.parse(readFileSync(stdout.receiptPath, 'utf8'));
+  assert.equal(receipt.disabled, true);
+  assert.equal(receipt.skillExecutionMode, 'mechanical-receipt');
+}
+
+const hookScript = source('hooks/aria-universal-turn-packet.mjs');
+includesAll('universal hook script', hookScript, [
+  'SKILL_FLOOR = 50',
+  'RUNTIME_FLOOR = 16',
+  'PRIMITIVE_FLOOR = 24',
+  'MAPPING_FLOOR = 24',
+  'QA_SKILL_FLOOR = 6',
+  'CORRECTION_SKILL_FLOOR = 6',
+  'HIVE_OBSERVER_FLOOR = 1',
+  'HIVE_SOURCE_FLOOR = 1',
+  'HIVE_SIBLING_BROADCAST_FLOOR = 1',
+  "skillExecutionMode: 'mechanical-receipt'",
+  'mechanical_skill_execution_receipt_missing_or_under_floor',
+  'active_runtime_count_below_',
+  'repo_doctrine_runtime_receipt_missing_or_invalid',
+  'active_primitive_count_below_',
+  'active_mapping_count_below_',
+  'qa_skill_count_below_',
+  'correction_skill_count_below_',
+  'hive_observer_source_topology_missing_or_under_floor',
+  'hive_sibling_session_broadcast_missing_or_under_floor',
+  "'aria-cognition-autofire'",
+  "'ghazali-8lens'",
+  "'aria-noor-cognitives'",
+  "'pre_cognition'",
+  "'post_cognition'",
+  '/build-system-prompt',
+  'schema: \'aria.universal_turn_packet.live_entrypoint.v1\'',
+  "const HOOK_MODES = new Set(['coach-lite', 'observe', 'repair-first', 'strict', 'off']);",
+  'process.env[`ARIA_${surfaceKey}_HOOK_MODE`]',
+  'ARIA_CLAUDE_HOOK_MODE',
+  'runtime_unavailable_or_receipt_build_failed',
+  'degraded: true',
+  'disabled: true',
+  'native provider execution continues',
+]);
+
+const claudeConnector = source('src/connectors/claude-code.ts');
+includesAll('claude-code connector', claudeConnector, [
+  "'aria-universal-turn-packet.mjs'",
+  'ARIA_SURFACE_ID=claude-code HOOK_EVENT_NAME=UserPromptSubmit node $HOME/.claude/hooks/aria-universal-turn-packet.mjs',
+  'Building Aria universal turn packet...',
+]);
+
+const opencodeContext = source('opencode-plugins/harness-context/index.js');
+includesAll('opencode harness context plugin', opencodeContext, [
+  'UNIVERSAL_TURN_PACKET_SCRIPT',
+  'aria-universal-turn-packet.mjs',
+  "ARIA_SURFACE_ID: 'opencode'",
+  "ARIA_UNIVERSAL_TURN_PACKET_CONTEXT: '1'",
+  'const fullContext = [universalTurnPacket, context, coachDirectives]',
+]);
+
+const shellConnector = source('src/connectors/shell.ts');
+includesAll('shell connector wrappers', shellConnector, [
+  'function buildUniversalTurnPacketExecBlock',
+  'ARIA_UNIVERSAL_TURN_PACKET_SCRIPT="$HOME/.aria/runtime/hooks/aria-universal-turn-packet.mjs"',
+  'ARIA_SURFACE_ID="${surfaceId}" ARIA_TURN_USER_TEXT="$*" node "$ARIA_UNIVERSAL_TURN_PACKET_SCRIPT" >/dev/null',
+  'aria_codex_start_async_bootstrap()',
+  'ARIA_SESSION_ID="$_aria_bootstrap_id"',
+  'ARIA_CODEX_READINESS_SILENT=1',
+  'nohup node "$ARIA_UNIVERSAL_TURN_PACKET_SCRIPT" >"$_aria_bootstrap_log" 2>&1 &',
+  "if (toolName === 'claude') return 'claude-code';",
+  "if (toolName === 'codex') return 'codex';",
+  "if (toolName === 'opencode') return 'opencode';",
+]);
+
+const codexNativeHook = source('hooks/codex-native/aria-userprompt-submit.mjs');
+includesAll('codex native UserPromptSubmit hook', codexNativeHook, [
+  'ARIA_CODEX_UNIVERSAL_TURN_PACKET_SKILLS',
+  'ARIA_CODEX_UNIVERSAL_TURN_PACKET_PHASES',
+  "surface: 'codex'",
+  'universalTurnPacket: true',
+  "source: 'codex-userprompt-submit'",
+  'Universal packet: runtimes',
+  'Cognitive runtimes: tadabbur=',
+]);
+
+const codexRuntimeClient = source('hooks/codex-native/lib/runtime-client.mjs');
+includesAll('codex native runtime client universal validator', codexRuntimeClient, [
+  'ARIA_CODEX_UNIVERSAL_TURN_PACKET_SKILLS',
+  'ARIA_CODEX_UNIVERSAL_RUNTIME_FLOOR',
+  'ARIA_CODEX_UNIVERSAL_PRIMITIVE_FLOOR',
+  'ARIA_CODEX_UNIVERSAL_MAPPING_FLOOR',
+  'universalTurnPacketGaps',
+  'universal cognitive runtime receipt missing or failed',
+  'universal Hive observer/source topology receipt missing or failed',
+  'universal Hive sibling session broadcast receipt missing or failed',
+  'universal owner approval packet does not block requested production promotion',
+  'universal owner approval packet has ambiguous non-promotion status',
+]);
+
+smokeHookScript();
+smokeClaudeCoachLiteRuntimeRecovery();
+smokeClaudeStrictRuntimeBlock();
+smokeClaudeHookOffMode();
+
+console.log(JSON.stringify({
+  ok: true,
+  checked: {
+    universalHookScript: true,
+    claudeCodeUserPromptSubmit: true,
+    opencodeHarnessContext: true,
+    shellWrapperPreExec: true,
+    codexNativeUserPromptSubmit: true,
+    codexNativeUniversalValidator: true,
+    hookRuntimeSmoke: true,
+    claudeCoachLiteRuntimeRecovery: true,
+    claudeStrictRuntimeBlock: true,
+    claudeHookOffMode: true,
+  },
+  predicate: 'all live entrypoint source paths invoke aria-universal-turn-packet before provider execution and hook script builds a compact mechanical receipt with 50 skills, 16 active runtimes, repo doctrine runtime, 24 primitives, 24 mappings, QA/correction skills, Hive observer/source topology, and explicit Claude hook modes that preserve native provider execution in coach-lite/observe while retaining strict blocking when requested',
+}, null, 2));

package/scripts/self-test-universal-turn-packet.mjs

@@ -0,0 +1,320 @@
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import path from 'node:path';
+
+import {
+  GOVERNED_SURFACES,
+  GovernedSurfaceRunner,
+  UNIVERSAL_TURN_PACKET_CORRECTION_SKILL_FLOOR,
+  UNIVERSAL_TURN_PACKET_HIVE_OBSERVER_FLOOR,
+  UNIVERSAL_TURN_PACKET_HIVE_SOURCE_FLOOR,
+  UNIVERSAL_TURN_PACKET_MAPPING_FLOOR,
+  UNIVERSAL_TURN_PACKET_PHASES,
+  UNIVERSAL_TURN_PACKET_PRIMITIVE_FLOOR,
+  UNIVERSAL_TURN_PACKET_QA_SKILL_FLOOR,
+  UNIVERSAL_TURN_PACKET_RUNTIME_FLOOR,
+  UNIVERSAL_TURN_PACKET_SKILL_FLOOR,
+  UNIVERSAL_TURN_PACKET_SKILLS,
+} from '../dist/aria-connector/src/index.js';
+
+const SURFACES_UNDER_TEST = ['codex', 'claude-code', 'opencode', 'shell'];
+const sessionId = `universal-turn-packet-smoke-${process.pid}`;
+const repoRoot = path.resolve(import.meta.dirname, '..', '..', '..');
+const runtimeIndex = JSON.parse(readFileSync(
+  path.join(repoRoot, 'codex', 'plans', 'aria-civilizational-corpus-skills', 'proposed-runtimes-index.json'),
+  'utf8',
+));
+const EXPECTED_RUNTIMES = runtimeIndex.runtimes.map((runtime) => runtime.name);
+const primitiveIndex = JSON.parse(readFileSync(
+  path.join(repoRoot, 'codex', 'plans', 'aria-civilizational-corpus-skills', 'proposed-primitives-index.json'),
+  'utf8',
+));
+const EXPECTED_PRIMITIVES = primitiveIndex.primitives.map((primitive) => primitive.name);
+const mappingIndex = JSON.parse(readFileSync(
+  path.join(repoRoot, 'codex', 'plans', 'aria-civilizational-corpus-skills', 'proposed-cross-domain-mappings.json'),
+  'utf8',
+));
+const EXPECTED_MAPPINGS = mappingIndex.mappings.map((mapping) => mapping.primitive);
+
+function summarizeReceipt(receipt) {
+  return {
+    surfaceId: receipt.surfaceId,
+    ok: receipt.ok,
+    requiredSkillCount: receipt.requiredSkills.length,
+    loadedSkillCount: receipt.loadedSkillIds.length,
+    skillExecutionMode: receipt.skillExecutionMode,
+    firedSkillCount: Array.isArray(receipt.skillExecutionReceipt?.firedSkillIds) ? receipt.skillExecutionReceipt.firedSkillIds.length : 0,
+    activeRuntimeCount: receipt.activeRuntimes.length,
+    activePrimitiveCount: receipt.activePrimitives.length,
+    activeMappingCount: receipt.activeMappings.length,
+    qaSkillCount: receipt.qaSkills.length,
+    correctionSkillCount: receipt.correctionSkills.length,
+    hiveObserverCount: Array.isArray(receipt.hiveObserverSourceTopology?.observerSurfaces) ? receipt.hiveObserverSourceTopology.observerSurfaces.length : 0,
+    hiveSourceCount: Array.isArray(receipt.hiveObserverSourceTopology?.sourceSurfaces) ? receipt.hiveObserverSourceTopology.sourceSurfaces.length : 0,
+    hiveCoherenceHash: receipt.hiveObserverSourceTopology?.coherenceHash || null,
+    doctrineRuntimeOk: receipt.doctrineRuntimeReceipt?.ok === true,
+    doctrineTimeoutVerdict: receipt.doctrineRuntimeReceipt?.timeoutVerdict || null,
+    taskClass: receipt.taskClass,
+    selectedExtraOperatorCount: Array.isArray(receipt.selectedExtraOperators) ? receipt.selectedExtraOperators.length : 0,
+    dynamicOperatorSelectionOk: receipt.dynamicOperatorSelection?.ok === true,
+    dynamicOperatorSelectedCount: receipt.dynamicOperatorSelection?.selectedOperatorCount || null,
+    phaseRuntimeExecutionOk: receipt.phaseRuntimeExecution?.ok === true,
+    gardenMemorySubstrateOk: receipt.gardenMemorySubstrate?.ok === true,
+    qaCorrectionLearningOk: receipt.qaCorrectionLearningReceipt?.ok === true,
+    tadabburMode: receipt.cognitiveRuntimeReceipts?.tadabbur?.mode || null,
+    tadabburStageCount: receipt.cognitiveRuntimeReceipts?.tadabbur?.stageCount || null,
+    qiyasMode: receipt.cognitiveRuntimeReceipts?.qiyas?.mode || null,
+    qiyasPerspectiveCount: receipt.cognitiveRuntimeReceipts?.qiyas?.perspectiveCount || null,
+    noorSuiteCount: receipt.cognitiveRuntimeReceipts?.noor?.noorSuiteCount || null,
+    ownerApprovalRequired: receipt.ownerApprovalPacket?.required === true,
+    ownerApprovalBlocksProduction: receipt.ownerApprovalPacket?.blocksProductionPromotion === true,
+    missingSkillIds: receipt.missingSkillIds,
+    missingCookbookCount: receipt.missingCookbooks.length,
+    phases: receipt.phases.map((phase) => ({ phase: phase.phase, ok: phase.ok })),
+    qaStatus: receipt.qa.status,
+    learningIntegrated: receipt.learningLoop.integratedIntoNextPacket,
+  };
+}
+
+async function main() {
+  const runner = new GovernedSurfaceRunner({ sessionId });
+  const receipts = [];
+
+  for (const surfaceId of SURFACES_UNDER_TEST) {
+    assert.ok(GOVERNED_SURFACES.includes(surfaceId), `surface must be governed: ${surfaceId}`);
+    const receipt = await runner.buildUniversalTurnPacket({
+      surfaceId,
+      sessionId: `${sessionId}-${surfaceId}`,
+      userText: 'Wire extracted corpus skills mechanically into this connector surface before cognition, tools, QA correction, learning promotion, owner approval, Tadabbur full-depth, Qiyas transfer, Mizan false closure, and Noor source-grounded manifold reasoning.',
+      correctionFindings: [
+        'Do not treat skills as decorative context.',
+        'Do not let surface-specific paths fork the skill floor.',
+        'Learning candidate must stay sandboxed until owner approval.',
+      ],
+      requiredSkills: [
+        ...UNIVERSAL_TURN_PACKET_SKILLS,
+        'aria-quality-audit',
+        'tadabbur',
+        'qiyas-analogy',
+      ],
+    });
+    assert.equal(receipt.ok, true, JSON.stringify(summarizeReceipt(receipt), null, 2));
+    assert.ok(receipt.requiredSkills.length >= UNIVERSAL_TURN_PACKET_SKILL_FLOOR, 'required skill floor must be at least 50');
+    assert.ok(receipt.loadedSkillIds.length >= UNIVERSAL_TURN_PACKET_SKILL_FLOOR, 'runtime loaded skill floor must be at least 50');
+    assert.ok(receipt.activeRuntimes.length >= UNIVERSAL_TURN_PACKET_RUNTIME_FLOOR, 'runtime operator floor must match the corpus registry');
+    assert.ok(receipt.activePrimitives.length >= UNIVERSAL_TURN_PACKET_PRIMITIVE_FLOOR, 'primitive operator floor must be at least 24');
+    assert.ok(receipt.activeMappings.length >= UNIVERSAL_TURN_PACKET_MAPPING_FLOOR, 'cross-domain mapping floor must be at least 24');
+    assert.ok(receipt.qaSkills.length >= UNIVERSAL_TURN_PACKET_QA_SKILL_FLOOR, 'QA skill floor must be at least 6');
+    assert.ok(receipt.correctionSkills.length >= UNIVERSAL_TURN_PACKET_CORRECTION_SKILL_FLOOR, 'correction skill floor must be at least 6');
+    assert.deepEqual(
+      [...receipt.activeRuntimes].sort(),
+      [...EXPECTED_RUNTIMES].sort(),
+      'mechanical receipt must record every proposed runtime from the corpus registry',
+    );
+    assert.deepEqual(
+      [...receipt.activePrimitives].sort(),
+      [...EXPECTED_PRIMITIVES].sort(),
+      'mechanical receipt must record every proposed primitive from the corpus registry',
+    );
+    assert.deepEqual(
+      [...receipt.activeMappings].sort(),
+      [...EXPECTED_MAPPINGS].sort(),
+      'mechanical receipt must record every proposed cross-domain mapping from the corpus registry',
+    );
+    assert.equal(receipt.skillExecutionMode, 'mechanical-receipt', 'skills must fire through the compact mechanical receipt mode');
+    assert.equal(receipt.skillExecutionReceipt?.ok, true, 'mechanical skill execution receipt must pass');
+    assert.equal(receipt.hiveObserverSourceTopology?.ok, true, 'Hive observer/source topology receipt must pass');
+    assert.ok(
+      Array.isArray(receipt.hiveObserverSourceTopology?.observerSurfaces)
+        && receipt.hiveObserverSourceTopology.observerSurfaces.length >= UNIVERSAL_TURN_PACKET_HIVE_OBSERVER_FLOOR,
+      'Hive topology receipt must record at least one observer surface',
+    );
+    assert.ok(
+      Array.isArray(receipt.hiveObserverSourceTopology?.sourceSurfaces)
+        && receipt.hiveObserverSourceTopology.sourceSurfaces.length >= UNIVERSAL_TURN_PACKET_HIVE_SOURCE_FLOOR,
+      'Hive topology receipt must record at least one source surface',
+    );
+    assert.equal(typeof receipt.hiveObserverSourceTopology?.coherenceHash, 'string', 'Hive topology receipt must carry a coherence hash');
+    assert.ok(
+      Array.isArray(receipt.skillExecutionReceipt?.firedSkillIds)
+        && receipt.skillExecutionReceipt.firedSkillIds.length >= UNIVERSAL_TURN_PACKET_SKILL_FLOOR,
+      'mechanical receipt must record at least 25 fired skills',
+    );
+    assert.ok(
+      Array.isArray(receipt.skillExecutionReceipt?.activeRuntimes)
+        && receipt.skillExecutionReceipt.activeRuntimes.length >= UNIVERSAL_TURN_PACKET_RUNTIME_FLOOR,
+      'mechanical receipt must record every active runtime',
+    );
+    assert.equal(receipt.doctrineRuntimeReceipt?.ok, true, 'repo doctrine runtime receipt must pass');
+    assert.equal(receipt.doctrineRuntimeReceipt?.runtimeActive, true, 'repo doctrine runtime must be active');
+    assert.equal(receipt.doctrineRuntimeReceipt?.noFakeValidation, true, 'repo doctrine runtime must reject fake validation');
+    assert.equal(receipt.doctrineRuntimeReceipt?.timeoutVerdict, 'not_applicable', 'normal packet build must not classify timeout as proof');
+    assert.ok(
+      Array.isArray(receipt.skillExecutionReceipt?.activePrimitives)
+        && receipt.skillExecutionReceipt.activePrimitives.length >= UNIVERSAL_TURN_PACKET_PRIMITIVE_FLOOR,
+      'mechanical receipt must record at least 24 active primitives',
+    );
+    assert.ok(
+      Array.isArray(receipt.skillExecutionReceipt?.activeMappings)
+        && receipt.skillExecutionReceipt.activeMappings.length >= UNIVERSAL_TURN_PACKET_MAPPING_FLOOR,
+      'mechanical receipt must record at least 24 active mappings',
+    );
+    assert.equal(receipt.qaCorrectionReceipt?.ok, true, 'QA/correction operator receipt must pass');
+    assert.equal(receipt.taskClass, 'doctrine_or_promotion', 'promotion-sensitive packet must classify task class');
+    assert.equal(receipt.taskClassReceipt?.requiresFullDepth, true, 'promotion-sensitive packet must require full cognition depth');
+    assert.ok(
+      Array.isArray(receipt.selectedExtraOperators) && receipt.selectedExtraOperators.includes('tadabbur-full-depth-runtime'),
+      'task-class expansion must select Tadabbur full-depth runtime',
+    );
+    assert.ok(
+      Array.isArray(receipt.selectedExtraOperators) && receipt.selectedExtraOperators.includes('qiyas-15-analogy-runtime'),
+      'task-class expansion must select Qiyas-15 runtime for transfer-sensitive work',
+    );
+    assert.ok(
+      Array.isArray(receipt.selectedExtraOperators) && receipt.selectedExtraOperators.includes('aria-noor-cognitives-runtime'),
+      'task-class expansion must select Noor cognitive runtime when source-grounded Noor reasoning is in scope',
+    );
+    assert.equal(receipt.dynamicOperatorSelection?.schema, 'aria.dynamic_operator_selection_receipt.v1', 'dynamic operator selection receipt must be present');
+    assert.equal(receipt.dynamicOperatorSelection?.ok, true, 'dynamic operator selection receipt must pass');
+    assert.equal(receipt.dynamicOperatorSelection?.registryCap, null, 'dynamic operator selection must not impose an arbitrary registry cap');
+    assert.equal(receipt.dynamicOperatorSelection?.providerProjection?.bounded, true, 'dynamic operator selection provider projection must be bounded');
+    assert.equal(receipt.dynamicOperatorSelection?.providerProjection?.includesFullOperatorBodies, false, 'dynamic operator selection must not project full operator bodies');
+    assert.ok(
+      Number(receipt.dynamicOperatorSelection?.selectedOperatorCount || 0) >= UNIVERSAL_TURN_PACKET_RUNTIME_FLOOR,
+      'dynamic operator selection must select a non-trivial operator set',
+    );
+    assert.equal(receipt.phaseRuntimeExecution?.schema, 'aria.phase_runtime_execution_receipt.v1', 'phase runtime execution receipt must be present');
+    assert.equal(receipt.phaseRuntimeExecution?.ok, true, 'phase runtime execution receipt must pass');
+    assert.equal(receipt.phaseRuntimeExecution?.providerReceivesFullSkillBodies, false, 'phase runtime execution must keep full bodies out of provider projection');
+    assert.equal(receipt.gardenMemorySubstrate?.schema, 'aria.garden_memory_substrate_receipt.v1', 'Garden memory substrate receipt must be present');
+    assert.equal(receipt.gardenMemorySubstrate?.ok, true, 'Garden memory substrate receipt must pass');
+    assert.match(
+      String(receipt.gardenMemorySubstrate?.substrateBoundary || ''),
+      /memory_is_substrate_not_cognition_or_prompt_body/i,
+      'Garden memory boundary must keep Garden as substrate instead of cognition or prompt body',
+    );
+    assert.equal(receipt.gardenMemorySubstrate?.providerProjection?.includesMemoryBodies, false, 'Garden memory substrate must not project memory bodies to providers');
+    assert.equal(receipt.qaCorrectionLearningReceipt?.schema, 'aria.qa_correction_learning_receipt.v1', 'QA correction learning receipt must be present');
+    assert.equal(receipt.qaCorrectionLearningReceipt?.ok, true, 'QA correction learning receipt must pass');
+    assert.equal(receipt.qaCorrectionLearningReceipt?.learningFeedsNextSelection, true, 'learning loop must feed next operator selection');
+    assert.equal(receipt.qaCorrectionLearningReceipt?.productionPromotionRequiresOwnerApproval, true, 'learning promotion must require owner approval');
+    assert.equal(receipt.cognitiveRuntimeReceipts?.ok, true, 'cognitive runtime receipt bundle must pass');
+    assert.equal(receipt.cognitiveRuntimeReceipts?.tadabbur?.mode, 'full', 'Tadabbur runtime must escalate to full mode');
+    assert.equal(receipt.cognitiveRuntimeReceipts?.tadabbur?.stageCount, 12, 'Tadabbur full mode must run 12 stages');
+    assert.equal(receipt.cognitiveRuntimeReceipts?.qiyas?.mode, 'full', 'Qiyas runtime must escalate to full mode');
+    assert.equal(receipt.cognitiveRuntimeReceipts?.qiyas?.perspectiveCount, 15, 'Qiyas full mode must carry 15 perspectives');
+    assert.equal(receipt.cognitiveRuntimeReceipts?.mizan?.ok, true, 'Mizan runtime receipt must pass');
+    assert.equal(receipt.cognitiveRuntimeReceipts?.noor?.ok, true, 'Noor cognitive runtime receipt must pass');
+    assert.equal(receipt.cognitiveRuntimeReceipts?.noor?.noorSuiteCount, 14, 'Noor runtime must carry the 14-entry suite');
+    assert.match(
+      String(receipt.cognitiveRuntimeReceipts?.noor?.semanticBoundary || ''),
+      /not generic pattern recognition/i,
+      'Noor runtime must state the corrected semantic boundary',
+    );
+    assert.ok(
+      Array.isArray(receipt.learningCandidateReceipts) && receipt.learningCandidateReceipts.length >= 1,
+      'QA findings must create sandboxed learning candidate receipts',
+    );
+    assert.ok(
+      Array.isArray(receipt.operatorDeltaReceipts) && receipt.operatorDeltaReceipts.length >= 1,
+      'task-class expansion must record operator delta receipts',
+    );
+    assert.equal(receipt.ownerApprovalPacket?.schema, 'aria.owner_final_approval_packet.v1', 'owner approval packet must be present');
+    assert.equal(receipt.ownerApprovalPacket?.required, true, 'learning or promotion candidates must require owner approval');
+    assert.equal(receipt.ownerApprovalPacket?.blocksProductionPromotion, true, 'owner approval packet must block production promotion');
+    assert.equal(receipt.ownerApprovalPacket?.ownerApprovalStatus, 'not_requested', 'sandbox packet must not claim owner approval');
+    assert.ok(receipt.promptChars < 75000, `mechanical packet prompt must stay compact; observed=${receipt.promptChars}`);
+    assert.deepEqual(receipt.missingSkillIds, [], 'no required skills may be missing');
+    assert.deepEqual(receipt.missingCookbooks, [], 'no required cookbooks may be missing');
+    assert.deepEqual(receipt.phases.map((phase) => phase.phase), [...UNIVERSAL_TURN_PACKET_PHASES], 'all six turn phases must be represented');
+    assert.equal(receipt.qa.status, 'pass', 'QA status must pass for a complete packet');
+    assert.equal(receipt.learningLoop.style, 'dalio_reflexion', 'learning loop must be attached');
+    assert.equal(receipt.learningLoop.integratedIntoNextPacket, true, 'learning must feed the next packet');
+    receipts.push(receipt);
+  }
+
+  const approvedReceipt = await runner.buildUniversalTurnPacket({
+    surfaceId: 'codex',
+    sessionId: `${sessionId}-owner-approved-codex`,
+    userText: 'Promote the approved learning candidate and runtime operator after sandbox QA, owner approval, full Tadabbur, full Qiyas, Mizan, and Noor verification.',
+    correctionFindings: [
+      'Owner approved production promotion after sandbox QA.',
+      'Learning candidate must carry approval receipt before production promotion.',
+    ],
+    ownerApproval: {
+      ownerApprovalStatus: 'approved_by_owner',
+      approvedBy: 'owner',
+      approvedAt: '2026-05-15T03:37:00.000Z',
+      source: 'owner-chat-approval',
+      scope: 'runtime_or_registry_promotion',
+      evidence: 'User stated ownerapproved for continuation.',
+    },
+    requiredSkills: [
+      ...UNIVERSAL_TURN_PACKET_SKILLS,
+      'aria-quality-audit',
+      'tadabbur',
+      'qiyas-analogy',
+    ],
+  });
+  assert.equal(approvedReceipt.ok, true, JSON.stringify(summarizeReceipt(approvedReceipt), null, 2));
+  assert.equal(approvedReceipt.ownerApprovalPacket?.schema, 'aria.owner_final_approval_packet.v1', 'approved packet must include owner approval packet');
+  assert.equal(approvedReceipt.ownerApprovalPacket?.required, true, 'approved promotion packet remains production sensitive');
+  assert.equal(approvedReceipt.ownerApprovalPacket?.ownerApprovalStatus, 'approved_by_owner', 'approved packet must consume structured owner approval');
+  assert.equal(approvedReceipt.ownerApprovalPacket?.blocksProductionPromotion, false, 'approved packet must unblock production promotion receipts');
+  assert.equal(approvedReceipt.ownerApprovalPacket?.approvalReceipt?.schema, 'aria.owner_approval_receipt.v1', 'approved packet must carry approval receipt');
+  assert.equal(approvedReceipt.ownerApprovalPacket?.approvalReceipt?.approvedBy, 'owner', 'approval receipt must name approver');
+  assert.ok(
+    approvedReceipt.learningCandidateReceipts.every((candidate) => candidate?.promotionState === 'owner_approved_for_promotion'),
+    'approved learning candidates must carry owner-approved promotion state',
+  );
+  assert.ok(
+    approvedReceipt.operatorDeltaReceipts.some((receipt) => receipt?.operatorId === 'learning-promotion-runtime' && receipt?.promotionState === 'owner_approved_for_promotion'),
+    'learning-promotion runtime delta must carry owner-approved promotion state',
+  );
+  receipts.push(approvedReceipt);
+
+  const outputVerdict = await runner.validateOutput({
+    text: [
+      'Status: blocked_partial. The universal turn packet passed for sandboxed connector surfaces; live provider canary remains bounded by Claude provider auth.',
+      '<applied_cognition>',
+      'decision_delta: output names the verified packet boundary and does not claim universal live completion',
+      'dominant_domain: connector-runtime',
+      'binds_to: GovernedSurfaceRunner.buildUniversalTurnPacket',
+      'expected_predicate: universalTurnPacket.ok=true for codex, claude-code, opencode, shell',
+      'artifact_change: self-test-universal-turn-packet fixture carries the required contract',
+      '</applied_cognition>',
+    ].join('\n'),
+    surfaceId: 'codex',
+    sessionId,
+    timeoutMs: 20000,
+  });
+  assert.notEqual(outputVerdict.severity, 'block', JSON.stringify(outputVerdict, null, 2));
+
+  console.log(JSON.stringify({
+    ok: true,
+    skillFloor: UNIVERSAL_TURN_PACKET_SKILL_FLOOR,
+    runtimeFloor: UNIVERSAL_TURN_PACKET_RUNTIME_FLOOR,
+    primitiveFloor: UNIVERSAL_TURN_PACKET_PRIMITIVE_FLOOR,
+    mappingFloor: UNIVERSAL_TURN_PACKET_MAPPING_FLOOR,
+    qaSkillFloor: UNIVERSAL_TURN_PACKET_QA_SKILL_FLOOR,
+    correctionSkillFloor: UNIVERSAL_TURN_PACKET_CORRECTION_SKILL_FLOOR,
+    hiveObserverFloor: UNIVERSAL_TURN_PACKET_HIVE_OBSERVER_FLOOR,
+    hiveSourceFloor: UNIVERSAL_TURN_PACKET_HIVE_SOURCE_FLOOR,
+    requiredSkillCount: UNIVERSAL_TURN_PACKET_SKILLS.length,
+    expectedRuntimeCount: EXPECTED_RUNTIMES.length,
+    expectedPrimitiveCount: EXPECTED_PRIMITIVES.length,
+    expectedMappingCount: EXPECTED_MAPPINGS.length,
+    surfaceCount: receipts.length,
+    surfaces: receipts.map(summarizeReceipt),
+    outputVerdict: {
+      passed: outputVerdict.passed,
+      severity: outputVerdict.severity,
+      violations: outputVerdict.violations,
+    },
+  }, null, 2));
+}
+
+main().catch((error) => {
+  console.error(error instanceof Error ? error.stack : String(error));
+  process.exit(1);
+});