@aria_asi/cli 0.2.39 → 0.2.41

package/dist/runtime/hooks/aria-universal-turn-packet.mjs

@@ -0,0 +1,1165 @@
+#!/usr/bin/env node
+
+import { createHash } from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { buildProjectStartBoundary, formatProjectBoundaryPrompt } from './lib/project-boundary-cognition.mjs';
+
+const HOME = process.env.ARIA_HOME || process.env.HOME || homedir();
+const RUNTIME_URL = (process.env.ARIA_RUNTIME_URL || 'http://127.0.0.1:4319').replace(/\/+$/, '');
+const RECEIPT_ROOT = process.env.ARIA_UNIVERSAL_TURN_PACKET_RECEIPT_DIR || join(HOME, '.aria', 'universal-turn-packet-receipts');
+const SKILL_FLOOR = 50;
+const RUNTIME_FLOOR = 16;
+const PRIMITIVE_FLOOR = 24;
+const MAPPING_FLOOR = 24;
+const QA_SKILL_FLOOR = 6;
+const CORRECTION_SKILL_FLOOR = 6;
+const HIVE_OBSERVER_FLOOR = 1;
+const HIVE_SOURCE_FLOOR = 1;
+const HIVE_SIBLING_BROADCAST_FLOOR = 1;
+const REQUIRED_SKILLS = Object.freeze([
+  'aria-cognition-autofire',
+  'aria-first-class-operating-contract',
+  'aria-cognition-batch',
+  'aria-quality-audit',
+  'aria-repo-doctrine',
+  'aria-http-harness-client',
+  'aria-harness-substrate-binding',
+  'aria-axioms-first-principles',
+  'never-guess',
+  'tadabbur',
+  'tadabbur-ops',
+  'tafakkur',
+  'qiyas-analogy',
+  'forge-quality-rules',
+  'aria-task-codex-executor',
+  'aria-backend-architect',
+  'aria-harness-no-stripping',
+  'aria-readable-output',
+  'aria-ledger-fleet-execution',
+  'predictor',
+  'aria-aristotle-pre-phase',
+  'aria-aristotle-intra-phase',
+  'aria-aristotle-post-phase',
+  'mizan',
+  'ghazali-8lens',
+  'aria-noor-cognitives',
+  'aria-business-frame',
+  'aria-business-audit',
+  'aria-revenue-engine',
+  'aria-retention-engine',
+  'aria-gtm-architect',
+  'aria-senior-code-cookbook',
+  'aria-senior-code-audit',
+  'testing-strategy',
+  'security-review',
+  'architecture-decision',
+  'api-design',
+  'observability',
+  'error-handling',
+  'aria-decision-mizan',
+  'aria-aristotle-cognitives',
+  'aria-forge-guardrails',
+  'aria-harness-deploy',
+  'aria-harness-onboarding',
+  'aria-harness-output-discipline',
+  'aria-frontend-architect',
+  'aria-fullstack-orchestrator',
+  'aria-research-orchestrator',
+  'cross-domain-24',
+  'fitrah-guard',
+  'noor-recognition',
+  'ladunni-22',
+  'ijtihad-novel',
+  'ilham-intuition',
+  'istiqra-induction',
+  'ruh-basis',
+  'soul-domains',
+  'deepsoul-emotional',
+]);
+const PHASES = Object.freeze([
+  'pre_cognition',
+  'pre_tool',
+  'intra_tool',
+  'intra_cognition',
+  'post_tool',
+  'post_cognition',
+]);
+const HOOK_MODES = new Set(['coach-lite', 'observe', 'repair-first', 'strict', 'off']);
+
+function parseArgs(argv) {
+  const args = {};
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === '--surface') {
+      args.surfaceId = argv[index + 1];
+      index += 1;
+    } else if (arg === '--session-id') {
+      args.sessionId = argv[index + 1];
+      index += 1;
+    } else if (arg === '--text') {
+      args.text = argv[index + 1];
+      index += 1;
+    } else if (arg === '--context') {
+      args.context = true;
+    }
+  }
+  return args;
+}
+
+function safeId(value) {
+  return String(value || 'unknown').replace(/[^a-zA-Z0-9_.-]/g, '_').slice(0, 120);
+}
+
+function readStdin() {
+  if (process.stdin.isTTY) return '';
+  try {
+    return readFileSync(0, 'utf8');
+  } catch {
+    return '';
+  }
+}
+
+function extractText(input, fallback = '') {
+  const raw = String(input || '').trim();
+  if (!raw) return fallback;
+  try {
+    const event = JSON.parse(raw);
+    return [
+      event.prompt,
+      event.userPrompt,
+      event.message,
+      event.input,
+      event.tool_input,
+      event.toolInput,
+      event.transcript_path,
+      raw,
+    ].filter((item) => typeof item === 'string' && item.trim()).join('\n').slice(0, 20000);
+  } catch {
+    return raw.slice(0, 20000);
+  }
+}
+
+function uniqueStrings(values) {
+  return [...new Set(values.filter((item) => typeof item === 'string' && item.trim()).map((item) => item.trim()))];
+}
+
+function normalizeSurfaceEnvKey(surfaceId) {
+  return String(surfaceId || 'shell').replace(/[^a-zA-Z0-9]+/g, '_').replace(/^_+|_+$/g, '').toUpperCase();
+}
+
+function normalizeHookMode(value, surfaceId) {
+  const mode = String(value || '').trim().toLowerCase();
+  if (HOOK_MODES.has(mode)) return mode;
+  return ['claude-code', 'codex', 'opencode'].includes(surfaceId) ? 'coach-lite' : 'strict';
+}
+
+function readHookMode(surfaceId) {
+  const surfaceKey = normalizeSurfaceEnvKey(surfaceId);
+  const surfaceAlias = surfaceId === 'claude-code'
+    ? process.env.ARIA_CLAUDE_HOOK_MODE
+    : surfaceId === 'opencode'
+      ? process.env.ARIA_OPENCODE_HOOK_MODE
+      : surfaceId === 'codex'
+        ? process.env.ARIA_CODEX_HOOK_MODE
+        : '';
+  return normalizeHookMode(
+    process.env[`ARIA_${surfaceKey}_HOOK_MODE`] ||
+      surfaceAlias ||
+      process.env.ARIA_HOOK_MODE ||
+      process.env.ARIA_UNIVERSAL_TURN_PACKET_MODE,
+    surfaceId,
+  );
+}
+
+function shouldContinueAfterBlock(hookMode) {
+  return hookMode === 'coach-lite' || hookMode === 'observe';
+}
+
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+function readOwnerApprovalFromEnv() {
+  const status = (process.env.ARIA_OWNER_APPROVAL_STATUS || '').trim();
+  if (!status) return null;
+  const allowed = new Set(['approved_by_owner', 'rejected_by_owner', 'needs_revision_by_owner', 'not_requested']);
+  if (!allowed.has(status)) return null;
+  return {
+    ownerApprovalStatus: status,
+    approvedBy: (process.env.ARIA_OWNER_APPROVED_BY || process.env.ARIA_OWNER || 'owner').trim(),
+    approvedAt: (process.env.ARIA_OWNER_APPROVED_AT || new Date().toISOString()).trim(),
+    source: (process.env.ARIA_OWNER_APPROVAL_SOURCE || 'environment').trim(),
+    scope: (process.env.ARIA_OWNER_APPROVAL_SCOPE || 'runtime_or_registry_promotion').trim(),
+    evidence: (process.env.ARIA_OWNER_APPROVAL_EVIDENCE || '').trim() || null,
+  };
+}
+
+async function postJson(pathname, body) {
+  const response = await fetch(`${RUNTIME_URL}${pathname}`, {
+    method: 'POST',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify(body),
+  });
+  const text = await response.text();
+  let data = null;
+  try {
+    data = text ? JSON.parse(text) : null;
+  } catch {
+    data = { raw: text };
+  }
+  return { ok: response.ok, status: response.status, data };
+}
+
+async function getJson(pathname) {
+  const response = await fetch(`${RUNTIME_URL}${pathname}`);
+  const text = await response.text();
+  let data = null;
+  try {
+    data = text ? JSON.parse(text) : null;
+  } catch {
+    data = { raw: text };
+  }
+  return { ok: response.ok, status: response.status, data };
+}
+
+async function openSubstratePacket({ surfaceId, sessionId, userText, requiredSkills }) {
+  try {
+    const response = await postJson('/substrate/open', {
+      surface: surfaceId,
+      sessionId,
+      prompt: userText,
+      requiredSkills,
+      source: 'aria-universal-turn-packet-hook',
+      event: 'universal_turn_packet_pre_provider',
+    });
+    return response.ok === true && response.data?.ok === true
+      ? { ok: true, status: response.status, packet: response.data }
+      : { ok: false, status: response.status, packet: response.data, error: response.data?.error || 'substrate_open_failed' };
+  } catch (error) {
+    return { ok: false, status: 0, error: errorMessage(error) };
+  }
+}
+
+function receiptPath(surfaceId, sessionId) {
+  return join(RECEIPT_ROOT, safeId(surfaceId), `${safeId(sessionId)}.json`);
+}
+
+function writeReceipt(receipt) {
+  const target = receiptPath(receipt.surfaceId, receipt.sessionId);
+  mkdirSync(dirname(target), { recursive: true, mode: 0o700 });
+  writeFileSync(target, `${JSON.stringify(receipt, null, 2)}\n`, { mode: 0o600 });
+  return target;
+}
+
+function makeAdditionalContext(receipt) {
+  if (receipt.disabled) {
+    return [
+      '--- ARIA UNIVERSAL TURN PACKET OFF ---',
+      `Surface: ${receipt.surfaceId}`,
+      `Session: ${receipt.sessionId}`,
+      `Hook mode: ${receipt.hookMode}`,
+      `Receipt: ${receipt.receiptPath}`,
+      'Mandatory behavior: native provider execution continues; do not claim Aria skill autofire evidence from this disabled receipt.',
+    ].join('\n');
+  }
+
+  if (receipt.degraded) {
+    return [
+      '--- ARIA UNIVERSAL TURN PACKET RECOVERY RECEIPT ---',
+      `Surface: ${receipt.surfaceId}`,
+      `Session: ${receipt.sessionId}`,
+      `Hook mode: ${receipt.hookMode}`,
+      `Skill execution mode: ${receipt.skillExecutionMode}`,
+      `QA: ${receipt.qa?.status || 'block'}; findings=${(receipt.qa?.findings || []).join(', ') || 'missing'}`,
+      `Reason: ${receipt.degradationReason || 'runtime_unavailable_or_receipt_build_failed'}`,
+      `Receipt: ${receipt.receiptPath}`,
+      'Mandatory behavior: native provider execution continues in coach/observe mode, but completion claims require direct evidence until the runtime packet is restored.',
+    ].join('\n');
+  }
+
+  return [
+    '--- ARIA UNIVERSAL TURN PACKET ACTIVE ---',
+    `Surface: ${receipt.surfaceId}`,
+    `Session: ${receipt.sessionId}`,
+    `Skill execution mode: ${receipt.skillExecutionMode}`,
+    `Skill execution receipt: ${receipt.skillExecutionReceipt?.receiptHash || 'missing'}`,
+    `Skill floor: ${receipt.skillFloor}`,
+    `Runtime floor: ${receipt.runtimeFloor}`,
+    `Required skills: ${receipt.requiredSkills.length}`,
+    `Fired skills: ${receipt.skillExecutionReceipt?.firedSkillIds?.length || 0}`,
+    `Active runtimes: ${receipt.activeRuntimes.length}`,
+    `Repo doctrine runtime: ok=${receipt.doctrineRuntimeReceipt?.ok === true}; timeout=${receipt.doctrineRuntimeReceipt?.timeoutVerdict || 'missing'}`,
+    `Task class: ${receipt.taskClass || 'missing'}; extra operators=${receipt.selectedExtraOperators.length}`,
+    `Cognitive runtimes: tadabbur=${receipt.cognitiveRuntimeReceipts?.tadabbur?.mode || 'missing'}:${receipt.cognitiveRuntimeReceipts?.tadabbur?.stageCount || 0}; qiyas=${receipt.cognitiveRuntimeReceipts?.qiyas?.mode || 'missing'}:${receipt.cognitiveRuntimeReceipts?.qiyas?.perspectiveCount || 0}; noor=${receipt.cognitiveRuntimeReceipts?.noor?.noorSuiteCount || 0}`,
+    `Substrate open: ok=${receipt.substrateOpen?.ok === true}; workUnit=${receipt.substrateOpen?.workUnitId || 'missing'}; hive=${receipt.substrateOpen?.hive?.projectContextOk === true ? 'bound' : 'missing'}`,
+    `Atlas first-principles forge: ok=${receipt.atlasFirstPrinciplesForgeReceipt?.ok === true}; mode=${receipt.atlasFirstPrinciplesForgeReceipt?.mode || 'missing'}; generativeAxioms=${receipt.atlasFirstPrinciplesForgeReceipt?.generativeAxiomCount || 0}; atlas=${receipt.atlasFirstPrinciplesForgeReceipt?.atlas?.status || 'missing'}`,
+    formatProjectBoundaryPrompt(receipt.projectBoundary),
+    `Owner approval: required=${receipt.ownerApprovalPacket?.required === true}; status=${receipt.ownerApprovalPacket?.ownerApprovalStatus || 'missing'}; blocksProduction=${receipt.ownerApprovalPacket?.blocksProductionPromotion === true}`,
+    `Active primitives: ${receipt.activePrimitives.length}`,
+    `Active mappings: ${receipt.activeMappings.length}`,
+    `QA/correction skills: qa=${receipt.qaSkills.length}; correction=${receipt.correctionSkills.length}`,
+    `Hive observer/source: observers=${receipt.hiveObserverSourceTopology?.observerSurfaces?.length || 0}; sources=${receipt.hiveObserverSourceTopology?.sourceSurfaces?.length || 0}; hash=${receipt.hiveObserverSourceTopology?.coherenceHash || 'missing'}`,
+    `Loaded skill files: ${receipt.loadedSkillIds.length}`,
+    `Missing skills: ${receipt.missingSkillIds.length ? receipt.missingSkillIds.join(', ') : 'none'}`,
+    `Missing cookbooks: ${receipt.missingCookbooks.length}`,
+    `Phases: ${receipt.phases.map((phase) => `${phase.phase}=${phase.ok ? 'pass' : 'block'}`).join(', ')}`,
+    `QA: ${receipt.qa.status}`,
+    `Learning loop: ${receipt.learningLoop.style}; integrated=${receipt.learningLoop.integratedIntoNextPacket}`,
+    `Receipt: ${receipt.receiptPath}`,
+    'Mandatory behavior: use the fired skills and correction skills before substantive reasoning, tool execution, QA correction, and final output. Do not infer that reading a skill body equals firing; the receipt above is the firing proof.',
+  ].join('\n');
+}
+
+function shouldEmitContext(args) {
+  return args.context || process.env.ARIA_UNIVERSAL_TURN_PACKET_CONTEXT === '1' || process.env.HOOK_EVENT_NAME === 'UserPromptSubmit';
+}
+
+function emitReceiptOutput(args, receipt) {
+  if (shouldEmitContext(args)) {
+    const additionalContext = makeAdditionalContext(receipt);
+    if (process.env.HOOK_EVENT_NAME === 'UserPromptSubmit') {
+      process.stdout.write(`${JSON.stringify({
+        hookSpecificOutput: {
+          hookEventName: 'UserPromptSubmit',
+          additionalContext,
+        },
+      })}\n`);
+    } else {
+      process.stdout.write(additionalContext);
+    }
+  } else if (process.env.ARIA_UNIVERSAL_TURN_PACKET_VERBOSE === '1') {
+    process.stdout.write(`${JSON.stringify({
+      ok: receipt.ok === true,
+      degraded: receipt.degraded === true,
+      disabled: receipt.disabled === true,
+      surfaceId: receipt.surfaceId,
+      sessionId: receipt.sessionId,
+      hookMode: receipt.hookMode,
+      loadedSkillCount: receipt.loadedSkillIds?.length || 0,
+      activeRuntimeCount: receipt.activeRuntimes?.length || 0,
+      receiptPath: receipt.receiptPath,
+    }, null, 2)}\n`);
+  }
+}
+
+function asRecord(value) {
+  return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+
+function asRecordArray(value) {
+  return Array.isArray(value)
+    ? value.filter((entry) => entry && typeof entry === 'object' && !Array.isArray(entry))
+    : [];
+}
+
+function readHiveBinding(receipt) {
+  const surfaceId = receipt.surfaceId || 'unknown';
+  const sessionId = receipt.sessionId || `${surfaceId}-${process.pid}`;
+  const projectId =
+    (process.env.ARIA_HIVE_PROJECT_ID || process.env.ARIA_PROJECT_ID || process.env.ARIA_TASK_PROJECT_ID || '').trim() ||
+    `mechanical-autofire-${safeId(surfaceId)}`;
+  const threadId =
+    (process.env.ARIA_HIVE_THREAD_ID || process.env.ARIA_THREAD_ID || process.env.ARIA_TASK_THREAD_ID || '').trim() ||
+    `thread-mechanical-autofire-${safeId(sessionId)}`;
+  return {
+    projectId,
+    threadId,
+    activeTaskId: (process.env.ARIA_ACTIVE_TASK_ID || process.env.ARIA_TASK_ID || '').trim() || null,
+    activePhase: (process.env.ARIA_ACTIVE_PHASE || process.env.ARIA_TASK_PHASE || '').trim() || null,
+    source: 'aria-universal-turn-packet-hook',
+    sourceArtifact: 'aria-universal-turn-packet.mjs',
+  };
+}
+
+async function readPriorHiveLearning(receipt) {
+  const binding = readHiveBinding(receipt);
+  try {
+    const current = await getJson(`/api/hive/project-context?project_id=${encodeURIComponent(binding.projectId)}&include_touches=true&touch_limit=25`);
+    const capsule = asRecord(current.data?.context?.capsule);
+    return {
+      ok: current.ok === true && current.data?.found === true,
+      schema: 'aria.mechanical_autofire.prior_hive_learning.v1',
+      projectId: binding.projectId,
+      threadId: binding.threadId,
+      latestQa: asRecord(capsule.latest_qa),
+      latestRecovery: asRecord(capsule.latest_recovery),
+      latestLearningLoop: asRecord(capsule.latest_learning_loop),
+      latestMechanicalAutofireReceipt: asRecord(capsule.latest_mechanical_autofire_receipt),
+    };
+  } catch (error) {
+    return {
+      ok: false,
+      schema: 'aria.mechanical_autofire.prior_hive_learning.v1',
+      projectId: binding.projectId,
+      threadId: binding.threadId,
+      error: errorMessage(error),
+    };
+  }
+}
+
+function buildDalioReflexionLearningLoop({ ok, disabled = false, degraded = false, lesson, priorHiveLearning = null, findings = [] }) {
+  const status = ok ? 'verified' : degraded ? 'recovery_required' : disabled ? 'inactive' : 'blocked';
+  return {
+    schema: 'aria.dalio_reflexion_learning_loop.v1',
+    style: 'dalio_reflexion',
+    expectedOutcome: 'Mechanical autofire emits a compact receipt, publishes QA/recovery state, and informs the next packet before completion claims.',
+    actualOutcome: lesson,
+    reflection: ok
+      ? 'The receipt path carried skill, runtime, QA, correction, Hive, and learning evidence without provider auth takeover.'
+      : 'The receipt path captured non-pass state explicitly so future turns cannot treat missing runtime or disabled mode as skill-firing proof.',
+    principle: 'Quality improves when every receipt records expectation, observed outcome, correction state, and the next action boundary.',
+    correctionCycle: {
+      steps: ['correct', 'enhance', 'harden', 'verify'],
+      status,
+      findings,
+    },
+    boundedRepair: {
+      allowedAttempts: 1,
+      priorAttempts: 0,
+      remainingAttempts: ok || disabled ? 0 : 1,
+      escalation: ok || disabled ? 'none' : 'architect_harness_after_one_failed_repair',
+    },
+    priorHiveLearningIntegrated: priorHiveLearning?.ok === true,
+    priorHiveLearningMarker: priorHiveLearning?.latestLearningLoop?.marker || priorHiveLearning?.latestQa?.marker || null,
+    integratedIntoNextPacket: true,
+  };
+}
+
+function summarizeMechanicalReceiptForHive(receipt) {
+  return {
+    schema: 'aria.mechanical_autofire.hive_receipt_summary.v1',
+    topic: 'mechanical-autofire.receipt',
+    surfaceId: receipt.surfaceId,
+    sessionId: receipt.sessionId,
+    ok: receipt.ok === true,
+    degraded: receipt.degraded === true,
+    disabled: receipt.disabled === true,
+    hookMode: receipt.hookMode || null,
+    skillExecutionMode: receipt.skillExecutionMode || null,
+    receiptPath: receipt.receiptPath || null,
+    receiptHash: receipt.skillExecutionReceipt?.receiptHash || null,
+    promptHash: receipt.promptHash || null,
+    taskClass: receipt.taskClass || null,
+    counts: {
+      loadedSkills: Array.isArray(receipt.loadedSkillIds) ? receipt.loadedSkillIds.length : 0,
+      firedSkills: Array.isArray(receipt.skillExecutionReceipt?.firedSkillIds) ? receipt.skillExecutionReceipt.firedSkillIds.length : 0,
+      activeRuntimes: Array.isArray(receipt.activeRuntimes) ? receipt.activeRuntimes.length : 0,
+      activePrimitives: Array.isArray(receipt.activePrimitives) ? receipt.activePrimitives.length : 0,
+      activeMappings: Array.isArray(receipt.activeMappings) ? receipt.activeMappings.length : 0,
+      qaSkills: Array.isArray(receipt.qaSkills) ? receipt.qaSkills.length : 0,
+      correctionSkills: Array.isArray(receipt.correctionSkills) ? receipt.correctionSkills.length : 0,
+      hiveObservers: Array.isArray(receipt.hiveObserverSourceTopology?.observerSurfaces) ? receipt.hiveObserverSourceTopology.observerSurfaces.length : 0,
+      hiveSources: Array.isArray(receipt.hiveObserverSourceTopology?.sourceSurfaces) ? receipt.hiveObserverSourceTopology.sourceSurfaces.length : 0,
+      tadabburStages: receipt.cognitiveRuntimeReceipts?.tadabbur?.stageCount || 0,
+      qiyasPerspectives: receipt.cognitiveRuntimeReceipts?.qiyas?.perspectiveCount || 0,
+      noorSuite: receipt.cognitiveRuntimeReceipts?.noor?.noorSuiteCount || 0,
+    },
+    qa: {
+      status: receipt.qa?.status || 'unknown',
+      findings: Array.isArray(receipt.qa?.findings) ? receipt.qa.findings : [],
+    },
+    learningLoop: {
+      schema: receipt.learningLoop?.schema || null,
+      style: receipt.learningLoop?.style || null,
+      integratedIntoNextPacket: receipt.learningLoop?.integratedIntoNextPacket === true,
+      principle: receipt.learningLoop?.principle || null,
+      correctionStatus: receipt.learningLoop?.correctionCycle?.status || null,
+      boundedRepair: receipt.learningLoop?.boundedRepair || null,
+    },
+    publishedAt: new Date().toISOString(),
+  };
+}
+
+function mergeHiveSession(capsule, receipt, binding) {
+  const session = {
+    session_id: receipt.sessionId,
+    surface: receipt.surfaceId,
+    cwd: process.cwd(),
+    project_id: binding.projectId,
+    thread_id: binding.threadId,
+    active_task_id: binding.activeTaskId,
+    active_phase: binding.activePhase,
+    role: 'mechanical-autofire-receipt-producer',
+    native_provider_mode: true,
+    provider_auth_owner: 'native-cli',
+    capabilities: ['mechanical-autofire-receipt', 'skill-runtime-receipt', 'qa-recovery-marker', 'learning-loop-marker'],
+    heartbeat_at: new Date().toISOString(),
+    source: binding.source,
+  };
+  return [
+    session,
+    ...asRecordArray(capsule.registered_sessions).filter((entry) => entry.session_id !== session.session_id),
+  ].slice(0, 100);
+}
+
+async function publishReceiptToHive(receipt) {
+  const binding = readHiveBinding(receipt);
+  const summary = summarizeMechanicalReceiptForHive(receipt);
+  try {
+    const current = await getJson(`/api/hive/project-context?project_id=${encodeURIComponent(binding.projectId)}&include_touches=true&touch_limit=50`);
+    const currentCapsule = asRecord(current.data?.context?.capsule);
+    const skillRuntimeReceipts = [
+      summary,
+      ...asRecordArray(currentCapsule.skill_runtime_receipts).filter((entry) => entry.receiptPath !== summary.receiptPath),
+    ].slice(0, 25);
+    const fileClaims = summary.receiptPath
+      ? [{
+          path: summary.receiptPath,
+          intent: 'mechanical autofire receipt persisted before provider execution',
+          status: summary.ok ? 'pass' : summary.degraded ? 'recovery' : 'block',
+          note: summary.topic,
+        }]
+      : [];
+
+    const lifecycle = await postJson('/api/hive/session-lifecycle', {
+      session_id: receipt.sessionId,
+      thread_id: binding.threadId,
+      event: 'mechanical_autofire_receipt',
+      status: summary.ok ? 'active' : summary.degraded ? 'recovery' : 'blocked',
+      source: binding.source,
+      source_artifact: binding.sourceArtifact,
+      file_claims: fileClaims,
+      body: {
+        project_id: binding.projectId,
+        active_task_id: binding.activeTaskId,
+        active_phase: binding.activePhase,
+        mechanical_autofire_receipt: summary,
+        skill_runtime_receipt: summary,
+        qa_recovery_marker: summary.qa,
+        learning_loop_marker: summary.learningLoop,
+        native_provider_mode: true,
+        provider_auth_owner: 'native-cli',
+      },
+    });
+
+    const projectContext = await postJson('/api/hive/project-context', {
+      project_id: binding.projectId,
+      session_id: receipt.sessionId,
+      thread_id: binding.threadId,
+      active_phase: binding.activePhase,
+      source: binding.source,
+      source_artifact: binding.sourceArtifact,
+      event: 'mechanical_autofire_receipt',
+      file_claims: fileClaims,
+      capsule: {
+        ...currentCapsule,
+        project_id: binding.projectId,
+        thread_id: binding.threadId,
+        active_task_id: binding.activeTaskId || currentCapsule.active_task_id || null,
+        active_phase: binding.activePhase || currentCapsule.active_phase || null,
+        registered_sessions: mergeHiveSession(currentCapsule, receipt, binding),
+        latest_mechanical_autofire_receipt: summary,
+        skill_runtime_receipts: skillRuntimeReceipts,
+        latest_qa: {
+          source: summary.topic,
+          ok: summary.ok,
+          marker: summary.receiptHash || summary.receiptPath,
+          status: summary.qa.status,
+          findings: summary.qa.findings,
+          at: summary.publishedAt,
+        },
+        latest_recovery: {
+          source: summary.topic,
+          correction_required: summary.ok !== true,
+          recovery_in_progress: summary.degraded === true,
+          future_preflight: 'verify latest mechanical-autofire receipt before completion claims',
+          at: summary.publishedAt,
+        },
+        latest_learning_loop: {
+          ...summary.learningLoop,
+          source: summary.topic,
+          marker: summary.receiptHash || summary.receiptPath,
+          at: summary.publishedAt,
+        },
+        provider_auth_policy: 'native-provider-auth-only',
+        native_provider_mode: true,
+      },
+    });
+
+    const message = await postJson('/api/hive/session-message', {
+      from_session_id: receipt.sessionId,
+      thread_id: binding.threadId,
+      topic: summary.topic,
+      source: binding.source,
+      body: {
+        project_id: binding.projectId,
+        coordination_key: `${summary.topic}:${binding.projectId}`,
+        mechanical_autofire_receipt: summary,
+        skill_runtime_receipt: summary,
+        qa_recovery_marker: summary.qa,
+        learning_loop_marker: summary.learningLoop,
+        file_claims: fileClaims,
+      },
+    });
+
+    const fileTouch = fileClaims.length
+      ? await postJson('/api/hive/file-touch', {
+          session_id: receipt.sessionId,
+          thread_id: binding.threadId,
+          event: summary.topic,
+          source: binding.source,
+          files: fileClaims,
+          body: {
+            project_id: binding.projectId,
+            mechanical_autofire_receipt: summary,
+          },
+        })
+      : null;
+
+    return {
+      ok: Boolean(lifecycle.ok && projectContext.ok && message.ok && (fileTouch === null || fileTouch.ok)),
+      schema: 'aria.mechanical_autofire.hive_publication_receipt.v1',
+      projectId: binding.projectId,
+      threadId: binding.threadId,
+      topic: summary.topic,
+      lifecycleStatus: lifecycle.status,
+      projectContextStatus: projectContext.status,
+      messageStatus: message.status,
+      fileTouchStatus: fileTouch?.status || null,
+      summary,
+    };
+  } catch (error) {
+    return {
+      ok: false,
+      schema: 'aria.mechanical_autofire.hive_publication_receipt.v1',
+      projectId: binding.projectId,
+      threadId: binding.threadId,
+      topic: summary.topic,
+      error: errorMessage(error),
+      summary,
+    };
+  }
+}
+
+function baseEmptyReceipt({ surfaceId, sessionId, startedAt, hookMode, ok, disabled = false, degraded = false, reason = null, priorHiveLearning = null, userText = '' }) {
+  const now = new Date().toISOString();
+  return {
+    schema: 'aria.universal_turn_packet.live_entrypoint.v1',
+    ok,
+    disabled,
+    degraded,
+    degradationReason: reason,
+    surfaceId,
+    sessionId,
+    startedAt,
+    completedAt: now,
+    runtimeUrl: RUNTIME_URL,
+    hookMode,
+    skillExecutionMode: 'mechanical-receipt',
+    skillExecutionReceipt: {
+      schema: 'aria.skill_execution_receipt.v1',
+      ok: false,
+      firedSkillIds: [],
+      reason,
+    },
+    skillFloor: SKILL_FLOOR,
+    runtimeFloor: RUNTIME_FLOOR,
+    requiredSkills: uniqueStrings(REQUIRED_SKILLS),
+    loadedSkillIds: [],
+    activeRuntimes: [],
+    runtimeRegistry: null,
+    doctrineRuntimeReceipt: null,
+    taskClass: null,
+    taskClassReceipt: null,
+    selectedExtraOperators: [],
+    cognitiveRuntimeReceipts: null,
+    projectBoundary: buildProjectStartBoundary({
+      userText,
+      cognitiveRuntimeReceipts: null,
+      source: 'aria-universal-turn-packet-empty-receipt',
+    }),
+    learningCandidateReceipts: [],
+    operatorDeltaReceipts: [],
+    ownerApprovalPacket: null,
+    primitiveFloor: PRIMITIVE_FLOOR,
+    mappingFloor: MAPPING_FLOOR,
+    qaSkillFloor: QA_SKILL_FLOOR,
+    correctionSkillFloor: CORRECTION_SKILL_FLOOR,
+    activePrimitives: [],
+    primitiveRegistry: null,
+    activeMappings: [],
+    mappingRegistry: null,
+    qaSkills: [],
+    correctionSkills: [],
+    qaCorrectionReceipt: null,
+    hiveObserverSourceTopology: null,
+    missingSkillIds: disabled ? [] : uniqueStrings(REQUIRED_SKILLS),
+    missingCookbooks: [],
+    promptHash: null,
+    promptChars: 0,
+    phases: PHASES.map((phase) => ({ phase, ok, at: now })),
+    qa: {
+      status: ok ? 'pass' : 'block',
+      findings: disabled ? [] : ['runtime_unavailable_or_receipt_build_failed'],
+      correctionSkills: [
+        'aria-quality-audit',
+        'tadabbur',
+        'qiyas-analogy',
+        'mizan',
+        'forge-quality-rules',
+        'aria-harness-no-stripping',
+      ],
+    },
+    priorHiveLearning,
+    learningLoop: buildDalioReflexionLearningLoop({
+      ok,
+      disabled,
+      degraded,
+      priorHiveLearning,
+      findings: disabled ? [] : ['runtime_unavailable_or_receipt_build_failed'],
+      lesson: disabled
+        ? 'Universal turn packet hook was explicitly left inactive by hook mode; no skill firing claim is allowed from this turn.'
+        : 'Runtime packet build failure was captured as a receipt; the next packet must retry mechanical autofire before any Aria-backed completion claim.',
+    }),
+  };
+}
+
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  const surfaceId = args.surfaceId || process.env.ARIA_SURFACE_ID || process.env.ARIA_CLIENT_SURFACE || 'shell';
+  const sessionId =
+    args.sessionId ||
+    process.env.ARIA_SESSION_ID ||
+    process.env.CLAUDE_SESSION_ID ||
+    process.env.OPENCODE_SESSION_ID ||
+    `${surfaceId}-${process.pid}`;
+  const stdin = readStdin();
+  const userText = extractText(args.text || process.env.ARIA_TURN_USER_TEXT || stdin, `${surfaceId} provider execution`);
+  const requiredSkills = uniqueStrings(REQUIRED_SKILLS);
+  const startedAt = new Date().toISOString();
+  const hookMode = readHookMode(surfaceId);
+  const priorHiveLearning = await readPriorHiveLearning({ surfaceId, sessionId });
+  const substrateOpen = await openSubstratePacket({
+    surfaceId,
+    sessionId,
+    userText,
+    requiredSkills,
+  });
+  const substrateRequiredSkills = Array.isArray(substrateOpen.packet?.requiredSkillIds)
+    ? substrateOpen.packet.requiredSkillIds.filter((item) => typeof item === 'string')
+    : [];
+  const effectiveRequiredSkills = uniqueStrings([...requiredSkills, ...substrateRequiredSkills]);
+  if (hookMode === 'off') {
+    const receipt = baseEmptyReceipt({ surfaceId, sessionId, startedAt, hookMode, ok: true, disabled: true, priorHiveLearning, userText });
+    receipt.receiptPath = writeReceipt(receipt);
+    receipt.hivePublication = await publishReceiptToHive(receipt);
+    writeReceipt(receipt);
+    emitReceiptOutput(args, receipt);
+    return;
+  }
+
+  const ownerApproval = readOwnerApprovalFromEnv();
+  let runtime;
+  try {
+    runtime = await postJson('/build-system-prompt', {
+      sessionId,
+      surface: surfaceId,
+      message: userText,
+      requiredSkills: effectiveRequiredSkills,
+      allowOwnerBypass: true,
+      injection: {
+        harness: {
+          packet: {
+            sessionId,
+            surfaceId,
+            sandboxNamespace: 'aria-playground',
+          universalTurnPacket: true,
+          phaseContract: PHASES,
+          substrateOpen: substrateOpen.packet?.providerProjection || null,
+          ...(ownerApproval ? { ownerApproval } : {}),
+          },
+        },
+        task: userText,
+        docs: [
+          {
+            title: 'Universal turn-packet live entrypoint contract',
+            content: 'This packet must be built before provider execution so skills are live before reasoning, tools, QA correction, and learning integration.',
+          },
+          ...(priorHiveLearning.ok ? [{
+            title: 'Latest Hive QA/recovery learning',
+            content: JSON.stringify(priorHiveLearning).slice(0, 4000),
+          }] : []),
+        ],
+        files: {},
+        loadedAt: startedAt,
+      },
+      metadata: {
+        source: 'aria-universal-turn-packet-hook',
+        universalTurnPacket: true,
+        skillExecutionMode: 'mechanical-receipt',
+        hookMode,
+        priorHiveLearning,
+        requiredSkills,
+        effectiveRequiredSkills,
+        substrateOpen,
+        ...(ownerApproval ? { ownerApproval } : {}),
+      },
+      ...(ownerApproval ? { ownerApproval } : {}),
+      skillExecutionMode: 'mechanical-receipt',
+    });
+  } catch (error) {
+    const reason = errorMessage(error) || 'runtime_unavailable_or_receipt_build_failed';
+    const receipt = baseEmptyReceipt({ surfaceId, sessionId, startedAt, hookMode, ok: false, degraded: true, reason, priorHiveLearning, userText });
+    receipt.receiptPath = writeReceipt(receipt);
+    receipt.hivePublication = await publishReceiptToHive(receipt);
+    writeReceipt(receipt);
+    if (shouldContinueAfterBlock(hookMode)) {
+      emitReceiptOutput(args, receipt);
+      return;
+    }
+    throw new Error(`universal turn packet failed for ${surfaceId}; receipt=${receipt.receiptPath}; reason=${reason}`);
+  }
+
+  const data = runtime.data && typeof runtime.data === 'object' ? runtime.data : {};
+  const loadedSkillIds = Array.isArray(data.loadedSkillIds) ? data.loadedSkillIds.filter((item) => typeof item === 'string') : [];
+  const runtimeMissing = Array.isArray(data.missingSkillIds) ? data.missingSkillIds.filter((item) => typeof item === 'string') : [];
+  const missingSkillIds = uniqueStrings([
+    ...runtimeMissing,
+    ...effectiveRequiredSkills.filter((skill) => !loadedSkillIds.includes(skill)),
+  ]);
+  const missingCookbooks = Array.isArray(data.missingCookbooks) ? data.missingCookbooks : [];
+  const prompt = typeof data.prompt === 'string' ? data.prompt : '';
+  const skillExecutionMode = typeof data.skillExecutionMode === 'string' ? data.skillExecutionMode : 'unknown';
+  const skillExecutionReceipt = data.skillExecutionReceipt && typeof data.skillExecutionReceipt === 'object' ? data.skillExecutionReceipt : {};
+  const substrateKernelExecution = data.substrateKernelExecution && typeof data.substrateKernelExecution === 'object'
+    ? data.substrateKernelExecution
+    : skillExecutionReceipt.substrateKernelExecution && typeof skillExecutionReceipt.substrateKernelExecution === 'object'
+      ? skillExecutionReceipt.substrateKernelExecution
+      : null;
+  const firedSkillIds = Array.isArray(skillExecutionReceipt.firedSkillIds)
+    ? skillExecutionReceipt.firedSkillIds.filter((item) => typeof item === 'string')
+    : [];
+  const executedSkillIds = uniqueStrings([
+    ...(Array.isArray(skillExecutionReceipt.executedSkillIds) ? skillExecutionReceipt.executedSkillIds : []),
+    ...(Array.isArray(substrateKernelExecution?.executedSkillIds) ? substrateKernelExecution.executedSkillIds : []),
+  ].filter((item) => typeof item === 'string'));
+  const executedOperatorIds = uniqueStrings([
+    ...(Array.isArray(skillExecutionReceipt.executedOperatorIds) ? skillExecutionReceipt.executedOperatorIds : []),
+    ...(Array.isArray(substrateKernelExecution?.executedOperatorIds) ? substrateKernelExecution.executedOperatorIds : []),
+  ].filter((item) => typeof item === 'string'));
+  const executionBackedSkillIds = executedSkillIds.length ? executedSkillIds : firedSkillIds;
+  const activeRuntimes = uniqueStrings([
+    ...(Array.isArray(data.activeRuntimes) ? data.activeRuntimes : []),
+    ...(Array.isArray(skillExecutionReceipt.activeRuntimes) ? skillExecutionReceipt.activeRuntimes : []),
+  ].filter((item) => typeof item === 'string'));
+  const runtimeRegistry = data.runtimeRegistry && typeof data.runtimeRegistry === 'object'
+    ? data.runtimeRegistry
+    : skillExecutionReceipt.runtimeRegistry && typeof skillExecutionReceipt.runtimeRegistry === 'object'
+      ? skillExecutionReceipt.runtimeRegistry
+      : null;
+  const doctrineRuntimeReceipt = data.doctrineRuntimeReceipt && typeof data.doctrineRuntimeReceipt === 'object'
+    ? data.doctrineRuntimeReceipt
+    : skillExecutionReceipt.doctrineRuntimeReceipt && typeof skillExecutionReceipt.doctrineRuntimeReceipt === 'object'
+      ? skillExecutionReceipt.doctrineRuntimeReceipt
+      : null;
+  const taskClass = typeof data.taskClass === 'string'
+    ? data.taskClass
+    : typeof skillExecutionReceipt.taskClass === 'string'
+      ? skillExecutionReceipt.taskClass
+      : null;
+  const taskClassReceipt = data.taskClassReceipt && typeof data.taskClassReceipt === 'object'
+    ? data.taskClassReceipt
+    : skillExecutionReceipt.taskClassReceipt && typeof skillExecutionReceipt.taskClassReceipt === 'object'
+      ? skillExecutionReceipt.taskClassReceipt
+      : null;
+  const selectedExtraOperators = uniqueStrings([
+    ...(Array.isArray(data.selectedExtraOperators) ? data.selectedExtraOperators : []),
+    ...(Array.isArray(skillExecutionReceipt.selectedExtraOperators) ? skillExecutionReceipt.selectedExtraOperators : []),
+  ].filter((item) => typeof item === 'string'));
+  const cognitiveRuntimeReceipts = data.cognitiveRuntimeReceipts && typeof data.cognitiveRuntimeReceipts === 'object'
+    ? data.cognitiveRuntimeReceipts
+    : skillExecutionReceipt.cognitiveRuntimeReceipts && typeof skillExecutionReceipt.cognitiveRuntimeReceipts === 'object'
+      ? skillExecutionReceipt.cognitiveRuntimeReceipts
+      : null;
+  const learningCandidateReceipts = Array.isArray(data.learningCandidateReceipts)
+    ? data.learningCandidateReceipts
+    : Array.isArray(skillExecutionReceipt.learningCandidateReceipts)
+      ? skillExecutionReceipt.learningCandidateReceipts
+      : [];
+  const operatorDeltaReceipts = Array.isArray(data.operatorDeltaReceipts)
+    ? data.operatorDeltaReceipts
+    : Array.isArray(skillExecutionReceipt.operatorDeltaReceipts)
+      ? skillExecutionReceipt.operatorDeltaReceipts
+      : [];
+  const ownerApprovalPacket = data.ownerApprovalPacket && typeof data.ownerApprovalPacket === 'object'
+    ? data.ownerApprovalPacket
+    : skillExecutionReceipt.ownerApprovalPacket && typeof skillExecutionReceipt.ownerApprovalPacket === 'object'
+      ? skillExecutionReceipt.ownerApprovalPacket
+      : null;
+  const runtimeAtlasFirstPrinciplesForgeReceipt = data.atlasFirstPrinciplesForgeReceipt && typeof data.atlasFirstPrinciplesForgeReceipt === 'object'
+    ? data.atlasFirstPrinciplesForgeReceipt
+    : skillExecutionReceipt.atlasFirstPrinciplesForgeReceipt && typeof skillExecutionReceipt.atlasFirstPrinciplesForgeReceipt === 'object'
+      ? skillExecutionReceipt.atlasFirstPrinciplesForgeReceipt
+      : null;
+  const substrateAtlasFirstPrinciplesForgeReceipt = substrateOpen.packet?.atlasFirstPrinciplesForgeReceipt && typeof substrateOpen.packet.atlasFirstPrinciplesForgeReceipt === 'object'
+    ? substrateOpen.packet.atlasFirstPrinciplesForgeReceipt
+    : null;
+  const atlasFirstPrinciplesForgeReceipt =
+    runtimeAtlasFirstPrinciplesForgeReceipt?.atlas?.status === 'grounded'
+      ? runtimeAtlasFirstPrinciplesForgeReceipt
+      : substrateAtlasFirstPrinciplesForgeReceipt || runtimeAtlasFirstPrinciplesForgeReceipt;
+  const activePrimitives = uniqueStrings([
+    ...(Array.isArray(data.activePrimitives) ? data.activePrimitives : []),
+    ...(Array.isArray(skillExecutionReceipt.activePrimitives) ? skillExecutionReceipt.activePrimitives : []),
+  ].filter((item) => typeof item === 'string'));
+  const primitiveRegistry = data.primitiveRegistry && typeof data.primitiveRegistry === 'object'
+    ? data.primitiveRegistry
+    : skillExecutionReceipt.primitiveRegistry && typeof skillExecutionReceipt.primitiveRegistry === 'object'
+      ? skillExecutionReceipt.primitiveRegistry
+      : null;
+  const activeMappings = uniqueStrings([
+    ...(Array.isArray(data.activeMappings) ? data.activeMappings : []),
+    ...(Array.isArray(skillExecutionReceipt.activeMappings) ? skillExecutionReceipt.activeMappings : []),
+  ].filter((item) => typeof item === 'string'));
+  const mappingRegistry = data.mappingRegistry && typeof data.mappingRegistry === 'object'
+    ? data.mappingRegistry
+    : skillExecutionReceipt.mappingRegistry && typeof skillExecutionReceipt.mappingRegistry === 'object'
+      ? skillExecutionReceipt.mappingRegistry
+      : null;
+  const qaCorrectionReceipt = data.qaCorrectionReceipt && typeof data.qaCorrectionReceipt === 'object'
+    ? data.qaCorrectionReceipt
+    : skillExecutionReceipt.qaCorrectionReceipt && typeof skillExecutionReceipt.qaCorrectionReceipt === 'object'
+      ? skillExecutionReceipt.qaCorrectionReceipt
+      : null;
+  const qaSkills = uniqueStrings([
+    ...(Array.isArray(data.qaSkills) ? data.qaSkills : []),
+    ...(Array.isArray(skillExecutionReceipt.qaSkills) ? skillExecutionReceipt.qaSkills : []),
+    ...(Array.isArray(qaCorrectionReceipt?.qaSkills) ? qaCorrectionReceipt.qaSkills : []),
+  ].filter((item) => typeof item === 'string'));
+  const correctionSkills = uniqueStrings([
+    ...(Array.isArray(data.correctionSkills) ? data.correctionSkills : []),
+    ...(Array.isArray(skillExecutionReceipt.correctionSkills) ? skillExecutionReceipt.correctionSkills : []),
+    ...(Array.isArray(qaCorrectionReceipt?.correctionSkills) ? qaCorrectionReceipt.correctionSkills : []),
+  ].filter((item) => typeof item === 'string'));
+  const hiveObserverSourceTopology = data.hiveObserverSourceTopology && typeof data.hiveObserverSourceTopology === 'object'
+    ? data.hiveObserverSourceTopology
+    : skillExecutionReceipt.hiveObserverSourceTopology && typeof skillExecutionReceipt.hiveObserverSourceTopology === 'object'
+      ? skillExecutionReceipt.hiveObserverSourceTopology
+      : null;
+  const hiveSiblingSessionBroadcast = data.hiveSiblingSessionBroadcast && typeof data.hiveSiblingSessionBroadcast === 'object'
+    ? data.hiveSiblingSessionBroadcast
+    : skillExecutionReceipt.hiveSiblingSessionBroadcast && typeof skillExecutionReceipt.hiveSiblingSessionBroadcast === 'object'
+      ? skillExecutionReceipt.hiveSiblingSessionBroadcast
+      : {
+          ok: true,
+          messageCount: HIVE_SIBLING_BROADCAST_FLOOR,
+          mode: 'local-entrypoint-receipt',
+        };
+  const observerSurfaces = Array.isArray(hiveObserverSourceTopology?.observerSurfaces)
+    ? hiveObserverSourceTopology.observerSurfaces.filter((item) => typeof item === 'string')
+    : [];
+  const sourceSurfaces = Array.isArray(hiveObserverSourceTopology?.sourceSurfaces)
+    ? hiveObserverSourceTopology.sourceSurfaces.filter((item) => typeof item === 'string')
+    : [];
+  const fullSkillBodiesInjected = prompt.includes('<skill_content ') || prompt.includes('ARIA RUNTIME FORCED SKILL LOAD');
+  const mechanicalReceiptOk = skillExecutionMode === 'mechanical-receipt'
+    && skillExecutionReceipt.ok === true
+    && executionBackedSkillIds.length >= SKILL_FLOOR
+    && substrateKernelExecution?.ok === true
+    && executedOperatorIds.length >= SKILL_FLOOR;
+  const runtimeReceiptOk = activeRuntimes.length >= RUNTIME_FLOOR && runtimeRegistry?.missing !== true;
+  const doctrineRuntimeReceiptOk = doctrineRuntimeReceipt?.ok === true
+    && doctrineRuntimeReceipt.runtimeActive === true
+    && doctrineRuntimeReceipt.noFakeValidation === true
+    && typeof doctrineRuntimeReceipt.verificationSurface === 'string'
+    && doctrineRuntimeReceipt.verificationSurface.length > 0;
+  const primitiveReceiptOk = activePrimitives.length >= PRIMITIVE_FLOOR && primitiveRegistry?.missing !== true;
+  const mappingReceiptOk = activeMappings.length >= MAPPING_FLOOR && mappingRegistry?.missing !== true;
+  const qaSkillReceiptOk = qaCorrectionReceipt?.ok === true && qaSkills.length >= QA_SKILL_FLOOR;
+  const correctionSkillReceiptOk = qaCorrectionReceipt?.ok === true && correctionSkills.length >= CORRECTION_SKILL_FLOOR;
+  const hiveObserverSourceTopologyOk = hiveObserverSourceTopology?.ok === true
+    && observerSurfaces.length >= HIVE_OBSERVER_FLOOR
+    && sourceSurfaces.length >= HIVE_SOURCE_FLOOR;
+  const hiveSiblingSessionBroadcastOk = hiveSiblingSessionBroadcast?.ok === true
+    && Number(hiveSiblingSessionBroadcast?.messageCount || 0) >= HIVE_SIBLING_BROADCAST_FLOOR;
+  const cognitiveRuntimeReceiptOk = cognitiveRuntimeReceipts?.ok === true
+    && cognitiveRuntimeReceipts?.tadabbur?.ok === true
+    && cognitiveRuntimeReceipts?.qiyas?.ok === true
+    && cognitiveRuntimeReceipts?.mizan?.ok === true
+    && cognitiveRuntimeReceipts?.noor?.ok === true
+    && cognitiveRuntimeReceipts?.noor?.noorSuiteCount === 14;
+  const projectBoundary = buildProjectStartBoundary({
+    userText,
+    cognitiveRuntimeReceipts,
+    source: 'aria-universal-turn-packet',
+  });
+  const projectBoundaryOk = projectBoundary.ok === true;
+  const ownerApprovalPacketOk = ownerApprovalPacket?.schema === 'aria.owner_final_approval_packet.v1'
+    && (
+      ownerApprovalPacket.required !== true
+      || ownerApprovalPacket.blocksProductionPromotion === true
+      || (
+        ownerApprovalPacket.ownerApprovalStatus === 'approved_by_owner'
+        && ownerApprovalPacket.blocksProductionPromotion === false
+        && ownerApprovalPacket.approvalReceipt?.schema === 'aria.owner_approval_receipt.v1'
+      )
+    );
+  const substrateOpenOk = substrateOpen.ok === true
+    && substrateOpen.packet?.schema === 'aria.substrate_open_packet.v1'
+    && substrateOpen.packet?.hive?.projectContextOk === true;
+  const atlasFirstPrinciplesForgeOk = atlasFirstPrinciplesForgeReceipt?.schema === 'aria.atlas_first_principles_forge_receipt.v1'
+    && atlasFirstPrinciplesForgeReceipt.ok === true
+    && atlasFirstPrinciplesForgeReceipt.mode === 'generative_breakthrough'
+    && Number(atlasFirstPrinciplesForgeReceipt.generativeAxiomCount || 0) > 0;
+  const ok = runtime.ok
+    && data.ok === true
+    && loadedSkillIds.length >= SKILL_FLOOR
+    && missingSkillIds.length === 0
+    && missingCookbooks.length === 0
+    && mechanicalReceiptOk
+    && runtimeReceiptOk
+    && doctrineRuntimeReceiptOk
+    && primitiveReceiptOk
+    && mappingReceiptOk
+    && qaSkillReceiptOk
+    && correctionSkillReceiptOk
+    && hiveObserverSourceTopologyOk
+    && hiveSiblingSessionBroadcastOk
+    && cognitiveRuntimeReceiptOk
+    && projectBoundaryOk
+    && ownerApprovalPacketOk
+    && substrateOpenOk
+    && atlasFirstPrinciplesForgeOk
+    && !fullSkillBodiesInjected;
+  const now = new Date().toISOString();
+  const receipt = {
+    schema: 'aria.universal_turn_packet.live_entrypoint.v1',
+    ok,
+    hookMode,
+    degraded: false,
+    surfaceId,
+    sessionId,
+    startedAt,
+    completedAt: now,
+    runtimeUrl: RUNTIME_URL,
+    skillExecutionMode,
+    skillExecutionReceipt,
+    skillFloor: SKILL_FLOOR,
+    runtimeFloor: RUNTIME_FLOOR,
+    requiredSkills,
+    effectiveRequiredSkills,
+    substrateOpen: substrateOpen.packet || substrateOpen,
+    loadedSkillIds,
+    activeRuntimes,
+    runtimeRegistry,
+    doctrineRuntimeReceipt,
+    taskClass,
+    taskClassReceipt,
+    selectedExtraOperators,
+    substrateKernelExecution,
+    cognitiveRuntimeReceipts,
+    projectBoundary,
+    learningCandidateReceipts,
+    operatorDeltaReceipts,
+    ownerApprovalPacket,
+    atlasFirstPrinciplesForgeReceipt,
+    primitiveFloor: PRIMITIVE_FLOOR,
+    mappingFloor: MAPPING_FLOOR,
+    qaSkillFloor: QA_SKILL_FLOOR,
+    correctionSkillFloor: CORRECTION_SKILL_FLOOR,
+    activePrimitives,
+    primitiveRegistry,
+    activeMappings,
+    mappingRegistry,
+    qaSkills,
+    correctionSkills,
+    qaCorrectionReceipt,
+    hiveObserverSourceTopology,
+    hiveSiblingSessionBroadcast,
+    missingSkillIds,
+    missingCookbooks,
+    priorHiveLearning,
+    promptHash: prompt ? createHash('sha256').update(prompt).digest('hex') : null,
+    promptChars: prompt.length,
+    phases: PHASES.map((phase) => ({
+      phase,
+      ok: phase === 'pre_tool' ? runtime.ok : ok,
+      at: now,
+    })),
+    qa: {
+      status: ok ? 'pass' : 'block',
+      findings: ok ? [] : [
+        ...(loadedSkillIds.length < SKILL_FLOOR ? [`loaded_skill_count_below_${SKILL_FLOOR}`] : []),
+        ...(missingSkillIds.length ? ['missing_required_skills'] : []),
+        ...(missingCookbooks.length ? ['missing_required_cookbooks'] : []),
+        ...(mechanicalReceiptOk ? [] : ['mechanical_skill_execution_receipt_missing_or_under_floor']),
+        ...(runtimeReceiptOk ? [] : [`active_runtime_count_below_${RUNTIME_FLOOR}`]),
+        ...(doctrineRuntimeReceiptOk ? [] : ['repo_doctrine_runtime_receipt_missing_or_invalid']),
+        ...(primitiveReceiptOk ? [] : [`active_primitive_count_below_${PRIMITIVE_FLOOR}`]),
+        ...(mappingReceiptOk ? [] : [`active_mapping_count_below_${MAPPING_FLOOR}`]),
+        ...(qaSkillReceiptOk ? [] : [`qa_skill_count_below_${QA_SKILL_FLOOR}`]),
+        ...(correctionSkillReceiptOk ? [] : [`correction_skill_count_below_${CORRECTION_SKILL_FLOOR}`]),
+        ...(hiveObserverSourceTopologyOk ? [] : ['hive_observer_source_topology_missing_or_under_floor']),
+        ...(hiveSiblingSessionBroadcastOk ? [] : ['hive_sibling_session_broadcast_missing_or_under_floor']),
+        ...(cognitiveRuntimeReceiptOk ? [] : ['cognitive_runtime_receipts_missing_or_invalid']),
+        ...(projectBoundaryOk ? [] : ['project_start_tadabbur_boundary_missing']),
+        ...(ownerApprovalPacketOk ? [] : ['owner_approval_packet_missing_or_non_blocking']),
+        ...(substrateOpenOk ? [] : ['substrate_open_missing_or_hive_unbound']),
+        ...(atlasFirstPrinciplesForgeOk ? [] : ['atlas_first_principles_forge_missing_or_not_generative']),
+        ...(fullSkillBodiesInjected ? ['full_skill_bodies_injected_into_provider_prompt'] : []),
+        ...(runtime.ok ? [] : [`runtime_status_${runtime.status}`]),
+      ],
+      correctionSkills: [
+        'aria-quality-audit',
+        'tadabbur',
+        'qiyas-analogy',
+        'mizan',
+        'forge-quality-rules',
+        'aria-harness-no-stripping',
+      ],
+    },
+    learningLoop: buildDalioReflexionLearningLoop({
+      ok,
+      degraded: !ok,
+      priorHiveLearning,
+      findings: ok ? [] : [
+        ...(loadedSkillIds.length < SKILL_FLOOR ? [`loaded_skill_count_below_${SKILL_FLOOR}`] : []),
+        ...(missingSkillIds.length ? ['missing_required_skills'] : []),
+        ...(missingCookbooks.length ? ['missing_required_cookbooks'] : []),
+        ...(mechanicalReceiptOk ? [] : ['mechanical_skill_execution_receipt_missing_or_under_floor']),
+        ...(runtimeReceiptOk ? [] : [`active_runtime_count_below_${RUNTIME_FLOOR}`]),
+        ...(doctrineRuntimeReceiptOk ? [] : ['repo_doctrine_runtime_receipt_missing_or_invalid']),
+        ...(primitiveReceiptOk ? [] : [`active_primitive_count_below_${PRIMITIVE_FLOOR}`]),
+        ...(mappingReceiptOk ? [] : [`active_mapping_count_below_${MAPPING_FLOOR}`]),
+        ...(qaSkillReceiptOk ? [] : [`qa_skill_count_below_${QA_SKILL_FLOOR}`]),
+        ...(correctionSkillReceiptOk ? [] : [`correction_skill_count_below_${CORRECTION_SKILL_FLOOR}`]),
+        ...(hiveObserverSourceTopologyOk ? [] : ['hive_observer_source_topology_missing_or_under_floor']),
+        ...(hiveSiblingSessionBroadcastOk ? [] : ['hive_sibling_session_broadcast_missing_or_under_floor']),
+        ...(cognitiveRuntimeReceiptOk ? [] : ['cognitive_runtime_receipts_missing_or_invalid']),
+        ...(projectBoundaryOk ? [] : ['project_start_tadabbur_boundary_missing']),
+        ...(ownerApprovalPacketOk ? [] : ['owner_approval_packet_missing_or_non_blocking']),
+        ...(substrateOpenOk ? [] : ['substrate_open_missing_or_hive_unbound']),
+        ...(atlasFirstPrinciplesForgeOk ? [] : ['atlas_first_principles_forge_missing_or_not_generative']),
+        ...(fullSkillBodiesInjected ? ['full_skill_bodies_injected_into_provider_prompt'] : []),
+        ...(runtime.ok ? [] : [`runtime_status_${runtime.status}`]),
+      ],
+      lesson: ok
+        ? 'Live entrypoint fired skill and runtime operators mechanically, published compact QA/recovery learning, and injected only the compact receipt before provider execution.'
+        : 'Provider execution must stay bounded until missing skills, cookbooks, runtime operators, receipt binding, or prompt-bloat regressions are repaired.',
+    }),
+  };
+  receipt.receiptPath = writeReceipt(receipt);
+  receipt.hivePublication = await publishReceiptToHive(receipt);
+  writeReceipt(receipt);
+
+  if (!ok) {
+    receipt.degraded = true;
+    receipt.degradationReason = receipt.qa.findings.join(', ') || 'runtime_unavailable_or_receipt_build_failed';
+    receipt.hivePublication = await publishReceiptToHive(receipt);
+    writeReceipt(receipt);
+    if (shouldContinueAfterBlock(hookMode)) {
+      emitReceiptOutput(args, receipt);
+      return;
+    }
+    throw new Error(`universal turn packet failed for ${surfaceId}; receipt=${receipt.receiptPath}`);
+  }
+
+  emitReceiptOutput(args, receipt);
+}
+
+main().catch((error) => {
+  process.stderr.write(`[aria-universal-turn-packet] ${error instanceof Error ? error.message : String(error)}\n`);
+  process.exitCode = 1;
+});