@aria_asi/cli 0.2.40 → 0.2.41

package/hooks/codex-native/aria-stop.mjs

@@ -0,0 +1,691 @@
+#!/usr/bin/env node
+import {
+  inferSessionId,
+  extractAssistantText,
+  readEventFromStdin,
+  runtimePost,
+  recordHiveSessionLifecycle,
+  recordCoachPhase,
+  loadTurnState,
+  saveTurnState,
+  makeEvidenceRef,
+  clearTurnState,
+  inferRequiredAriaSkills,
+  forcedSkillLoadGaps,
+  readinessSkillFloorGaps,
+  ARIA_CODEX_MINIMUM_SKILL_FLOOR,
+  fullCognitionMethodGaps,
+  buildUniversalConnectorGoalContract,
+  evaluateGoalContractOutput,
+  buildTurnSubstratePacket,
+  loadTurnSubstratePacket,
+  writeTurnSubstratePacket,
+  evaluateQaExecutionKernel,
+  consumeTurnSubstratePacket,
+  runEndOfPhaseQaAutofire,
+  formatValidationFailure,
+  formatCodexRecoveryBlock,
+  isAriaControlBlock,
+  runGovernanceGate,
+  updateTaskProjectLedger,
+  evaluateTaskProjectClaim,
+  recordBlockedTaskProjectClaim,
+  recordCodexActionEvent,
+  publishCodexActionEventToRuntime,
+  emitJson,
+  ARIA_HOOK_SURFACE,
+} from './lib/runtime-client.mjs';
+import { evaluateProjectEndBoundary, formatProjectBoundaryBlock } 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 sessionId = inferSessionId(event);
+const state = loadTurnState(sessionId);
+const text = extractAssistantText(event);
+
+const outputRef = makeEvidenceRef('assistant_output', text, { sessionId, traceId: state?.traceId || null });
+const toolRefs = Array.isArray(state?.toolOutputs) ? state.toolOutputs.map((entry) => entry.evidenceRef).filter(Boolean) : [];
+const inferredRequiredSkills = inferRequiredAriaSkills(state?.userText || '');
+const ledgerResult = updateTaskProjectLedger({
+  platform: 'codex',
+  phase: 'stop',
+  source: `${ARIA_HOOK_SURFACE}-stop-hook`,
+  event: { ...event, text, sessionId, cwd: process.cwd() },
+});
+
+try {
+  // ── Cross-phase: unacknowledged tool failures (runs FIRST) ─────────
+  // Plan §12 G-cross-phase. Reads its own text source so the check works
+  // even when extractAssistantText returns empty (e.g. /dev/null transcript
+  // in integration smoke). When chained state has an unacknowledged tool
+  // failure and the Stop emit claims completion without acknowledging,
+  // block with recovery directive. Runs before the !text short-circuit so
+  // integration smoke can drive it via event.test_assistant_text.
+  const crossPhaseText = String(event?.test_assistant_text || text || '');
+  const unackFailures = Array.isArray(state?.unacknowledgedToolFailures) ? state.unacknowledgedToolFailures : [];
+  if (unackFailures.length > 0 && crossPhaseText) {
+    const failureRefs = unackFailures.flatMap((f) => [f.toolName, f.action, ...(Array.isArray(f.touchedFiles) ? f.touchedFiles : [])].filter(Boolean));
+    const ACKNOWLEDGMENT_RX = /\b(?:fail(?:ed|ure|s)?|error|errored|did\s+not\s+(?:pass|complete|succeed)|broke|broken|crashed|exit\s*[1-9]|exit_code\s*[:=]?\s*[1-9]|exited\s+non-zero|red|regression|blocked|pending|unfinished|incomplete|not\s+(?:done|ready|complete))\b/i;
+    const COMPLETION_CLAIM_RX = /\b(?:production\s+ready|release\s+ready|(?:this|it|the\s+\w+)\s+is\s+(?:complete|completed|done|shipped|verified)|(?:we|i)\s+(?:have|'ve)\s+(?:complete|completed|shipped|done|verified))\b/i;
+    const referencesFailure = failureRefs.some((ref) => ref && crossPhaseText.toLowerCase().includes(String(ref).toLowerCase()));
+    const acknowledgesFailure = ACKNOWLEDGMENT_RX.test(crossPhaseText) || referencesFailure;
+    const claimsCompletion = COMPLETION_CLAIM_RX.test(crossPhaseText);
+    if (claimsCompletion && !acknowledgesFailure) {
+      const recent = unackFailures[unackFailures.length - 1];
+      emitJson({
+        decision: 'block',
+        reason: formatCodexRecoveryBlock({
+          surface: `${ARIA_HOOK_SURFACE}-stop-cross-phase`,
+          reason: `Cross-phase gate: a PostToolUse recorded an unacknowledged tool failure earlier in this turn (${recent.toolName || 'tool'} ${recent.action || 'action'}: ${recent.errorSummary || 'no detail'}). The Stop emit claims completion but does not acknowledge or address the failure.`,
+          issues: unackFailures.slice(-3).map((f) => `${f.toolName || 'tool'} (${f.action || 'action'}): ${f.errorSummary || f.responseSummary || ''}`.slice(0, 200)),
+          next: '6. Acknowledge each failure by name OR retract the completion claim and emit bounded status. Then re-submit.',
+        }),
+      });
+    }
+    if (acknowledgesFailure) {
+      saveTurnState(sessionId, { unacknowledgedToolFailures: [] });
+    }
+  }
+
+  if (!text) {
+    emitJson({ continue: true });
+  }
+  if (isAriaControlBlock(text)) {
+    clearTurnState(sessionId);
+    emitJson({ continue: true });
+  }
+  const loadedTurnPacket = loadTurnSubstratePacket({ sessionId, event, state });
+  const stateWithPacket = loadedTurnPacket ? { ...state, turnSubstratePacket: loadedTurnPacket } : state;
+  const cognitionMethodGaps = fullCognitionMethodGaps({ state, text });
+  const qaAutofire = {
+    mode: 'always-on-15',
+    phase: 'stop',
+    correctionCycle: ARIA_QA_AUTOFIRE_CYCLE,
+    methodContract: ARIA_QA_METHOD_CONTRACT,
+  };
+  const goalContract = state?.goalContract || buildUniversalConnectorGoalContract({
+    userText: state?.userText || '',
+    phase: 'stop',
+  });
+  const goalQa = evaluateGoalContractOutput(text, {
+    userText: state?.userText || '',
+    goalContract,
+  });
+  const stopRuntimeGaps = [];
+  let stopConsumption = consumeTurnSubstratePacket({
+    surface: 'codex-stop',
+    phase: 'stop',
+    action: 'release',
+    text,
+    state: stateWithPacket,
+    sessionId,
+    event,
+    goalQa,
+    qualityGaps: cognitionMethodGaps,
+    evidenceRefs: [outputRef, ...toolRefs],
+  });
+  let readinessGaps = stopConsumption.readinessGaps;
+  let forcedSkillGaps = stopConsumption.forcedSkillGaps;
+  let stopQaKernel = stopConsumption.qaKernel;
+  let stopTurnPacket = stopConsumption.turnPacket;
+  let stopPacketWrite = stopConsumption.packetWrite;
+  saveTurnState(sessionId, {
+    ...stateWithPacket,
+    turnSubstratePacket: stopPacketWrite.packet || stopTurnPacket,
+    turnSubstratePacketRef: stopPacketWrite.ok ? makeEvidenceRef('turn_substrate_packet', stopPacketWrite.packet, { sessionId, phase: 'stop' }) : null,
+    turnSubstrateQaKernel: stopQaKernel,
+    turnPacketConsumerReceipt: stopConsumption.receipt,
+  });
+  function recordStopQaGap(surface, gap, next = '6. Keep the output bounded, record the QA finding, correct/enhance/harden in the next action, and only stop for hard-risk evidence.') {
+    if (gap) stopRuntimeGaps.push(String(gap));
+    stopConsumption = consumeTurnSubstratePacket({
+      surface,
+      phase: 'stop',
+      action: 'release',
+      text,
+      state: stateWithPacket,
+      sessionId,
+      event,
+      goalQa,
+      qualityGaps: [...cognitionMethodGaps, ...stopRuntimeGaps],
+      evidenceRefs: [outputRef, ...toolRefs],
+    });
+    readinessGaps = stopConsumption.readinessGaps;
+    forcedSkillGaps = stopConsumption.forcedSkillGaps;
+    stopQaKernel = stopConsumption.qaKernel;
+    stopTurnPacket = stopConsumption.turnPacket;
+    stopPacketWrite = stopConsumption.packetWrite;
+    saveTurnState(sessionId, {
+      ...stateWithPacket,
+      turnSubstratePacket: stopPacketWrite.packet || stopTurnPacket,
+      turnSubstratePacketRef: stopPacketWrite.ok ? makeEvidenceRef('turn_substrate_packet', stopPacketWrite.packet, { sessionId, phase: surface }) : null,
+      turnSubstrateQaKernel: stopQaKernel,
+      turnPacketConsumerReceipt: stopConsumption.receipt,
+    });
+    if (stopQaKernel.hardBlock) {
+      emitJson({
+        decision: 'block',
+        reason: formatCodexRecoveryBlock({
+          surface,
+          reason: 'QA execution kernel rejected a hard-risk stop-hook finding.',
+          issues: [...stopQaKernel.hardFindings, ...stopQaKernel.repairs],
+          next,
+        }),
+      });
+    }
+  }
+  if (stopQaKernel.hardBlock) {
+    emitJson({
+      decision: 'block',
+      reason: formatCodexRecoveryBlock({
+        surface: 'codex-stop-goal-contract',
+        reason: 'QA execution kernel rejected a hard-risk release condition',
+        issues: [...stopQaKernel.hardFindings, ...stopQaKernel.repairs],
+        next: '4. Re-author around the actual corpus-to-runtime wiring goal, name the next highest-impact action, include QA/correction/evidence, and keep receipts/gates as support only.',
+      }),
+    });
+  }
+  const postGenerationCoach = await recordCoachPhase('post_generation', {
+    requestId: state?.traceId || sessionId,
+    sessionId,
+    text,
+    evidenceRefs: [outputRef],
+    metadata: {
+      source: `${ARIA_HOOK_SURFACE}-stop-hook`,
+      requireCognitionBlock: false,
+      requireAppliedCognition: false,
+      requiredSkills: Array.isArray(state?.requiredSkills) ? state.requiredSkills : inferredRequiredSkills,
+      forcedSkillLoad: state?.forcedSkillLoad || null,
+      forcedSkillGaps,
+      turnSubstratePacket: stopPacketWrite.packet || stopTurnPacket,
+      qaKernel: stopQaKernel,
+      goalContract,
+      goalQa,
+      qaAutofire: { ...qaAutofire, phase: 'post_generation' },
+    },
+  });
+  if (postGenerationCoach?.permitted === false) {
+    recordStopQaGap('codex-stop-coach-post-generation', `coach post_generation: ${postGenerationCoach.clientMessage || 'Coach Kernel held Codex output before validation.'}`);
+  }
+  let gateEvidence = null;
+  try {
+    gateEvidence = runGovernanceGate({
+      sessionId,
+      sourceRuntime: 'codex',
+      surface: 'codex-stop',
+      text: text.slice(0, 8000),
+      isOutputCloseout: true,
+      evidence: outputRef,
+    });
+  } catch {}
+  const ledgerClaim = evaluateTaskProjectClaim({ text, ledger: ledgerResult.ledger });
+  if (!ledgerClaim.ok) {
+    recordBlockedTaskProjectClaim({
+      ledger: ledgerResult.ledger,
+      paths: ledgerResult.paths,
+      text,
+      evaluation: ledgerClaim,
+    });
+    recordStopQaGap(
+      'codex-stop-ledger',
+      [
+        `ledger claim: missing readiness gates ${ledgerClaim.missingReadinessGates.join(', ') || 'none'}`,
+        `ledger claim: open blockers ${ledgerClaim.openBlockers.length}`,
+      ].join(' | '),
+      '6. Record real verification evidence or emit bounded status without completion/readiness language, then re-submit.',
+    );
+  }
+  const validation = await runtimePost('/validate-output', {
+    text,
+    sessionId,
+    packetRequest: {
+      sessionId,
+      platform: 'codex',
+      message: state?.userText || 'codex stop validation',
+      stage: 'codex-stop',
+      actor: 'codex-hook',
+      system: 'codex-hook',
+    },
+    requireCognitionBlock: false,
+    runLayer3: true,
+  });
+  const preOutputCoach = await recordCoachPhase('pre_output', {
+    requestId: state?.traceId || sessionId,
+    sessionId,
+    text,
+    validation: validation?.validation || null,
+    layer3: validation?.layer3 || null,
+    evidenceRefs: [outputRef, makeEvidenceRef('runtime_validation', validation, { sessionId, traceId: state?.traceId || null }), ...(gateEvidence ? [makeEvidenceRef('governance_gate', gateEvidence, { sessionId })] : [])],
+    metadata: {
+      source: `${ARIA_HOOK_SURFACE}-stop-hook`,
+      requireCognitionBlock: false,
+      requireAppliedCognition: false,
+      governanceGate: gateEvidence || null,
+      requiredSkills: Array.isArray(state?.requiredSkills) ? state.requiredSkills : inferredRequiredSkills,
+      forcedSkillLoad: state?.forcedSkillLoad || null,
+      forcedSkillGaps,
+      turnSubstratePacket: stopPacketWrite.packet || stopTurnPacket,
+      qaKernel: stopQaKernel,
+      goalContract,
+      goalQa,
+      qaAutofire: { ...qaAutofire, phase: 'pre_output' },
+    },
+  });
+  if (preOutputCoach?.permitted === false) {
+    recordStopQaGap('codex-stop-coach-pre-output', `coach pre_output: ${preOutputCoach.clientMessage || 'Coach Kernel held Codex output before release.'}`);
+  }
+  if (validation?.pass === false || validation?.validation?.passed === false || validation?.layer3?.pass === false) {
+    recordStopQaGap('codex-stop-output', `runtime validation: ${formatValidationFailure(validation)}`);
+  }
+  const post = await runtimePost('/mizan/post', {
+    sessionId,
+    text,
+    evidence: {
+      validated_output: true,
+      validation_severity: validation?.validation?.severity || 'pass',
+      layer3_pass: validation?.layer3?.pass !== false,
+      surface: 'codex-hooks',
+      tool_count: Array.isArray(state?.tools) ? state.tools.length : 0,
+      trace_id: state?.traceId || null,
+      output_ref: outputRef,
+      tool_refs: toolRefs,
+      required_skills: Array.isArray(state?.requiredSkills) ? state.requiredSkills : inferredRequiredSkills,
+      forced_skill_load: state?.forcedSkillLoad || null,
+      forced_skill_gaps: forcedSkillGaps,
+      turn_substrate_packet: stopPacketWrite.packet || stopTurnPacket,
+      qa_kernel: stopQaKernel,
+      goal_contract: goalContract,
+      goal_qa: goalQa,
+      qa_autofire: { ...qaAutofire, phase: 'mizan_post' },
+    },
+    context: {
+      sessionId,
+      surface: 'codex-hooks',
+      platform: 'codex',
+      userText: state?.userText || null,
+      traceId: state?.traceId || null,
+    },
+    parentReceiptId: state?.preReceiptId || null,
+  });
+  const endPhaseQaAutofire = runEndOfPhaseQaAutofire({
+    sessionId,
+    phase: 'codex-stop-phase-close',
+    trigger: 'phase_close',
+    text,
+    qaKernel: stopQaKernel,
+    validation,
+    postReceipt: post?.receipt || null,
+    outputRef,
+    toolRefs,
+    ledger: ledgerResult.ledger,
+    source: `${ARIA_HOOK_SURFACE}-stop-hook`,
+  });
+  const projectBoundaryEnd = evaluateProjectEndBoundary({
+    userText: state?.userText || '',
+    assistantText: text,
+    endPhaseQaAutofire,
+    source: `${ARIA_HOOK_SURFACE}-stop-hook`,
+  });
+  if (!projectBoundaryEnd.ok) {
+    recordStopQaGap(
+      'codex-stop-project-boundary',
+      `project boundary closeout: ${projectBoundaryEnd.missing.join(', ')}`,
+      '6. Re-run project closeout with Qiyas-15, Tadabbur-12, and an evidence-bounded claim gate before release.',
+    );
+  }
+  await recordCoachPhase('post_output', {
+    requestId: state?.traceId || sessionId,
+    sessionId,
+    text,
+    validation: validation?.validation || null,
+    layer3: validation?.layer3 || null,
+    evidenceRefs: [
+      outputRef,
+      makeEvidenceRef('mizan_post_receipt', post?.receipt || null, { sessionId, traceId: state?.traceId || null }),
+    ],
+    metadata: {
+      source: `${ARIA_HOOK_SURFACE}-stop-hook`,
+      requireCognitionBlock: false,
+      requireAppliedCognition: false,
+      requiredSkills: Array.isArray(state?.requiredSkills) ? state.requiredSkills : inferredRequiredSkills,
+      forcedSkillLoad: state?.forcedSkillLoad || null,
+      forcedSkillGaps,
+      turnSubstratePacket: stopPacketWrite.packet || stopTurnPacket,
+      qaKernel: stopQaKernel,
+      goalContract,
+      goalQa,
+      qaAutofire: { ...qaAutofire, phase: 'post_output' },
+      endPhaseQaAutofire: {
+        verdict: endPhaseQaAutofire.receipt.claim_gate.verdict,
+        receiptHash: endPhaseQaAutofire.receipt.receipt_hash,
+        latestPath: endPhaseQaAutofire.latestPath,
+      },
+      projectBoundaryEnd,
+    },
+  });
+  if (!projectBoundaryEnd.ok) {
+    emitJson({
+      decision: 'block',
+      reason: formatCodexRecoveryBlock({
+        surface: 'codex-stop-project-boundary',
+        reason: formatProjectBoundaryBlock(projectBoundaryEnd),
+        issues: projectBoundaryEnd.missing,
+        next: '6. Re-author closeout from the end-phase QA receipt, keep the claim bounded to evidence, and resubmit.',
+      }),
+    });
+  }
+  await runtimePost('/decision/log', {
+    session_id: sessionId,
+    decision_type: 'operational',
+    category: 'codex-hooks',
+    context: `Codex native stop hook for ${sessionId}`,
+    decision: 'validated output release',
+    reasoning: 'Mounted Aria runtime validated the output, issued Mizan post, and preserved the turn in garden memory.',
+    summary: 'codex native stop hook validated output',
+    outcome: 'success',
+    surface: 'codex-hooks',
+    metadata: {
+      post_receipt_id: post?.receipt?.receiptId || null,
+      pre_receipt_id: state?.preReceiptId || null,
+      trace_id: state?.traceId || null,
+      output_ref: outputRef,
+      tool_refs: toolRefs,
+      tool_count: Array.isArray(state?.tools) ? state.tools.length : 0,
+      validation_severity: validation?.validation?.severity || 'pass',
+      layer3_pass: validation?.layer3?.pass !== false,
+      required_skills: Array.isArray(state?.requiredSkills) ? state.requiredSkills : inferredRequiredSkills,
+      forced_skill_load: state?.forcedSkillLoad || null,
+      forced_skill_gaps: forcedSkillGaps,
+      turn_substrate_packet: stopPacketWrite.packet || stopTurnPacket,
+      qa_kernel: stopQaKernel,
+      goal_contract: goalContract,
+      goal_qa: goalQa,
+      qa_autofire: { ...qaAutofire, phase: 'decision_log' },
+      end_phase_qa_autofire: {
+        verdict: endPhaseQaAutofire.receipt.claim_gate.verdict,
+        receipt_hash: endPhaseQaAutofire.receipt.receipt_hash,
+        latest_path: endPhaseQaAutofire.latestPath,
+      },
+      project_boundary_end: projectBoundaryEnd,
+    },
+  });
+  if (typeof state?.userText === 'string' && state.userText.trim()) {
+    await runtimePost('/garden/turn', {
+      sessionId,
+      message: state.userText,
+      response: text,
+      userId: state?.userId || undefined,
+      requireCognitionBlock: false,
+      metadata: {
+        decision_type: 'codex-stop-garden-turn',
+        decision_category: 'codex-hooks',
+        trace_id: state?.traceId || null,
+        output_ref: outputRef,
+        required_skills: Array.isArray(state?.requiredSkills) ? state.requiredSkills : inferredRequiredSkills,
+        forced_skill_load: state?.forcedSkillLoad || null,
+        forced_skill_gaps: forcedSkillGaps,
+        turn_substrate_packet: stopPacketWrite.packet || stopTurnPacket,
+        qa_kernel: stopQaKernel,
+        goal_contract: goalContract,
+        goal_qa: goalQa,
+        qa_autofire: { ...qaAutofire, phase: 'garden_turn' },
+        end_phase_qa_autofire: {
+          verdict: endPhaseQaAutofire.receipt.claim_gate.verdict,
+          receipt_hash: endPhaseQaAutofire.receipt.receipt_hash,
+          latest_path: endPhaseQaAutofire.latestPath,
+        },
+        project_boundary_end: projectBoundaryEnd,
+      },
+    });
+  }
+  updateTaskProjectLedger({
+    platform: 'codex',
+    phase: 'post_turn',
+    source: `${ARIA_HOOK_SURFACE}-stop-hook`,
+    event: { ...event, text, sessionId, cwd: process.cwd() },
+    evidence: {
+      post_turn: true,
+      output_ref: outputRef,
+      verification: false,
+      requiredSkills: Array.isArray(state?.requiredSkills) ? state.requiredSkills : inferredRequiredSkills,
+      forcedSkillLoad: state?.forcedSkillLoad || null,
+      forcedSkillGaps,
+      turnSubstratePacket: stopPacketWrite.packet || stopTurnPacket,
+      qaKernel: stopQaKernel,
+      goalContract,
+      goalQa,
+      qaAutofire: { ...qaAutofire, phase: 'post_turn_ledger' },
+      endPhaseQaAutofire: {
+        verdict: endPhaseQaAutofire.receipt.claim_gate.verdict,
+        receiptHash: endPhaseQaAutofire.receipt.receipt_hash,
+        latestPath: endPhaseQaAutofire.latestPath,
+      },
+      projectBoundaryEnd,
+    },
+  });
+  const releaseCoach = await recordCoachPhase('claim_or_release', {
+    requestId: state?.traceId || sessionId,
+    sessionId,
+    text,
+    validation: validation?.validation || null,
+    layer3: validation?.layer3 || null,
+    evidenceRefs: [outputRef, ...toolRefs],
+    metadata: {
+      source: `${ARIA_HOOK_SURFACE}-stop-hook`,
+      validated_output: true,
+      requireCognitionBlock: false,
+      requireAppliedCognition: false,
+      post_receipt_id: post?.receipt?.receiptId || null,
+      requiredSkills: Array.isArray(state?.requiredSkills) ? state.requiredSkills : inferredRequiredSkills,
+      forcedSkillLoad: state?.forcedSkillLoad || null,
+      forcedSkillGaps,
+      turnSubstratePacket: stopPacketWrite.packet || stopTurnPacket,
+      qaKernel: stopQaKernel,
+      goalContract,
+      goalQa,
+      qaAutofire: { ...qaAutofire, phase: 'claim_or_release' },
+      endPhaseQaAutofire: {
+        verdict: endPhaseQaAutofire.receipt.claim_gate.verdict,
+        receiptHash: endPhaseQaAutofire.receipt.receipt_hash,
+        latestPath: endPhaseQaAutofire.latestPath,
+      },
+      projectBoundaryEnd,
+    },
+  });
+  if (releaseCoach?.permitted === false) {
+    recordStopQaGap('codex-stop-coach-release', `coach claim_or_release: ${releaseCoach.clientMessage || 'Coach Kernel held the release claim.'}`);
+  }
+  const touchedFileMap = new Map();
+  for (const entry of [...(Array.isArray(state?.tools) ? state.tools : []), ...(Array.isArray(state?.toolOutputs) ? state.toolOutputs : [])]) {
+    for (const file of Array.isArray(entry?.touchedFiles) ? entry.touchedFiles : []) {
+      if (file?.path && !touchedFileMap.has(file.path)) touchedFileMap.set(file.path, file);
+    }
+  }
+  const actionLedger = recordCodexActionEvent({
+    event,
+    state: {
+      ...state,
+      turnSubstratePacket: stopPacketWrite.packet || stopTurnPacket,
+    },
+    sessionId,
+    ledgerResult,
+    lifecyclePhase: 'post_cognition',
+    status: projectBoundaryEnd.ok && validation?.pass !== false && validation?.validation?.passed !== false && validation?.layer3?.pass !== false ? 'verified' : 'repaired',
+    intent: (state?.userText || text || 'Codex stop hook validated output').slice(0, 240),
+    action: 'release',
+    fileClaims: [...touchedFileMap.values()],
+    evidenceRefs: [
+      outputRef,
+      ...toolRefs,
+      makeEvidenceRef('mizan_post_receipt', post?.receipt || null, { sessionId, traceId: state?.traceId || null }),
+      makeEvidenceRef('end_phase_qa_autofire', endPhaseQaAutofire.receipt, { sessionId, phase: 'codex-stop-phase-close' }),
+    ],
+    runtimeReceipt: {
+      preReceiptId: state?.preReceiptId || null,
+      postReceiptId: post?.receipt?.receiptId || null,
+      validationSeverity: validation?.validation?.severity || 'pass',
+      layer3Pass: validation?.layer3?.pass !== false,
+    },
+    qaReceipt: {
+      schema: 'aria.codex_native_action_qa.v1',
+      phase: 'post_cognition',
+      stopQaKernel,
+      goalQa,
+      endPhaseQaAutofire: {
+        verdict: endPhaseQaAutofire.receipt.claim_gate.verdict,
+        receiptHash: endPhaseQaAutofire.receipt.receipt_hash,
+      },
+      projectBoundaryEnd,
+      passed: projectBoundaryEnd.ok && stopQaKernel.hardBlock !== true,
+    },
+    correctionPlan: {
+      required: !projectBoundaryEnd.ok || stopQaKernel.decision !== 'pass',
+      findings: [
+        ...(!projectBoundaryEnd.ok ? projectBoundaryEnd.missing : []),
+        ...(stopQaKernel.findings || []),
+      ],
+      repairs: stopQaKernel.repairs || [],
+    },
+    learningDelta: {
+      style: 'dalio_reflexion',
+      lesson: 'Native stop release must close the same action spine that UserPromptSubmit and tool hooks opened.',
+      nextAction: 'Use the action ledger projection to evaluate turn-level QA and follow-up correction.',
+    },
+    metadata: {
+      hook: 'aria-stop',
+      validationPass: validation?.pass !== false,
+      projectBoundaryEndOk: projectBoundaryEnd.ok,
+      endPhaseQaLatestPath: endPhaseQaAutofire.latestPath,
+    },
+  });
+  const actionLedgerPublish = await publishCodexActionEventToRuntime(actionLedger);
+  saveTurnState(sessionId, {
+    actionLedger: {
+      projectId: actionLedger.event?.projectId || state?.actionLedger?.projectId || null,
+      taskId: actionLedger.event?.taskId || state?.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,
+    },
+  });
+  await recordHiveSessionLifecycle({
+    sessionId,
+    threadId: state?.hiveThreadId || null,
+    event: 'turn_complete',
+    status: 'completed',
+    intentSummary: (state?.userText || text || 'Codex turn completed').slice(0, 240),
+    fileClaims: [...touchedFileMap.values()],
+    source: `${ARIA_HOOK_SURFACE}-stop-hook`,
+    body: {
+      traceId: state?.traceId || null,
+      outputRef,
+      validationSeverity: validation?.validation?.severity || 'pass',
+      layer3Pass: validation?.layer3?.pass !== false,
+      turnSubstratePacket: stopPacketWrite.packet || stopTurnPacket,
+      qaKernel: stopQaKernel,
+      goalQa,
+      endPhaseQaAutofire: {
+        verdict: endPhaseQaAutofire.receipt.claim_gate.verdict,
+        receiptHash: endPhaseQaAutofire.receipt.receipt_hash,
+        latestPath: endPhaseQaAutofire.latestPath,
+      },
+      actionLedger: {
+        eventId: actionLedger.event?.eventId || null,
+        eventHash: actionLedger.event?.eventHash || null,
+        projectionPath: actionLedger.paths?.projectionPath || null,
+        eventCount: actionLedger.projection?.eventCount || 0,
+        runtimePublish: actionLedgerPublish,
+      },
+    },
+  });
+  clearTurnState(sessionId);
+  emitJson({ continue: true });
+} catch (error) {
+  const catchLoadedTurnPacket = loadTurnSubstratePacket({ sessionId, event, state });
+  const catchStateWithPacket = catchLoadedTurnPacket ? { ...state, turnSubstratePacket: catchLoadedTurnPacket } : state;
+  const catchGoalContract = state?.goalContract || buildUniversalConnectorGoalContract({
+    userText: state?.userText || '',
+    phase: 'stop',
+  });
+  const catchGoalQa = evaluateGoalContractOutput(text, {
+    userText: state?.userText || '',
+    goalContract: catchGoalContract,
+  });
+  const catchQaKernel = evaluateQaExecutionKernel({
+    surface: `${ARIA_HOOK_SURFACE}-stop-hook`,
+    phase: 'stop',
+    action: 'release',
+    text,
+    state: catchStateWithPacket,
+    turnPacket: catchLoadedTurnPacket,
+    goalQa: catchGoalQa,
+    readinessGaps: readinessSkillFloorGaps(catchStateWithPacket),
+    forcedSkillGaps: forcedSkillLoadGaps(catchStateWithPacket),
+    qualityGaps: [`runtime stop-hook exception: ${error instanceof Error ? error.message : String(error)}`],
+  });
+  const catchTurnPacket = buildTurnSubstratePacket({
+    sessionId,
+    event,
+    state: catchStateWithPacket,
+    phase: 'stop_exception',
+    action: 'release',
+    text,
+    evidenceRefs: [outputRef, ...toolRefs],
+    goalQa: catchGoalQa,
+    qaKernel: catchQaKernel,
+  });
+  writeTurnSubstratePacket(catchTurnPacket, { sessionId, event, state: catchStateWithPacket });
+  const catchActionLedger = recordCodexActionEvent({
+    event,
+    state: {
+      ...catchStateWithPacket,
+      turnSubstratePacket: catchTurnPacket,
+    },
+    sessionId,
+    ledgerResult,
+    lifecyclePhase: 'post_cognition',
+    status: 'failed',
+    intent: (state?.userText || text || 'Codex stop hook exception').slice(0, 240),
+    action: 'release',
+    evidenceRefs: [outputRef, ...toolRefs],
+    qaReceipt: catchQaKernel,
+    correctionPlan: {
+      required: true,
+      findings: [`runtime stop-hook exception: ${error instanceof Error ? error.message : String(error)}`],
+      repairs: catchQaKernel.repairs || [],
+    },
+    learningDelta: catchQaKernel.learning || null,
+    metadata: {
+      hook: 'aria-stop',
+      exception: error instanceof Error ? error.message : String(error),
+    },
+  });
+  await publishCodexActionEventToRuntime(catchActionLedger);
+  if (catchQaKernel.hardBlock) {
+    emitJson({
+      decision: 'block',
+      reason: formatCodexRecoveryBlock({
+        surface: `${ARIA_HOOK_SURFACE}-stop-hook`,
+        reason: error instanceof Error ? error.message : String(error),
+        issues: [...catchQaKernel.hardFindings, ...catchQaKernel.repairs],
+        next: '6. Re-open the turn substrate, repair the hook/runtime blocker, and re-submit with this recovery contract if it repeats.',
+      }),
+    });
+  }
+  emitJson({ continue: true });
+}