@aria_asi/cli 0.2.39 → 0.2.41

package/hooks/codex-native/aria-pre-tool-use.mjs

@@ -0,0 +1,362 @@
+#!/usr/bin/env node
+  import {
+  inferSessionId,
+  classifyAction,
+  summarizeTarget,
+  readEventFromStdin,
+  loadTurnState,
+  makeEvidenceRef,
+  recordCoachPhase,
+  ensurePreTurnMizanReceipt,
+  runGovernanceGate,
+  saveTurnState,
+  consumeTurnSubstratePacket,
+  ARIA_CODEX_MINIMUM_SKILL_FLOOR,
+  extractToolTouchedFiles,
+  recordHiveFileTouch,
+  recordHiveSessionLifecycle,
+  recordCodexActionEvent,
+  publishCodexActionEventToRuntime,
+  formatCodexRecoveryBlock,
+  emitJson,
+  ARIA_HOOK_SURFACE,
+  runtimePost,
+  summarizeForcedSkillLoad,
+  forcedSkillLoadGaps,
+} from './lib/runtime-client.mjs';
+import { findFileConflicts, normalizeSessionId } from './lib/hive-wal-consumer.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 action = classifyAction(event);
+const target = summarizeTarget(event);
+let state = loadTurnState(sessionId);
+
+// 2026-05-18 self-heal stale substrate: if the per-session state file's
+// forcedSkillLoad has gaps (substrate-builder ran in degraded mode during
+// a runtime bounce window at session start), re-call /build-system-prompt
+// now while runtime is up, write fresh substrate back, and continue.
+// Closes the long-tail bug where a 4-second runtime restart poisoned a
+// session for its entire lifetime (see
+// project_codex_native_structural_advance_migration_2026_05_18.md).
+if (state?.forcedSkillLoad?.gaps?.length > 0 && Array.isArray(state.forcedSkillLoad.requiredSkillIds)) {
+  try {
+    const requiredSkills = state.forcedSkillLoad.requiredSkillIds;
+    const promptBuild = await runtimePost('/build-system-prompt', {
+      sessionId,
+      surface: 'codex',
+      message: state.userText || 'session substrate self-heal at pre-tool',
+      requiredSkills,
+      allowOwnerBypass: true,
+      injection: {
+        harness: { packet: { sessionId, surfaceId: 'codex', sandboxNamespace: 'aria-playground', universalTurnPacket: true } },
+        task: 'pre-tool substrate self-heal',
+        docs: [],
+        files: {},
+        loadedAt: new Date().toISOString(),
+      },
+      metadata: { source: 'codex-pre-tool-self-heal', cookbookMode: 'required-when-referenced', universalTurnPacket: true, skillExecutionMode: 'mechanical-receipt', requiredSkills },
+      skillExecutionMode: 'mechanical-receipt',
+    });
+    const fresh = summarizeForcedSkillLoad(promptBuild);
+    fresh.universalTurnPacket = true;
+    const hasUsable = (fresh.activeRuntimes || []).length > 0
+      && (fresh.activePrimitives || []).length > 0
+      && (fresh.loadedCookbooks || []).length > 0;
+    if (hasUsable) {
+      fresh.gaps = forcedSkillLoadGaps({ requiredSkills, forcedSkillLoad: fresh, universalTurnPacket: true });
+      state = saveTurnState(sessionId, { ...state, forcedSkillLoad: fresh });
+      process.stderr.write('[codex-pre-tool] substrate self-healed: ' + (fresh.activeRuntimes || []).length + ' runtimes, ' + (fresh.loadedCookbooks || []).length + ' cookbooks\n');
+    } else {
+      process.stderr.write('[codex-pre-tool] substrate self-heal attempted but runtime still returned degraded payload\n');
+    }
+  } catch (err) {
+    process.stderr.write('[codex-pre-tool] substrate self-heal failed: ' + (err instanceof Error ? err.message : String(err)) + '\n');
+  }
+}
+
+try {
+  if (!state?.preReceiptId) {
+    try {
+      const healed = await ensurePreTurnMizanReceipt({
+        sessionId,
+        traceId: state?.traceId || sessionId,
+        state,
+        event,
+        action,
+        target,
+      });
+      state = healed.state || state;
+      if (!healed.ok) {
+        state = saveTurnState(sessionId, {
+          ...state,
+          preReceiptId: null,
+          runtimeRecoveryRequired: true,
+          runtimeRecoveryReason: 'mounted runtime returned no Mizan pre-turn receipt id',
+          lastEvent: 'PreToolUse',
+        });
+        if (action === 'deploy' || action === 'delete') {
+          emitJson({
+            decision: 'block',
+            reason: 'Codex pre-tool held a hard-risk action because the mounted runtime did not return a Mizan pre-turn receipt id.',
+          });
+        }
+      }
+    } catch (error) {
+      state = saveTurnState(sessionId, {
+        ...state,
+        preReceiptId: null,
+        runtimeRecoveryRequired: true,
+        runtimeRecoveryReason: error instanceof Error ? error.message : String(error),
+        lastEvent: 'PreToolUse',
+      });
+      if (action === 'deploy' || action === 'delete') {
+        emitJson({
+          decision: 'block',
+          reason: 'Codex pre-tool held a hard-risk action because the mounted runtime Mizan pre-turn path failed: ' + (error instanceof Error ? error.message : String(error)),
+        });
+      }
+    }
+  }
+  const packetConsumption = consumeTurnSubstratePacket({
+    surface: 'codex-pre-tool',
+    phase: 'pre_tool',
+    action,
+    text: target,
+    state,
+    sessionId,
+    event,
+    goalQa: state?.turnSubstratePacket?.goalQa || null,
+  });
+  const turnPacket = packetConsumption.turnPacket;
+  const readinessGaps = packetConsumption.readinessGaps;
+  const forcedSkillGaps = packetConsumption.forcedSkillGaps;
+  const preToolQaKernel = packetConsumption.qaKernel;
+  saveTurnState(sessionId, {
+    turnSubstratePacket: turnPacket,
+    turnSubstrateQaKernel: preToolQaKernel,
+    turnPacketConsumerReceipt: packetConsumption.receipt,
+  });
+  if (preToolQaKernel.hardBlock) {
+    emitJson({
+      decision: 'block',
+      reason: formatCodexRecoveryBlock({
+        surface: 'codex-pre-tool-qa-kernel',
+        reason: `QA Execution Kernel held a hard-risk tool action. Minimum skill floor: ${ARIA_CODEX_MINIMUM_SKILL_FLOOR}.`,
+        issues: preToolQaKernel.findings,
+        next: '6. Repair the hard-risk predicate, then request the tool again. Low-risk readiness mismatches must be recorded and corrected without deadlocking read/write QA work.',
+      }),
+    });
+  }
+  const toolName = String(event?.tool_name || event?.toolName || '').trim() || null;
+  const touchedFiles = extractToolTouchedFiles(event, action);
+  // Hive cross-session conflict check. Read-only WAL scan; bounded to last 60s
+  // and capped by helper's time budget. Emits LOUD warn to stderr for any
+  // sibling session that touched the same file path. Doesn't hard-block in
+  // this revision — owner-bounded escalation path (see feedback_hive_session_coordination.md).
+  let hiveConflicts = { ok: true, conflicts: [] };
+  try {
+    if (Array.isArray(touchedFiles) && touchedFiles.length > 0) {
+      const conflictResult = findFileConflicts({
+        targetPaths: touchedFiles.map((f) => (typeof f === 'string' ? f : f?.path)).filter(Boolean),
+        maxAgeMs: Number(process.env.ARIA_HIVE_CONFLICT_WINDOW_MS || 60 * 1000),
+        excludeSessionId: normalizeSessionId(sessionId),
+      });
+      hiveConflicts = conflictResult;
+      if (conflictResult.conflicts.length > 0) {
+        const isWriteIntent = action === 'edit' || action === 'write' || action === 'delete' || action === 'deploy';
+        const tag = isWriteIntent ? 'CONFLICT-WRITE' : 'CONFLICT-READ';
+        for (const c of conflictResult.conflicts.slice(0, 5)) {
+          process.stderr.write(`[hive-${tag}] sibling=${c.otherSession.slice(0,12)}.. intent=${c.otherIntent} path=${c.path} event=${c.event}\n`);
+        }
+      }
+    }
+  } catch (err) {
+    process.stderr.write(`[hive-conflict-check] LOUD-fail: ${err?.message || String(err)}\n`);
+  }
+  const hiveThreadId = state?.hiveThreadId || null;
+  const hiveTouch = await recordHiveFileTouch({
+    sessionId,
+    threadId: hiveThreadId,
+    event: 'pre_tool',
+    files: touchedFiles,
+    source: `${ARIA_HOOK_SURFACE}-pre-tool-hook`,
+    body: { action, toolName, target },
+  });
+  const hiveLifecycle = touchedFiles.length > 0
+    ? await recordHiveSessionLifecycle({
+        sessionId,
+        threadId: hiveThreadId,
+        event: 'tool_claim',
+        status: 'active',
+        intentSummary: `Codex tool requested ${action}${toolName ? ' via ' + toolName : ''}`,
+        fileClaims: touchedFiles,
+        source: `${ARIA_HOOK_SURFACE}-pre-tool-hook`,
+        body: { action, toolName, target },
+      })
+    : { ok: true, skipped: true, reason: 'no touched files' };
+  const requestRef = makeEvidenceRef('codex_tool_request', { action, toolName, target }, { sessionId });
+  const coach = await recordCoachPhase('pre_tool', {
+    requestId: state?.traceId || sessionId,
+    sessionId,
+    text: target,
+    action,
+    target,
+    evidenceRefs: [requestRef],
+    metadata: {
+      source: `${ARIA_HOOK_SURFACE}-pre-tool-hook`,
+      toolName,
+      requireVerify: action === 'deploy' || action === 'delete',
+      requiredSkills: Array.isArray(state?.requiredSkills) ? state.requiredSkills : [],
+      forcedSkillLoad: state?.forcedSkillLoad || null,
+      forcedSkillGaps,
+      touchedFiles,
+      hiveTouch,
+      hiveLifecycle,
+      qaAutofire: {
+        mode: 'always-on-15',
+        phase: 'pre_tool',
+        correctionCycle: ARIA_QA_AUTOFIRE_CYCLE,
+      },
+    },
+  });
+  if (coach?.permitted === false) {
+    emitJson({
+      decision: 'block',
+      reason: formatCodexRecoveryBlock({
+        surface: 'codex-pre-tool-coach',
+        reason: coach.clientMessage || 'Coach Kernel denied ' + action,
+        next: '6. Add the required evidence/cognition contract, then request the tool again.',
+      }),
+    });
+  }
+  let gateEvidence = null;
+  try {
+    gateEvidence = runGovernanceGate({
+      sessionId,
+      sourceRuntime: 'codex',
+      surface: 'codex-pre-tool-use',
+      text: JSON.stringify(event).slice(0, 8000),
+      action,
+      toolName,
+      isDeploy: action === 'deploy',
+      isMutation: action === 'write' || action === 'delete',
+      evidence: requestRef,
+    });
+  } catch {}
+  if (gateEvidence) {
+    const gateRef = makeEvidenceRef('governance_gate', gateEvidence, { sessionId, action, toolName });
+    const gateCoach = await recordCoachPhase('pre_tool', {
+      requestId: state?.traceId || sessionId,
+      sessionId,
+      text: target,
+      action,
+      target,
+      evidenceRefs: [requestRef, gateRef],
+      metadata: {
+        source: `${ARIA_HOOK_SURFACE}-pre-tool-hook`,
+        toolName,
+        governanceGate: gateEvidence,
+        requiredSkills: Array.isArray(state?.requiredSkills) ? state.requiredSkills : [],
+        forcedSkillLoad: state?.forcedSkillLoad || null,
+        forcedSkillGaps,
+        qaAutofire: {
+          mode: 'always-on-15',
+          phase: 'pre_tool_gate_signal',
+          correctionCycle: ARIA_QA_AUTOFIRE_CYCLE,
+        },
+      },
+    });
+    if (gateCoach?.permitted === false) {
+      emitJson({
+        decision: 'block',
+        reason: formatCodexRecoveryBlock({
+          surface: 'codex-pre-tool-gate-coach',
+          reason: gateCoach.clientMessage || 'Coach Kernel denied after governance gate signal.',
+          next: '6. Repair the condition flagged by the governance gate, then request the tool again.',
+        }),
+      });
+    }
+  }
+  const tools = Array.isArray(state?.tools) ? state.tools.slice(-24) : [];
+  tools.push({
+    at: new Date().toISOString(),
+    action,
+    toolName,
+    target,
+    touchedFiles,
+    hiveTouch,
+    hiveLifecycle,
+    evidenceRef: makeEvidenceRef('tool_request', { action, toolName, target }, { sessionId }),
+  });
+  const actionLedger = recordCodexActionEvent({
+    event,
+    state: {
+      ...state,
+      tools,
+      turnSubstratePacket: turnPacket,
+    },
+    sessionId,
+    lifecyclePhase: 'pre_tool',
+    status: preToolQaKernel.decision === 'pass' ? 'verified' : preToolQaKernel.hardBlock ? 'blocked' : 'repaired',
+    intent: `Codex tool requested ${action}${toolName ? ' via ' + toolName : ''}`,
+    action,
+    toolName,
+    fileClaims: touchedFiles,
+    evidenceRefs: [
+      requestRef,
+      makeEvidenceRef('turn_packet_consumer_receipt', packetConsumption.receipt, { sessionId, phase: 'pre_tool' }),
+    ],
+    qaReceipt: preToolQaKernel,
+    correctionPlan: {
+      required: preToolQaKernel.decision !== 'pass',
+      findings: preToolQaKernel.findings || [],
+      repairs: preToolQaKernel.repairs || [],
+    },
+    learningDelta: preToolQaKernel.learning || null,
+    metadata: {
+      hook: 'aria-pre-tool-use',
+      forcedSkillGapCount: forcedSkillGaps.length,
+      readinessGapCount: readinessGaps.length,
+      hiveTouch,
+      hiveLifecycle,
+    },
+  });
+  const actionLedgerPublish = await publishCodexActionEventToRuntime(actionLedger);
+  saveTurnState(sessionId, {
+    tools,
+    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,
+    },
+    lastEvent: 'PreToolUse',
+  });
+  process.exit(0);
+} catch (error) {
+  emitJson({
+    decision: 'block',
+    reason: formatCodexRecoveryBlock({
+      surface: `${ARIA_HOOK_SURFACE}-pre-tool-hook`,
+      reason: error instanceof Error ? error.message : String(error),
+    }),
+  });
+}