@aria_asi/cli 0.2.36 → 0.2.37

package/dist/runtime/hooks/aria-cognition-substrate-binding.mjs

@@ -34,9 +34,10 @@
 // 2026-04-27 gates are unconditional from the gated process. If the gate
 // misfires on legitimate cognition, fix the gate.
 
-import { readFileSync, appendFileSync, existsSync, mkdirSync } from 'node:fs';
+import { readFileSync, appendFileSync, existsSync, mkdirSync, writeFileSync } from 'node:fs';
 import { dirname } from 'node:path';
 import { homedir } from 'node:os';
+import { createHash } from 'node:crypto';
 import { ALL_LENS_NAMES, lensNamesForTier } from './lib/canonical-lenses.mjs';
 import { collectTurnWindowFromMessages } from './lib/hook-message-window.mjs';
 
@@ -79,6 +80,7 @@ const MEMORY_DIR = `${HOME}/.claude/projects/-home-hamzaibrahim1/memory`;
 const RECENT_VIOLATIONS_PATH = `${HOME}/.claude/.aria-recent-violations.jsonl`;
 const THRASHING_STATE_PATH = `${HOME}/.claude/.aria-thrashing-state.json`;
 const CLEAR_VIOLATIONS_SCRIPT = `${HOME}/.claude/aria-clear-violations.sh`;
+const CURRENT_RECOVERY_PATH = `${HOME}/.aria/governance-recovery-current.json`;
 
 function buildForceReauthorReason({ source, reason, violations = [] }) {
   return [
@@ -95,6 +97,11 @@ function buildForceReauthorReason({ source, reason, violations = [] }) {
     '- The cognition block must reference first_principle and must not cite inactive language state.',
     violations.length ? `\nVIOLATIONS TO FIX:\n${violations.map((v) => `- ${v}`).join('\n')}` : '',
     '',
+    'Recovery contract:',
+    '1. Do not retry the same blocked text unchanged.',
+    '2. Apply the teaching above to the next draft before re-emitting.',
+    '3. Re-test by submitting the revised cognition through this same gate.',
+    '',
     'REQUIRED REDO SHAPE:',
     '1. Re-emit <cognition> with all required lenses.',
     '2. Each lens cites >=1 loaded anchor: axiom:, frame:, memory:, doctrine:, packet:, or active language:.',
@@ -105,6 +112,45 @@ function buildForceReauthorReason({ source, reason, violations = [] }) {
   ].filter(Boolean).join('\n');
 }
 
+function recoveryFingerprint(reason, source = 'substrate-binding') {
+  return createHash('sha256')
+    .update([source, String(reason || '').replace(/\s+/g, ' ').trim().slice(0, 1200)].join('\0'))
+    .digest('hex');
+}
+
+function emitRecoverableSubstrateBinding(reason, { source = 'substrate-binding' } = {}) {
+  const fingerprint = recoveryFingerprint(reason, source);
+  const recovery = {
+    schema: 'aria.governance_recovery_current.v1',
+    updatedAt: new Date().toISOString(),
+    deliveryRule: 'This file is injected into the next system prompt. Execute recoveryLoop.nextStep before any completion claim.',
+    ok: true,
+    decision: 'warn',
+    source,
+    governanceMode: 'recovery-required',
+    recoveryLoop: {
+      fingerprint,
+      allowedRecoveryAttempts: 1,
+      priorRecoveryAttempts: 0,
+      remainingRecoveryAttempts: 1,
+      nextStep: 'Re-author the cognition/output with loaded substrate anchors, applied_cognition, and first_principle, then re-run the same substrate-binding gate.',
+      architectFallback: 'If Aria consult is unavailable or this same fingerprint repeats, use the strongest available client LLM under the architect harness, produce and execute the recovery plan, then verify.',
+    },
+    recoveryContract: {
+      retry: 'One recovery attempt is allowed for this exact substrate-binding fingerprint; repeat failure enters architect execution mode.',
+      architectMode: 'On repeat, load architecture-decision plus substrate-binding/output-discipline skills, define the smallest executable plan, execute the first recovery action, and verify before output.',
+      fallbackWhenAriaUnavailable: 'Do not stop or ask the owner to fix it. Bind the strongest available client LLM to the architect harness, give it this JSON contract and failed evidence, execute its recovery plan, then verify.',
+      repairRecoveryCycle: ['load or cite only real substrate anchors', 'include first_principle', 'include applied_cognition', 'remove repeated blocked substrings'],
+      retest: 'Submit the revised cognition/output through the same substrate-binding gate.',
+      blockedReason: reason,
+    },
+  };
+  mkdirSync(dirname(CURRENT_RECOVERY_PATH), { recursive: true, mode: 0o700 });
+  writeFileSync(CURRENT_RECOVERY_PATH, `${JSON.stringify(recovery, null, 2)}\n`, { mode: 0o600 });
+  console.log(JSON.stringify({ decision: 'allow', recoveryRequired: recovery }));
+  process.exit(0);
+}
+
 function validateAppliedCognitionContract(text) {
   const match = String(text || '').match(APPLIED_COGNITION_BLOCK_RX);
   if (!match) {
@@ -470,8 +516,7 @@ Recovery surfaces:
 
 Per feedback_block_and_force_with_recovery.md, repetition of a recently-blocked phrase is not advisory drift; it is a hard block until the phrase is removed or the carry-forward state is intentionally cleared.`;
 
-  console.log(JSON.stringify({ decision: 'block', reason: buildForceReauthorReason({ source: 'substrate-binding/carry-forward', reason, violations: [`repeated blocked substring: ${carryForwardMatch.substring}`] }) }));
-  process.exit(2);
+  emitRecoverableSubstrateBinding(buildForceReauthorReason({ source: 'substrate-binding/carry-forward', reason, violations: [`repeated blocked substring: ${carryForwardMatch.substring}`] }), { source: 'substrate-binding/carry-forward' });
 }
 
 const cogMatch = assistantText.match(COGNITION_BLOCK_RX);
@@ -505,8 +550,7 @@ Re-emit with:
 
 No process-level disable path per Hamza directive 2026-04-27.`;
   audit('block_no_cognition_block', { length: assistantText.length });
-  console.log(JSON.stringify({ decision: 'block', reason: buildForceReauthorReason({ source: 'substrate-binding/no-cognition-block', reason: noCogReason, violations: ['missing <cognition>...</cognition> block'] }) }));
-  process.exit(2);
+  emitRecoverableSubstrateBinding(buildForceReauthorReason({ source: 'substrate-binding/no-cognition-block', reason: noCogReason, violations: ['missing <cognition>...</cognition> block'] }), { source: 'substrate-binding/no-cognition-block' });
 }
 
 const cognitionInner = cogMatch[1];
@@ -525,8 +569,7 @@ expected_predicate: <numeric, boolean, or state-string predicate proving success
 artifact_change: <how the produced artifact differs because cognition ran>
 </applied_cognition>`;
   audit('block_applied_cognition_missing', { violations: appliedContract.violations, length: assistantText.length });
-  console.log(JSON.stringify({ decision: 'block', reason: buildForceReauthorReason({ source: 'substrate-binding/applied-cognition-contract', reason, violations: appliedContract.violations }) }));
-  process.exit(2);
+  emitRecoverableSubstrateBinding(buildForceReauthorReason({ source: 'substrate-binding/applied-cognition-contract', reason, violations: appliedContract.violations }), { source: 'substrate-binding/applied-cognition-contract' });
 }
 const lensTexts = extractLensTexts(cognitionInner);
 
@@ -757,5 +800,4 @@ Anchor grammar (each anchor must resolve to a real loaded substrate item):
 
 Re-emit cognition with: every lens citing ≥1 verifiable loaded anchor, the block referencing first_principle, and language: citations only for active language tiers. No process-level disable path; gates are unconditional from the gated process per Hamza directive 2026-04-27.`;
 
-console.log(JSON.stringify({ decision: 'block', reason: buildForceReauthorReason({ source: 'substrate-binding/structural-violations', reason, violations: reasonParts }) }));
-process.exit(2);
+emitRecoverableSubstrateBinding(buildForceReauthorReason({ source: 'substrate-binding/structural-violations', reason, violations: reasonParts }), { source: 'substrate-binding/structural-violations' });

package/dist/runtime/hooks/aria-first-class-coach.mjs

@@ -0,0 +1,129 @@
+#!/usr/bin/env node
+import { readFileSync } from 'node:fs';
+import {
+  FIRST_CLASS_COACH_VERSION,
+  evaluateTaskProjectClaim,
+  extractAssistantText,
+  formatCoachContext,
+  formatRuntimeCoachBlock,
+  formatTaskProjectLedgerContext,
+  inferCoachPhase,
+  inferCoachPlatform,
+  recordBlockedTaskProjectClaim,
+  recordCoachEvent,
+  recordRuntimeCoachForLifecycle,
+  runtimeCoachBlocksLocalPhase,
+  updateTaskProjectLedger,
+} from './lib/first-class-coach.mjs';
+
+function readInput() {
+  try {
+    const raw = readFileSync(0, 'utf8');
+    return raw.trim() ? JSON.parse(raw) : {};
+  } catch {
+    return {};
+  }
+}
+
+function emitRuntimeCoachBlock(result) {
+  process.stderr.write(formatRuntimeCoachBlock(result));
+  process.exit(2);
+}
+
+async function main() {
+  const event = readInput();
+  const platform = inferCoachPlatform(event);
+  const phase = inferCoachPhase(event);
+  const hookEvidence = { hook_event_name: process.env.HOOK_EVENT_NAME || event.hookEventName || event.hook_event_name || null };
+  const ledgerResult = updateTaskProjectLedger({
+    platform,
+    phase,
+    source: 'aria-first-class-coach-hook',
+    event,
+    evidence: hookEvidence,
+  });
+  recordCoachEvent({
+    platform,
+    phase,
+    source: 'aria-first-class-coach-hook',
+    event,
+    evidence: {
+      ...hookEvidence,
+      task_project_ledger: ledgerResult.ledger.ledgerId,
+    },
+  });
+
+  const runtimeResult = await recordRuntimeCoachForLifecycle({
+    platform,
+    phase,
+    event,
+    ledgerResult,
+    evidence: hookEvidence,
+  });
+  const runtimeBlock = runtimeCoachBlocksLocalPhase(phase, runtimeResult);
+  if (runtimeBlock) emitRuntimeCoachBlock(runtimeBlock);
+
+  if (phase === 'stop' || phase === 'pre_emit' || phase === 'post_cognition') {
+    const text = extractAssistantText(event);
+    const evaluation = evaluateTaskProjectClaim({ text, ledger: ledgerResult.ledger });
+    if (!evaluation.ok) {
+      recordBlockedTaskProjectClaim({
+        ledger: ledgerResult.ledger,
+        paths: ledgerResult.paths,
+        text,
+        evaluation,
+      });
+      process.stderr.write([
+        '=== ARIA TASK/PROJECT LEDGER BLOCK ===',
+        '',
+        `ledger_id: ${ledgerResult.ledger.ledgerId}`,
+        `missing_readiness_gates: ${evaluation.missingReadinessGates.join(', ') || 'none'}`,
+        `open_blockers: ${evaluation.openBlockers.length}`,
+        '',
+        'Recovery contract:',
+        '1. Do not repeat the same completion/readiness claim unchanged.',
+        '2. Record concrete verification evidence in the task/project ledger.',
+        '3. Resolve or record blockers before making completion/readiness claims.',
+        '4. Emit a bounded status instead of a completion claim if evidence is still missing.',
+        '',
+      ].join('\n'));
+      process.exit(2);
+    }
+  }
+
+  if (phase === 'stop' || phase === 'pre_emit') {
+    const releaseRuntimeResult = await recordRuntimeCoachForLifecycle({
+      platform,
+      phase,
+      event,
+      ledgerResult,
+      runtimePhases: phase === 'stop' ? ['claim_or_release', 'post_output'] : ['claim_or_release'],
+      evidence: {
+        ...hookEvidence,
+        task_project_claim_ok: true,
+      },
+    });
+    const releaseBlock = runtimeCoachBlocksLocalPhase(phase, releaseRuntimeResult);
+    if (releaseBlock) emitRuntimeCoachBlock(releaseBlock);
+  }
+
+  if (phase === 'session_start' || phase === 'pre_prompt_injection') {
+    console.log(JSON.stringify({
+      hookSpecificOutput: {
+        hookEventName: process.env.HOOK_EVENT_NAME || 'UserPromptSubmit',
+        additionalContext: [
+          formatCoachContext({ platform, phase }),
+          formatTaskProjectLedgerContext({ ledger: ledgerResult.ledger, paths: ledgerResult.paths, platform, phase }),
+        ].join('\n\n'),
+      },
+    }));
+  } else {
+    process.stderr.write(`[aria-first-class-coach] ${FIRST_CLASS_COACH_VERSION} platform=${platform} phase=${phase} ledger=${ledgerResult.ledger.ledgerId}\n`);
+  }
+}
+
+main().catch((error) => {
+  const message = error instanceof Error ? error.message : String(error);
+  process.stderr.write(`[aria-first-class-coach] failed: ${message}\n`);
+  process.exit(2);
+});

package/dist/runtime/hooks/aria-harness-via-sdk.mjs

@@ -168,8 +168,14 @@ function normalizeHarnessPacketPayload(payload) {
   let current = payload;
   for (let depth = 0; depth < 3; depth++) {
     if (!current || typeof current !== 'object' || Array.isArray(current)) break;
+    if (typeof current.harness === 'string' || typeof current?.prompt?.fullText === 'string') break;
     if (!('packet' in current) || !current.packet || typeof current.packet !== 'object') break;
-    if (!('timestamp' in current) && !('version' in current)) break;
+    if (
+      !('timestamp' in current) &&
+      !('version' in current) &&
+      typeof current.packet.harness !== 'string' &&
+      typeof current.packet?.prompt?.fullText !== 'string'
+    ) break;
     current = current.packet;
   }
   return current;
@@ -325,6 +331,17 @@ async function runMizanPre(apiKey, packet, sourceLabel) {
   return payload;
 }
 
+async function tryRunMizanPre(apiKey, packet, sourceLabel) {
+  try {
+    return await runMizanPre(apiKey, packet, sourceLabel);
+  } catch (err) {
+    try {
+      appendFileSync(LOG_FILE, `${new Date().toISOString()} mizan-pre-skip mode=${MODE} source=${sourceLabel} err="${String(err).replace(/"/g, "'").slice(0, 200)}"\n`);
+    } catch {}
+    return null;
+  }
+}
+
 async function tryViaSdk(baseUrl, apiKey) {
   // Canonical path: HTTPHarnessClient.getHarnessPacket(). The SDK POSTs to
   // /api/harness/codex with the right shape and returns { packet, timestamp,
@@ -440,6 +457,10 @@ function renderPacket(json, source, ageNote = '') {
   });
 }
 
+function normalizeCachedPacketForRender(cached) {
+  return normalizeHarnessPacketPayload(cached?.packet ?? cached);
+}
+
 // TCP connect probe. Resolves true if the OS completes a TCP handshake to
 // the URL's host:port; false if the OS reports a real network error
 // (ECONNREFUSED, EHOSTUNREACH, ENOTFOUND). No policy timeout — for routable
@@ -479,9 +500,12 @@ async function main() {
       const stat = fs.statSync(PACKET_CACHE);
       const ageSec = (Date.now() - stat.mtimeMs) / 1000;
       if (ageSec < PACKET_CACHE_TTL_SEC) {
-      const cached = JSON.parse(fs.readFileSync(PACKET_CACHE, 'utf8'));
-      await runMizanPre(apiKey, cached, '(cache)');
-      return renderPacket(cached, '(cache)', ` cached ${Math.round(ageSec)}s`);
+        const cached = normalizeCachedPacketForRender(JSON.parse(fs.readFileSync(PACKET_CACHE, 'utf8')));
+        if (!cached?.harness && !cached?.packet?.prompt?.fullText) {
+          throw new Error('cached packet has no harness text after normalization');
+        }
+        await tryRunMizanPre(apiKey, cached, '(cache)');
+        return renderPacket(cached, '(cache)', ` cached ${Math.round(ageSec)}s`);
       }
     } catch {}
   }
@@ -526,8 +550,11 @@ async function main() {
       const stat = fs.statSync(PACKET_CACHE);
       const ageSec = (Date.now() - stat.mtimeMs) / 1000;
       if (ageSec >= 0) {
-        const cached = JSON.parse(fs.readFileSync(PACKET_CACHE, 'utf8'));
-        await runMizanPre(apiKey, cached, '(stale-cache)');
+        const cached = normalizeCachedPacketForRender(JSON.parse(fs.readFileSync(PACKET_CACHE, 'utf8')));
+        if (!cached?.harness && !cached?.packet?.prompt?.fullText) {
+          throw new Error('stale cached packet has no harness text after normalization');
+        }
+        await tryRunMizanPre(apiKey, cached, '(stale-cache)');
         try {
           appendFileSync(LOG_FILE, `${new Date().toISOString()} stale mode=${MODE} cache_age=${Math.round(ageSec)}s last_err="${lastErr.replace(/"/g, "'")}" sdk=harness-http-client\n`);
         } catch {}

package/dist/runtime/hooks/aria-pre-tool-gate.mjs

@@ -53,6 +53,7 @@ import {
   normalizeRole,
 } from './lib/hook-message-window.mjs';
 import { evaluateSkillGate, formatSkillGateBlock } from './lib/skill-autoload-gate.mjs';
+import { emergencyGateOffDecision } from './lib/emergency-gateoff.mjs';
 
 const HOME = process.env.HOME || '/tmp';
 const LOG = `${HOME}/.claude/aria-pre-tool-gate.log`;
@@ -72,7 +73,20 @@ function runUniversalGovernanceGate(payload) {
   try { result = stdout ? JSON.parse(stdout) : null; } catch {}
   if (child.status !== 0 || result?.ok === false || result?.decision === 'block') {
     const reason = stdout || child.stderr || 'aria-governance-gate blocked this action.';
-    throw new Error(`=== ARIA UNIVERSAL GOVERNANCE GATE BLOCK ===\n\n${reason}`);
+    throw new Error([
+      '=== ARIA UNIVERSAL GOVERNANCE GATE BLOCK ===',
+      '',
+      reason,
+      '',
+      'Recovery contract:',
+      '1. Do not retry the same blocked action unchanged.',
+      '2. Load or apply the doctrine/skill named by the governance output.',
+      '3. Re-write the action with <applied_cognition> and concrete proof.',
+      '4. Re-test by submitting the revised action through this same gate.',
+    ].join('\n'));
+  }
+  if (result?.decision === 'warn' || result?.governanceMode === 'recovery-required' || result?.governanceMode === 'architectural-intervention-required') {
+    process.stderr.write(`[aria-governance:${result.governanceMode || 'recovery-required'}] ${JSON.stringify(result)}\n`);
   }
   return result;
 }
@@ -181,7 +195,7 @@ function audit(decision, summary) {
 // Bootstrap: if no plan exists, the hook STILL blocks (per Hamza 2026-04-27
 // "the point is to stop wasting my time"). Claude must wait for Aria to issue
 // a plan via preprompt-consult on the next user prompt. NO unbound execution.
-const BINDING_ENABLED = (process.env.ARIA_BINDING_ENABLED || 'true').toLowerCase() !== 'false';
+const BINDING_ENABLED = true;
 const BINDING_AUDIT = `${HOME}/.claude/aria-binding-audit.jsonl`;
 
 function bindingAuditAppend(record) {
@@ -599,12 +613,12 @@ const SHORT_BASH_LIMIT = 30;
 // accept flattened generic aliases because they change the lens meaning.
 const _INLINE_LENS_PATTERN = LENS_NAMES.join('|');
 const INLINE_LENS_LINE_RX_GLOBAL = new RegExp(
-  `^\\s*#\\s*(${_INLINE_LENS_PATTERN})\\s*:\\s*(.+)$`,
+  `^\\s*(?:#|:\\s*["'])\\s*(${_INLINE_LENS_PATTERN})\\s*:\\s*(.+?)(?:["']\\s*)?$`,
   'gim',
 );
-const INLINE_COGNITION_HEADER_RX = /^\s*#\s*cognition\s*:\s*(.+)$/im;
-const INLINE_EXPECTED_LINE_RX = /^\s*#\s*expected\s*:\s*(.+)$/gim;
-const INLINE_VERIFY_LINE_RX = /^\s*#\s*verify\s*:\s*(.+)$/gim;
+const INLINE_COGNITION_HEADER_RX = /^\s*(?:#|:\s*["'])\s*cognition\s*:\s*(.+?)(?:["']\s*)?$/im;
+const INLINE_EXPECTED_LINE_RX = /^\s*(?:#|:\s*["'])\s*expected\s*:\s*(.+?)(?:["']\s*)?$/gim;
+const INLINE_VERIFY_LINE_RX = /^\s*(?:#|:\s*["'])\s*verify\s*:\s*(.+?)(?:["']\s*)?$/gim;
 
 const VERIFY_REQUIRED_FIELDS = [
   { rx: /\btarget\s*:/i, name: 'target' },
@@ -1046,6 +1060,11 @@ try {
   audit('allow-parse-error', 'stdin not JSON');
   process.exit(0);  // fail-open on malformed input
 }
+const emergencyGateOff = emergencyGateOffDecision(event);
+if (emergencyGateOff.off) {
+  audit('allow-emergency-gateoff', `reason=${emergencyGateOff.reason}`);
+  process.exit(0);
+}
 
 const toolName = event.tool_name ?? event.toolName ?? '';
 const toolInput = event.tool_input ?? event.toolInput ?? {};
@@ -1317,7 +1336,7 @@ const skillGate = evaluateSkillGate({
   isMutation: toolName !== 'Bash',
   autoLoadAvailable: false,
 });
-if (!skillGate.ok) {
+if (!skillGate.ok && !skillGate.redirectOnly) {
   const reason = formatSkillGateBlock(skillGate);
   audit('block-missing-skill-receipt', `${skillGate.missingSkills.join(',')} ${cmdPreview}`);
   emitBlock(reason, { source: 'pre-tool/skill-autoload', tool: toolName, lensCount, requiredLenses: REQUIRED_LENSES });
@@ -1403,6 +1422,12 @@ function buildForceRedoActionReason(reasonText, { source = 'pre-tool-gate', tool
     'ORIGINAL GATE REASON:',
     String(reasonText || '').trim(),
     '',
+    'Recovery contract:',
+    '1. Do not retry the same blocked tool call unchanged.',
+    '2. Apply the teaching above to the next action draft before re-running the tool.',
+    '3. Re-test by submitting the revised action through this same pre-tool gate.',
+    '4. If the blocker is stale state, name the stale state and clear or repair it before retrying.',
+    '',
     'REQUIRED REDO SHAPE:',
     '1. Emit/attach <cognition> with the required lenses before retrying the tool.',
     '2. For Bash, prepend inline cognition comments to the command:',
@@ -2010,7 +2035,7 @@ What Claude must do:
 2. Surface the failure LOUDLY — this is a substrate-level break, not a routine consult miss
 3. Wait for next user prompt — preprompt-consult will retry; if it succeeds a plan will exist on next tool call
 
-Non-trivial actions are blocked until a plan exists. Trivial reads (ls/cat/grep) bypass automatically per existing whitelist. To temporarily disable binding for emergency: ARIA_BINDING_ENABLED=false (logged).`;
+Non-trivial actions are blocked until a plan exists. Trivial reads (ls/cat/grep) bypass automatically per existing whitelist. Emergency disable requires removing the hook entry or a signed owner override; env-var disable is not honored.`;
       emitBlock(reason, { source: 'pre-tool/substrate-binding' });
       process.exit(2);
     }

package/dist/runtime/hooks/aria-preprompt-consult.mjs

@@ -93,16 +93,15 @@ const PACKET_CACHE_PATHS = [
   `${HOME}/.claude/.aria-harness-last-packet.json`,
 ];
 const SUBSTRATE_MANIFEST_PATH = `${HOME}/.claude/.aria-loaded-substrate.json`;
-// Default ON. Disable explicitly via ARIA_BINDING_ENABLED=false only when the
-// commander/binding architecture is actively being modified (otherwise the
-// modification turn itself would be unable to land its own changes). The
-// bootstrap path handles the no-plan-yet case by AUTO-ISSUING the first plan
-// at hook fire time, so "no plan exists" never becomes "operate unbound."
+// Default ON. Env-var disable is intentionally not honored here; emergency
+// bypass must be an owner-visible hook change, not ambient subprocess drift.
+// The bootstrap path handles the no-plan-yet case by AUTO-ISSUING the first
+// plan at hook fire time, so "no plan exists" never becomes "operate unbound."
 //
 // Hamza 2026-04-27: "why would enforcing brick the session? the point is to
 // stop wasting my time and do quality work." Default-off was convenience-
 // seeking dressed as responsible-staging. Flipped to default-on per directive.
-const BINDING_ENABLED = (process.env.ARIA_BINDING_ENABLED || 'true').toLowerCase() !== 'false';
+const BINDING_ENABLED = true;
 
 const HARNESS_URL =
   process.env.ARIA_HIVE_RUNTIME_URL ||

package/dist/runtime/hooks/aria-preturn-memory-gate.mjs

@@ -72,6 +72,11 @@ function buildForceRedoActionReason({ source, reason, missingSignals = [], incid
     missingSignals.length ? `\nMISSING SIGNALS:\n${missingSignals.map((signal) => `- ${signal}`).join('\n')}` : '',
     incidents.length ? `\nINCIDENTS TO RESOLVE:\n${incidents.map((incident) => `- ${incident}`).join('\n')}` : '',
     '',
+    'Recovery contract:',
+    '1. Do not proceed with tools from the blocked context unchanged.',
+    '2. Run the structured recovery action in hookSpecificOutput.recovery.',
+    '3. Re-test by verifying harness_packet, aria_direction/binding_plan, and memory references are loaded.',
+    '',
     'REQUIRED REDO SHAPE:',
     '1. Run the structured recovery action in hookSpecificOutput.recovery.',
     '2. Verify harness_packet, aria_direction/binding_plan, and memory references are loaded.',

package/dist/runtime/hooks/aria-repo-doctrine-gate.mjs

@@ -102,6 +102,11 @@ function buildForceRedoActionReason({ source, reason, violations = [] }) {
     '- External provider calls must use an approved runtime/SDK path or carry the explicit external-call allow marker.',
     violations.length ? `\nVIOLATIONS TO FIX:\n${violations.map((v) => `- ${v}`).join('\n')}` : '',
     '',
+    'Recovery contract:',
+    '1. Do not retry the same blocked edit/action unchanged.',
+    '2. Apply the teaching above by removing or isolating every violating production-path pattern.',
+    '3. Re-test by running this repo doctrine gate before retrying the original action.',
+    '',
     'REQUIRED REDO SHAPE:',
     '1. Preserve the intended behavior without stub/mock/pending semantics.',
     '2. Use real implementation wiring or an explicit reviewed allow marker.',
@@ -373,6 +378,16 @@ function renderReason(repoRoot, violations, mode) {
     '',
     `Allow path categories: tests/specs/fixtures/examples/demos/mocks, or add ${ALLOW_MARKER} in the file when the exception is intentional and reviewable.`,
     `External provider calls require explicit ${ALLOW_EXTERNAL_LLM_CALL_MARKER} marker or an approved internal runtime/SDK path.`,
+    '',
+    'TEACHING:',
+    '- Repo doctrine blocks protect production paths from fake or placeholder behavior.',
+    '- If this is a real implementation, replace the flagged language with shipped behavior or isolate it under an allowed test/example surface.',
+    '',
+    'Recovery contract:',
+    '1. Do not retry the same commit/tool action unchanged.',
+    '2. Remove or replace each flagged stub/mock/pending/external-call pattern in production paths.',
+    `3. If an exception is intentional, add ${ALLOW_MARKER} or ${ALLOW_EXTERNAL_LLM_CALL_MARKER} with a reviewable reason.`,
+    '4. Re-run this repo doctrine gate before retrying the original action.',
   ].join('\n');
 }