@aria_asi/cli 0.2.40 → 0.2.41

package/hooks/codex-native/aria-userprompt-submit.mjs

@@ -0,0 +1,623 @@
+#!/usr/bin/env node
+import {
+  getHarnessClient,
+  inferSessionId,
+  inferHiveThreadId,
+  inferUserId,
+  ensureTraceId,
+  extractUserText,
+  makeEvidenceRef,
+  readEventFromStdin,
+  runtimePost,
+  runtimeGet,
+  recordCoachPhase,
+  loadTurnState,
+  saveTurnState,
+  inferRequiredAriaSkills,
+  summarizeForcedSkillLoad,
+  forcedSkillLoadGaps,
+  readinessSkillFloorGaps,
+  buildTurnSubstratePacket,
+  writeTurnSubstratePacket,
+  buildLocalMechanicalSkillLoad,
+  recordReadinessPhase,
+  readinessStateFromPhase,
+  ARIA_CODEX_READINESS_PHASES,
+  ARIA_CODEX_MINIMUM_SKILL_FLOOR,
+  ARIA_CODEX_UNIVERSAL_TURN_PACKET_PHASES,
+  ARIA_CODEX_UNIVERSAL_TURN_PACKET_SKILLS,
+  ARIA_CODEX_UNIVERSAL_RUNTIME_FLOOR,
+  ARIA_CODEX_UNIVERSAL_PRIMITIVE_FLOOR,
+  ARIA_CODEX_UNIVERSAL_MAPPING_FLOOR,
+  buildUniversalConnectorGoalContract,
+  runGovernanceGate,
+  recordHiveSessionLifecycle,
+  updateTaskProjectLedger,
+  recordCodexActionEvent,
+  publishCodexActionEventToRuntime,
+  buildHarnessLiveTicker,
+  formatCodexRecoveryBlock,
+  emitJson,
+  ARIA_HOOK_SURFACE,
+} from './lib/runtime-client.mjs';
+import { buildProjectStartBoundary, formatProjectBoundaryPrompt } from '../lib/project-boundary-cognition.mjs';
+
+const ARIA_QA_AUTOFIRE_CYCLE = Object.freeze([
+  'qiyas_15_pass',
+  'tadabbur_full_canonical_12_stage',
+  'correct',
+  'enhance',
+  'harden',
+  'verify',
+]);
+
+const ARIA_QA_METHOD_CONTRACT = Object.freeze({
+  qiyas: 'Qiyas means full Qiyas-15 only. Mini Qiyas is not acceptable for architecture, runtime, code, QA, hook, SDK, worker, or harness work.',
+  tadabbur: 'Tadabbur means the full canonical 12-stage Tadabbur path for architecture, runtime, code, QA, hook, SDK, worker, or harness work.',
+});
+
+const event = readEventFromStdin();
+const client = getHarnessClient();
+const userText = extractUserText(event);
+const sessionId = inferSessionId(event);
+const hiveThreadId = inferHiveThreadId(event, sessionId);
+const userId = inferUserId(event);
+const priorState = loadTurnState(sessionId);
+const traceId = ensureTraceId(priorState);
+const inferredRequiredSkills = inferRequiredAriaSkills(userText);
+const requiredSkills = [...new Set([
+  ...ARIA_CODEX_UNIVERSAL_TURN_PACKET_SKILLS,
+  ...inferredRequiredSkills,
+])].sort();
+const goalContract = buildUniversalConnectorGoalContract({ userText, phase: 'pre_prompt' });
+const ledgerResult = updateTaskProjectLedger({
+  platform: 'codex',
+  phase: 'pre_prompt_injection',
+  source: 'codex-userprompt-hook',
+  event: { ...event, prompt: userText, sessionId, cwd: process.cwd() },
+});
+const readinessPhases = [];
+let currentReadinessPhase = 'runtime_health';
+let forcedSkillLoad = null;
+
+async function markReadiness(phaseId, status = 'active', body = {}) {
+  currentReadinessPhase = phaseId;
+  const phase = ARIA_CODEX_READINESS_PHASES.find((entry) => entry.id === phaseId) || {
+    id: phaseId,
+    label: phaseId,
+    progress: 0,
+  };
+  const receipt = await recordReadinessPhase({
+    sessionId,
+    threadId: hiveThreadId,
+    phase: phase.id,
+    label: phase.label,
+    progress: phase.progress,
+    status,
+    requiredSkills,
+    forcedSkillLoad,
+    body: {
+      traceId,
+      userId,
+      minimumSkillFloor: ARIA_CODEX_MINIMUM_SKILL_FLOOR,
+      qaAutofire: {
+        mode: 'always-on-15',
+        phase: phase.id,
+        correctionCycle: ARIA_QA_AUTOFIRE_CYCLE,
+        methodContract: ARIA_QA_METHOD_CONTRACT,
+      },
+      ...body,
+    },
+  });
+  readinessPhases.push({
+    at: new Date().toISOString(),
+    phase: phase.id,
+    label: phase.label,
+    progress: phase.progress,
+    status,
+    message: receipt.message,
+    qa: receipt.qa,
+    lifecycle: receipt.lifecycle,
+  });
+  saveTurnState(sessionId, {
+    traceId,
+    userId,
+    userText,
+    requiredSkills,
+    hiveThreadId,
+    readiness: {
+      status: readinessStateFromPhase(phaseId, status),
+      currentPhase: phase.id,
+      progress: phase.progress,
+      phases: readinessPhases,
+      minimumSkillFloor: ARIA_CODEX_MINIMUM_SKILL_FLOOR,
+      forcedSkillLoad,
+    },
+  });
+  return receipt;
+}
+
+try {
+  await markReadiness('runtime_health', 'active');
+  const runtimeHealth = await runtimeGet('/health');
+  await markReadiness('runtime_health', 'pass', {
+    runtimeOk: runtimeHealth?.ok === true,
+    runtimeId: runtimeHealth?.runtimeId || null,
+  });
+  await markReadiness('hive_turn_start', 'active');
+  const lifecycleStart = await recordHiveSessionLifecycle({
+    sessionId,
+    threadId: hiveThreadId,
+    event: 'turn_start',
+    status: 'active',
+    intentSummary: userText.slice(0, 240) || 'Codex session turn started',
+    source: 'codex-userprompt-hook',
+    body: { traceId, userId, goalContract },
+  });
+  await markReadiness('hive_turn_start', 'pass', { lifecycleStart });
+  await recordCoachPhase('pre_turn', {
+    requestId: traceId,
+    sessionId,
+    text: userText,
+    evidenceRefs: [makeEvidenceRef('user_input', userText, { sessionId, traceId, platform: 'codex' })],
+    metadata: { source: 'codex-userprompt-hook', userId },
+  });
+  await markReadiness('packet', 'active');
+  const packet = await client.getHarnessPacket({
+    sessionId,
+    platform: 'codex',
+    message: userText || 'codex turn start',
+  });
+  const packetRef = makeEvidenceRef('harness_packet', packet, { sessionId, platform: 'codex' });
+  await markReadiness('packet', 'pass', { packetRef, packetTimestamp: packet?.timestamp || null });
+  runGovernanceGate({
+    sessionId,
+    sourceRuntime: 'codex',
+    surface: 'codex-userprompt-submit',
+    text: userText.slice(0, 8000),
+    evidence: packetRef,
+  });
+  await markReadiness('mizan_pre', 'active');
+  const result = await runtimePost('/mizan/pre', {
+    sessionId,
+    packet,
+    packetRequest: {
+      sessionId,
+      platform: 'codex',
+      message: userText || 'codex turn start',
+      stage: 'codex-userprompt',
+      actor: 'codex-hook',
+      system: 'codex-hook',
+    },
+    context: {
+      sessionId,
+      traceId,
+      surface: 'codex-hooks',
+      platform: 'codex',
+      userText,
+      userId,
+      goalContract,
+      evidenceRefs: [packetRef],
+    },
+  });
+  await markReadiness('mizan_pre', 'pass', {
+    preReceiptId: result?.receipt?.receiptId || null,
+  });
+  await markReadiness('skills', 'active');
+  if (requiredSkills.length > 0) {
+    try {
+      const promptBuild = await runtimePost('/build-system-prompt', {
+        sessionId,
+        surface: 'codex',
+        message: userText || 'codex forced skill load',
+        requiredSkills,
+        allowOwnerBypass: true,
+        injection: {
+          harness: {
+            packet: {
+              sessionId,
+              surfaceId: 'codex',
+              sandboxNamespace: 'aria-playground',
+              universalTurnPacket: true,
+              phaseContract: ARIA_CODEX_UNIVERSAL_TURN_PACKET_PHASES,
+            },
+          },
+          task: userText || 'codex forced skill load',
+          docs: [
+            {
+              title: 'Codex native universal turn-packet contract',
+              content: 'This packet is built by UserPromptSubmit before provider execution so skills, runtimes, primitives, mappings, QA, correction, and learning receipts are live before reasoning or tools.',
+            },
+          ],
+          files: {},
+          loadedAt: new Date().toISOString(),
+        },
+        metadata: {
+          source: 'codex-userprompt-submit',
+          cookbookMode: 'required-when-referenced',
+          universalTurnPacket: true,
+          skillExecutionMode: 'mechanical-receipt',
+          goalContract,
+          requiredSkills,
+        },
+        skillExecutionMode: 'mechanical-receipt',
+      });
+      forcedSkillLoad = summarizeForcedSkillLoad(promptBuild);
+      forcedSkillLoad.universalTurnPacket = true;
+      // 2026-05-18 refuse-partial-substrate guard: when the build-system-prompt
+      // call succeeded HTTP-wise but returned empty critical arrays (runtime
+      // was mid-restart / mid-rebuild during the 4-second response window),
+      // the previous commit-ok:true behavior poisoned the per-session state
+      // file. Every pre-tool then read 1/16 runtimes etc. and false-blocked
+      // until session end. Flip ok:false on degraded response so downstream
+      // gates surface the gap loudly instead of silently mis-trusting it.
+      const hasUsableSubstrate = (forcedSkillLoad.activeRuntimes || []).length > 0
+        && (forcedSkillLoad.activePrimitives || []).length > 0
+        && (forcedSkillLoad.loadedCookbooks || []).length > 0;
+      if (!hasUsableSubstrate) {
+        forcedSkillLoad.ok = false;
+        forcedSkillLoad.degraded = true;
+        forcedSkillLoad.degradedReason = 'build-system-prompt returned empty critical arrays — runtime likely bouncing mid-call';
+      }
+      forcedSkillLoad.gaps = forcedSkillLoadGaps({ requiredSkills, forcedSkillLoad, universalTurnPacket: true });
+    } catch (error) {
+      forcedSkillLoad = {
+        ok: false,
+        universalTurnPacket: true,
+        requiredSkillIds: requiredSkills,
+        loadedSkillIds: [],
+        missingSkillIds: [],
+        loadedSkillHashes: [],
+        loadedCookbooks: [],
+        missingCookbooks: [],
+        promptSha256: null,
+        promptChars: 0,
+        gaps: ['forced skill autofire runtime call failed: ' + (error instanceof Error ? error.message : String(error))],
+      };
+    }
+  }
+  const firedSkillCount = forcedSkillLoad?.skillExecutionReceipt?.firedSkillIds?.length || forcedSkillLoad?.loadedSkillIds?.length || 0;
+  if (firedSkillCount < ARIA_CODEX_MINIMUM_SKILL_FLOOR) {
+    forcedSkillLoad = {
+      ...(forcedSkillLoad || {}),
+      gaps: [
+        ...new Set([
+          ...((forcedSkillLoad && Array.isArray(forcedSkillLoad.gaps)) ? forcedSkillLoad.gaps : []),
+          `minimum skill floor not met: fired ${firedSkillCount}/${ARIA_CODEX_MINIMUM_SKILL_FLOOR}`,
+        ]),
+      ],
+    };
+  }
+  await markReadiness('skills', forcedSkillLoad?.gaps?.length ? 'fail' : 'pass', {
+    forcedSkillLoad,
+    firedSkillCount,
+  });
+  if (forcedSkillLoad?.gaps?.length) {
+    throw new Error('Aria readiness skill floor failed: ' + forcedSkillLoad.gaps.join(' | '));
+  }
+  await markReadiness('post_cognition', 'active');
+  const projectBoundary = buildProjectStartBoundary({
+    userText,
+    cognitiveRuntimeReceipts: forcedSkillLoad?.cognitiveRuntimeReceipts || forcedSkillLoad?.skillExecutionReceipt?.cognitiveRuntimeReceipts || null,
+    source: 'codex-userprompt-hook',
+  });
+  if (!projectBoundary.ok) {
+    throw new Error('Project start Tadabbur boundary failed: observed ' + projectBoundary.startTadabbur.observedStages + '/' + projectBoundary.startTadabbur.expectedStages);
+  }
+  await recordCoachPhase('post_cognition', {
+    requestId: traceId,
+    sessionId,
+    text: userText,
+    evidenceRefs: [
+      packetRef,
+      makeEvidenceRef('mizan_pre_receipt', result?.receipt || null, { sessionId, traceId }),
+      ...(forcedSkillLoad ? [makeEvidenceRef('forced_skill_load', forcedSkillLoad, { sessionId, traceId })] : []),
+    ],
+    metadata: {
+      source: 'codex-userprompt-hook',
+      pre_receipt_id: result?.receipt?.receiptId || null,
+      requiredSkills,
+      forcedSkillLoad,
+      goalContract,
+      hiveThreadId,
+      projectBoundary,
+      lifecycleStart,
+      qaAutofire: {
+        mode: 'always-on-15',
+        phase: 'pre_turn',
+        correctionCycle: ARIA_QA_AUTOFIRE_CYCLE,
+      },
+    },
+  });
+  await markReadiness('post_cognition', 'pass', {
+    preReceiptId: result?.receipt?.receiptId || null,
+  });
+  const finalState = saveTurnState(sessionId, {
+    traceId,
+    userId,
+    userText,
+    requiredSkills,
+    forcedSkillLoad,
+    universalTurnPacket: true,
+    goalContract,
+    forcedSkillLoadEnforced: true,
+    forcedSkillAutofire: requiredSkills.length > 0,
+    hiveThreadId,
+    projectBoundary,
+    lifecycleStart,
+    qaAutofire: {
+      mode: 'always-on-15',
+      correctionCycle: ARIA_QA_AUTOFIRE_CYCLE,
+    },
+    preReceiptId: result?.receipt?.receiptId || null,
+    taskProjectLedgerId: ledgerResult.ledger.ledgerId,
+    packetTimestamp: packet?.timestamp || null,
+    packetRef,
+    readiness: {
+      status: 'ready',
+      currentPhase: 'ready',
+      progress: 100,
+      phases: readinessPhases,
+      minimumSkillFloor: ARIA_CODEX_MINIMUM_SKILL_FLOOR,
+      forcedSkillLoad,
+      universalTurnPacket: true,
+      firedSkillCount,
+      qaEachPhase: true,
+    },
+    lastEvent: 'UserPromptSubmit',
+  });
+  const turnSubstratePacket = buildTurnSubstratePacket({
+    sessionId,
+    event,
+    state: finalState,
+    phase: 'pre_prompt_ready',
+    text: userText,
+    evidenceRefs: [
+      packetRef,
+      makeEvidenceRef('mizan_pre_receipt', result?.receipt || null, { sessionId, traceId }),
+      ...(forcedSkillLoad ? [makeEvidenceRef('forced_skill_load', forcedSkillLoad, { sessionId, traceId })] : []),
+    ],
+  });
+  const packetWrite = writeTurnSubstratePacket(turnSubstratePacket, { sessionId, event, state: finalState });
+  saveTurnState(sessionId, {
+    turnSubstratePacket: packetWrite.packet || turnSubstratePacket,
+    turnSubstratePacketRef: makeEvidenceRef('turn_substrate_packet', packetWrite.packet || turnSubstratePacket, { sessionId, traceId }),
+  });
+  await markReadiness('ready', 'pass', {
+    preReceiptId: result?.receipt?.receiptId || null,
+    firedSkillCount,
+    taskProjectLedgerId: ledgerResult.ledger.ledgerId,
+    turnSubstratePacket: packetWrite.ok === true,
+  });
+  const floorGaps = readinessSkillFloorGaps(finalState);
+  if (floorGaps.length) {
+    throw new Error('Aria readiness final QA failed: ' + floorGaps.join(' | '));
+  }
+  const actionLedger = recordCodexActionEvent({
+    event,
+    state: {
+      ...finalState,
+      turnSubstratePacket: packetWrite.packet || turnSubstratePacket,
+    },
+    sessionId,
+    ledgerResult,
+    lifecyclePhase: 'pre_cognition',
+    status: 'verified',
+    intent: userText || 'Codex pre-cognition turn packet prepared',
+    evidenceRefs: [
+      packetRef,
+      makeEvidenceRef('mizan_pre_receipt', result?.receipt || null, { sessionId, traceId }),
+      makeEvidenceRef('turn_substrate_packet', packetWrite.packet || turnSubstratePacket, { sessionId, traceId }),
+      ...(forcedSkillLoad ? [makeEvidenceRef('forced_skill_load', forcedSkillLoad, { sessionId, traceId })] : []),
+    ],
+    skillReceipt: forcedSkillLoad,
+    runtimeReceipt: {
+      preReceiptId: result?.receipt?.receiptId || null,
+      lifecycleStart,
+      turnSubstratePacketWritten: packetWrite.ok === true,
+    },
+    qaReceipt: {
+      schema: 'aria.codex_native_action_qa.v1',
+      phase: 'pre_cognition',
+      readinessStatus: 'ready',
+      firedSkillCount,
+      minimumSkillFloor: ARIA_CODEX_MINIMUM_SKILL_FLOOR,
+      readinessPhases,
+      floorGaps,
+      passed: floorGaps.length === 0,
+    },
+    correctionPlan: {
+      required: floorGaps.length > 0,
+      findings: floorGaps,
+    },
+    learningDelta: {
+      style: 'dalio_reflexion',
+      lesson: 'Native UserPromptSubmit must write the same action spine it expects later hooks to consume.',
+      nextAction: 'PreToolUse consumes the turn packet and appends a pre_tool action event.',
+    },
+    metadata: {
+      hook: 'aria-userprompt-submit',
+      readinessCurrentPhase: 'ready',
+      universalTurnPacket: true,
+    },
+  });
+  const actionLedgerPublish = await publishCodexActionEventToRuntime(actionLedger);
+  const stateWithActionLedger = saveTurnState(sessionId, {
+    actionLedger: {
+      projectId: actionLedger.event?.projectId || finalState?.actionLedger?.projectId || null,
+      taskId: actionLedger.event?.taskId || finalState?.actionLedger?.taskId || null,
+      latestEventId: actionLedger.event?.eventId || null,
+      latestEventHash: actionLedger.event?.eventHash || null,
+      projectionPath: actionLedger.paths?.projectionPath || null,
+      eventCount: actionLedger.projection?.eventCount || 0,
+      runtimePublish: actionLedgerPublish,
+    },
+  });
+  const harnessTicker = buildHarnessLiveTicker(priorState);
+  saveTurnState(sessionId, { ...stateWithActionLedger, harnessTicker });
+  if (process.env.ARIA_CODEX_TICKER_STDERR === '1') {
+    process.stderr.write(`${harnessTicker.line}\n`);
+  }
+  emitJson({
+    hookSpecificOutput: {
+      hookEventName: 'UserPromptSubmit',
+      additionalContext: [
+        harnessTicker.line,
+        '--- ARIA CODEX READINESS QUEUE ---',
+        'Status: ready',
+        `Minimum skill floor: ${firedSkillCount}/${ARIA_CODEX_MINIMUM_SKILL_FLOOR}`,
+        `Universal packet: runtimes ${forcedSkillLoad.activeRuntimes?.length || 0}/${ARIA_CODEX_UNIVERSAL_RUNTIME_FLOOR}; primitives ${forcedSkillLoad.activePrimitives?.length || 0}/${ARIA_CODEX_UNIVERSAL_PRIMITIVE_FLOOR}; mappings ${forcedSkillLoad.activeMappings?.length || 0}/${ARIA_CODEX_UNIVERSAL_MAPPING_FLOOR}`,
+        `Cognitive runtimes: tadabbur=${forcedSkillLoad.cognitiveRuntimeReceipts?.tadabbur?.stageCount || 0}/12; qiyas=${forcedSkillLoad.cognitiveRuntimeReceipts?.qiyas?.perspectiveCount || 0}/15; noor=${forcedSkillLoad.cognitiveRuntimeReceipts?.noor?.noorSuiteCount || 0}/14`,
+        formatProjectBoundaryPrompt(projectBoundary),
+        `Hive ledger: ${ledgerResult.ledger.ledgerId}`,
+        `Action ledger: ${actionLedger.event?.eventId || 'unrecorded'} events=${actionLedger.projection?.eventCount || 0}`,
+        `Mizan pre receipt: ${result?.receipt?.receiptId || 'missing'}`,
+        'QA: Qiyas-15 + Tadabbur-12 correction cycle recorded for every readiness phase.',
+        'Prompt release: allowed; pre-tool and stop hooks must re-check readiness before action or completion claims.',
+      ].join('\n'),
+    },
+  });
+} catch (error) {
+  const fallbackReason = error instanceof Error ? error.message : String(error);
+  const localForcedSkillLoad = buildLocalMechanicalSkillLoad({
+    requiredSkills,
+    reason: fallbackReason,
+    source: 'codex-userprompt-submit',
+  });
+  forcedSkillLoad = localForcedSkillLoad;
+  const firedSkillCount = localForcedSkillLoad.skillExecutionReceipt.firedSkillIds.length;
+  const localState = saveTurnState(sessionId, {
+    traceId,
+    userId,
+    userText,
+    requiredSkills,
+    forcedSkillLoad: localForcedSkillLoad,
+    universalTurnPacket: true,
+    goalContract,
+    forcedSkillLoadEnforced: true,
+    forcedSkillAutofire: true,
+    orchestratorContinuityMode: localForcedSkillLoad.continuityMode,
+    hiveThreadId,
+    readiness: {
+      status: 'degraded_local_continuity',
+      currentPhase: 'local_orchestrator_continuity',
+      progress: 100,
+      phases: readinessPhases,
+      minimumSkillFloor: ARIA_CODEX_MINIMUM_SKILL_FLOOR,
+      forcedSkillLoad: localForcedSkillLoad,
+      universalTurnPacket: true,
+      firedSkillCount,
+      runtimeVerified: false,
+      runtimePrimaryVerified: false,
+      localContinuityOnly: true,
+      runtimeRecoveryRequired: true,
+      runtimeError: fallbackReason,
+    },
+    claimScopes: {
+      readiness: 'local_continuity_only',
+      runtime: 'unverified',
+      production: 'unverified',
+    },
+    lastEvent: 'UserPromptSubmit',
+  });
+  const turnSubstratePacket = buildTurnSubstratePacket({
+    sessionId,
+    event,
+    state: localState,
+    phase: 'pre_prompt_local_orchestrator_continuity',
+    text: userText,
+    evidenceRefs: [
+      makeEvidenceRef('local_mechanical_skill_load', localForcedSkillLoad, { sessionId, traceId }),
+    ],
+  });
+  const packetWrite = writeTurnSubstratePacket(turnSubstratePacket, { sessionId, event, state: localState });
+  saveTurnState(sessionId, {
+    turnSubstratePacket: packetWrite.packet || turnSubstratePacket,
+    turnSubstratePacketRef: makeEvidenceRef('turn_substrate_packet', packetWrite.packet || turnSubstratePacket, { sessionId, traceId }),
+  });
+  const actionLedger = recordCodexActionEvent({
+    event,
+    state: {
+      ...localState,
+      turnSubstratePacket: packetWrite.packet || turnSubstratePacket,
+    },
+    sessionId,
+    ledgerResult,
+    lifecyclePhase: 'pre_cognition',
+    status: 'repaired',
+    intent: userText || 'Codex pre-cognition released through local mechanical continuity',
+    evidenceRefs: [
+      makeEvidenceRef('local_mechanical_skill_load', localForcedSkillLoad, { sessionId, traceId }),
+      makeEvidenceRef('turn_substrate_packet', packetWrite.packet || turnSubstratePacket, { sessionId, traceId }),
+    ],
+    skillReceipt: localForcedSkillLoad,
+    runtimeReceipt: {
+      runtimeVerified: false,
+      runtimeRecoveryRequired: true,
+      runtimeError: fallbackReason,
+    },
+    qaReceipt: {
+      schema: 'aria.codex_native_action_qa.v1',
+      phase: 'pre_cognition',
+      readinessStatus: 'degraded_local_continuity',
+      firedSkillCount,
+      minimumSkillFloor: ARIA_CODEX_MINIMUM_SKILL_FLOOR,
+      passed: firedSkillCount >= ARIA_CODEX_MINIMUM_SKILL_FLOOR,
+    },
+    correctionPlan: {
+      required: true,
+      findings: [`runtime recovery required: ${fallbackReason}`],
+    },
+    learningDelta: {
+      style: 'dalio_reflexion',
+      lesson: 'When runtime receipts are unavailable, native hooks still preserve a bounded local action spine and claim boundary.',
+      nextAction: 'Recover runtime path before claiming runtime-backed production behavior.',
+    },
+    metadata: {
+      hook: 'aria-userprompt-submit',
+      continuityMode: localForcedSkillLoad.continuityMode,
+      readinessStatus: 'degraded_local_continuity',
+      readinessCurrentPhase: 'local_orchestrator_continuity',
+      universalTurnPacket: true,
+    },
+  });
+  const actionLedgerPublish = await publishCodexActionEventToRuntime(actionLedger);
+  saveTurnState(sessionId, {
+    actionLedger: {
+      projectId: actionLedger.event?.projectId || null,
+      taskId: actionLedger.event?.taskId || null,
+      latestEventId: actionLedger.event?.eventId || null,
+      latestEventHash: actionLedger.event?.eventHash || null,
+      projectionPath: actionLedger.paths?.projectionPath || null,
+      eventCount: actionLedger.projection?.eventCount || 0,
+      runtimePublish: actionLedgerPublish,
+    },
+  });
+  await markReadiness('ready', 'degraded', {
+    continuityMode: 'local_mechanical_orchestrator',
+    firedSkillCount,
+    runtimeError: fallbackReason,
+  }).catch(() => null);
+  const harnessTicker = buildHarnessLiveTicker(priorState);
+  saveTurnState(sessionId, { harnessTicker });
+  if (process.env.ARIA_CODEX_TICKER_STDERR === '1') {
+    process.stderr.write(`${harnessTicker.line}\n`);
+  }
+  emitJson({
+    hookSpecificOutput: {
+      hookEventName: 'UserPromptSubmit',
+      additionalContext: [
+        harnessTicker.line,
+        '--- ARIA CODEX ORCHESTRATOR CONTINUITY ---',
+        'Status: degraded local mechanical orchestrator continuity; runtime-backed receipts are not verified.',
+        `Mechanical skills fired: ${firedSkillCount}/${ARIA_CODEX_MINIMUM_SKILL_FLOOR}`,
+        `Continuity mode: ${localForcedSkillLoad.continuityMode}`,
+        `Action ledger: ${actionLedger.event?.eventId || 'unrecorded'} events=${actionLedger.projection?.eventCount || 0}`,
+        `Runtime recovery required: ${fallbackReason}`,
+        'Claim boundary: runtime/hive/garden receipts are unverified until the mounted runtime recovers; do not claim production readiness from this fallback.',
+        'Execution rule: continue work from the forced skill packet; hard stops remain limited to destructive actions, secrets, deploy/publication, owner contradiction, and false completion claims.',
+        `Forced skills: ${localForcedSkillLoad.skillExecutionReceipt.firedSkillIds.join(', ')}`,
+      ].join('\n'),
+    },
+  });
+}