@aria_asi/cli 0.2.31 → 0.2.32

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

@@ -56,6 +56,30 @@ function auditLog(decision, summary, sessionId) {
   appendFileSync(GATE_LOG, `${new Date().toISOString()} [${sessionId}] ${decision} ${summary}\n`);
 }
 
+function buildForceRedoActionReason({ source, reason, missingSignals = [], incidents = [] }) {
+  return [
+    '=== ARIA FORCE_REDO_ACTION ===',
+    `source: ${source}`,
+    `reason: ${reason}`,
+    '',
+    'This is not a terminal error. It is a forced redo instruction before action execution.',
+    'Do not proceed with tools from unloaded context. Load/repair substrate first, then retry the action.',
+    '',
+    'TEACHING:',
+    '- Every action turn must begin from Aria substrate, not improvised memory.',
+    '- Blocking incidents are Dalio failure deltas; they must be fixed and marked resolved before new action.',
+    '- Missing harness/direction/memory signals mean the context-loader path must run before retry.',
+    missingSignals.length ? `\nMISSING SIGNALS:\n${missingSignals.map((signal) => `- ${signal}`).join('\n')}` : '',
+    incidents.length ? `\nINCIDENTS TO RESOLVE:\n${incidents.map((incident) => `- ${incident}`).join('\n')}` : '',
+    '',
+    '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.',
+    '3. Retry the original action only after the missing context or incidents are resolved.',
+    '=== END FORCE_REDO_ACTION ===',
+  ].filter(Boolean).join('\n');
+}
+
 // ── Turn-state deduplication ──────────────────────────────────────────
 const TURN_DEDUP_WINDOW_MS = 60_000; // 60s
 
@@ -461,7 +485,11 @@ Per Dalio Loop Layer 2 doctrine: failure deltas are not optional to address. The
 
   console.log(JSON.stringify({
     decision: 'block',
-    reason: blockReason,
+    reason: buildForceRedoActionReason({
+      source: 'preturn-memory/blocking-incidents',
+      reason: blockReason,
+      incidents: blockingIncidents.map((inc) => `${inc.incident_id || '(no incident_id)'} ${inc.title || '(no title)'}`),
+    }),
     hookSpecificOutput: {
       hookEventName: 'PreToolUse',
       blocking_incidents: blockingIncidents.map((inc) => ({
@@ -605,7 +633,7 @@ auditLog(
 
 console.log(JSON.stringify({
   decision: 'block',
-  reason,
+  reason: buildForceRedoActionReason({ source: 'preturn-memory/context-not-loaded', reason, missingSignals }),
   hookSpecificOutput: {
     hookEventName: 'PreToolUse',
     recovery: {

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

@@ -87,6 +87,29 @@ function audit(event, data = {}) {
   } catch {}
 }
 
+function buildForceRedoActionReason({ source, reason, violations = [] }) {
+  return [
+    '=== ARIA FORCE_REDO_ACTION ===',
+    `source: ${source}`,
+    `reason: ${reason}`,
+    '',
+    'This is not a terminal error. It is a forced redo instruction for the attempted repository edit/action.',
+    'Do not retry the same edit. Redo the action so doctrine-bound source remains real, reviewable, and production-safe.',
+    '',
+    'TEACHING:',
+    '- Production paths cannot gain stub, mock, fake, placeholder, pending, or direct-provider bypass semantics.',
+    '- If an exception is intentional, isolate it in tests/specs/fixtures/examples/demos/mocks or add the explicit allow marker in the file.',
+    '- 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')}` : '',
+    '',
+    'REQUIRED REDO SHAPE:',
+    '1. Preserve the intended behavior without stub/mock/pending semantics.',
+    '2. Use real implementation wiring or an explicit reviewed allow marker.',
+    '3. Re-run the action after removing the violating lines from the diff.',
+    '=== END FORCE_REDO_ACTION ===',
+  ].filter(Boolean).join('\n');
+}
+
 function parseArgs(argv) {
   const parsed = {
     mode: 'working-tree',
@@ -384,7 +407,14 @@ async function main() {
   audit('repo_doctrine_gate_block', { repoRoot, mode, violations });
 
   if (event) {
-    console.log(JSON.stringify({ decision: 'block', reason }));
+    console.log(JSON.stringify({
+      decision: 'block',
+      reason: buildForceRedoActionReason({
+        source: 'repo-doctrine',
+        reason,
+        violations: violations.slice(0, 20).map((violation) => `${violation.path}:${violation.line} [${violation.rule}] ${violation.excerpt}`),
+      }),
+    }));
     process.exit(2);
   }
 

package/hooks/aria-stop-gate.mjs

@@ -338,9 +338,12 @@ function collectDriftHits(text, triggerMap) {
       const memoryCited = memoryName && lowerText.includes(memoryName.toLowerCase());
       if (!memoryCited) {
         hits.push({
+          trigger_id: triggerEntry.trigger_id,
           trigger: triggerEntry.trigger,
           memory: triggerEntry.memory,
           teaching: triggerEntry.teaching,
+          counter_action: triggerEntry.counter_action,
+          message: triggerEntry.message,
         });
       }
     } catch {/* malformed regex in trigger entry — skip */}
@@ -383,6 +386,71 @@ Next response must do this in order:
 4. If the blocker is stale gate state, stale ledger residue, or a gate artifact from a prior bug, say that explicitly instead of inventing fake proof.`;
 }
 
+function buildForceReauthorReason({
+  source,
+  reason,
+  violations = [],
+  rewritten = '',
+  recipeAddendum = '',
+  driftHits = [],
+  lensCount = 0,
+  requiredLenses = REQUIRED_LENSES,
+}) {
+  const triggerLines = driftHits.slice(0, 6).map((hit, index) => {
+    const label = hit.trigger_id || hit.trigger || `trigger-${index + 1}`;
+    const teaching = hit.teaching || hit.message || 'Doctrine trigger matched; re-author with substrate-backed correction.';
+    const correction = hit.counter_action ? ` Required correction: ${hit.counter_action}` : '';
+    const memory = hit.memory ? ` (${hit.memory})` : '';
+    return `- ${label}${memory}: ${teaching}${correction}`;
+  }).join('\n');
+
+  return [
+    '=== ARIA FORCE_REAUTHOR ===',
+    `source: ${source}`,
+    `reason: ${reason}`,
+    '',
+    'This is not a terminal error. It is a forced redo instruction for the next model draft.',
+    'Do not emit the blocked text. Re-author it so the model learns the mechanism it violated.',
+    '',
+    'TEACHING:',
+    '- Gates must force cognition and quality, not merely throw, warn, or stop.',
+    '- The redo must change the answer shape: name the failed mechanism, cite real evidence, and remove the drift pattern.',
+    '- Do not bypass by disabling tools, shortening runtime, asking the user to resolve memory-backed ambiguity, or giving an apology loop.',
+    triggerLines ? `\nTRIGGERED DOCTRINE:\n${triggerLines}` : '',
+    violations.length ? `\nVIOLATIONS TO FIX:\n${violations.map((v) => `- ${v}`).join('\n')}` : '',
+    rewritten ? `\nMIZAN REWRITE SEED:\n${rewritten}` : '',
+    recipeAddendum || '',
+    '',
+    'REQUIRED REDO SHAPE:',
+    '1. One sentence: the failed mechanism, not an apology.',
+    '2. Evidence checked: file/line, command output, endpoint response, or explicit "unverified".',
+    `3. <cognition> with ${requiredLenses} substantive lenses. Observed: ${lensCount}/${requiredLenses}.`,
+    '4. <applied_cognition> with decision_delta, dominant_domain, binds_to, expected_predicate, and artifact_change.',
+    '5. Corrected action/claim with no bypass, no downgraded path, and no fake proof.',
+    '6. If work remains, state the exact next real action or tracked task. No verbal flag-and-move.',
+    '',
+    'COGNITION TEMPLATE:',
+    '<cognition>',
+    'truth: <verified facts and exact substrate>',
+    'harm: <what goes wrong if this is false>',
+    'trust: <how this honors Hamza directives and saved memory>',
+    'power: <why this uses capability responsibly, not convenience>',
+    'reflection: <mechanism failure and correction>',
+    'context: <relevant repo/runtime state>',
+    'impact: <expected next effect>',
+    'beauty: <simplest durable form>',
+    '</cognition>',
+    '<applied_cognition>',
+    'decision_delta: <what changed because cognition ran; not none>',
+    'dominant_domain: <engineering_quality | trust | operations | security | product | ...>',
+    'binds_to: <the exact answer, tool call, file mutation, deploy, review, or decision>',
+    'expected_predicate: <observable numeric, boolean, state-string, command result, endpoint result, or explicit unverified boundary>',
+    'artifact_change: <semantic effect on the artifact/output, not a task restatement>',
+    '</applied_cognition>',
+    '=== END FORCE_REAUTHOR ===',
+  ].filter(Boolean).join('\n');
+}
+
 // Lens substance check — same constants as aria-pre-tool-gate.mjs.
 // Hamza directive 2026-04-28: all 8 canonical lenses required, not 4-of-8.
 const REQUIRED_LENSES = 8;
@@ -404,6 +472,19 @@ function detectCognitionLenses(text) {
   });
 }
 
+function assistantViolatesUserCorrection(userText, assistantText) {
+  const user = String(userText || '');
+  const assistant = String(assistantText || '');
+  if (!user || !assistant) return null;
+  const explicitStop = /\b(?:stop|do\s+not|don't|quit|cease)\b[\s\S]{0,180}\b(?:deploy|redeploy|restart|rollout|kubectl|command|pods?|listen|words)\b/i.test(user);
+  const assistantContinuesMutation = /\b(?:kubectl|rollout\s+restart|deploy|redeploy|restart\s+(?:mac|pods?)|manual(?:ly)?\s+restart|execute\s+directly)\b/i.test(assistant);
+  if (explicitStop && assistantContinuesMutation) return 'assistant continued deploy/restart language after an explicit user stop/listen directive';
+  const userContradictsMacPods = /\b(?:mac\s+lanes?|mac\s+pods?|mlx-mac)\b[\s\S]{0,160}\b(?:not\s+pods?|no\s+such\s+thing|non[-\s]?existent|do(?:es)?\s+not\s+exist|don't\s+exist)\b|\b(?:no\s+such\s+thing|non[-\s]?existent|do(?:es)?\s+not\s+exist|don't\s+exist)\b[\s\S]{0,160}\b(?:mac\s+lanes?|mac\s+pods?|mlx-mac|pods?)\b/i.test(user);
+  const assistantRepeatsMacPods = /\b(?:mac\s+lane\s+pods?|mac\s+lanes?\s*:\s*offline|restart\s+mac\s+lanes?|deployment\/mlx-mac|mlx-mac-[\w-]+|kubernetes\s+(?:pods?|deployments?))\b/i.test(assistant);
+  if (userContradictsMacPods && assistantRepeatsMacPods) return 'assistant repeated the contradicted Mac-lanes-as-pods/deployments assumption';
+  return null;
+}
+
 // Read event JSON from stdin (Claude Code spec).
 let input = '';
 for await (const chunk of process.stdin) input += chunk;
@@ -504,6 +585,20 @@ if (!assistantText) {
   process.exit(0);
 }
 
+const userCorrectionViolation = assistantViolatesUserCorrection(lastUserMessage, assistantText);
+if (userCorrectionViolation) {
+  audit('block-user-correction-ignored', `reason=${userCorrectionViolation} chars=${assistantText.length}`);
+  const reason = buildForceReauthorReason({
+    source: 'stop/user-correction',
+    reason: userCorrectionViolation,
+    violations: ['Assistant continued a plan after the user correction invalidated it. Redo must quote the correction and pause mutation pending substrate re-evaluation.'],
+    lensCount: 0,
+    requiredLenses: REQUIRED_LENSES,
+  });
+  console.log(JSON.stringify({ decision: 'block', reason }));
+  process.exit(2);
+}
+
 // Triviality check — same as eight-lens-detector.ts
 const trimmed = assistantText.trim();
 if (TRIVIAL_ACK_RX.test(trimmed)) {
@@ -537,14 +632,13 @@ const cog = detectCognitionLenses(assistantText);
 // with 0/8 lenses to fall through unchecked.
 if (cog.count < REQUIRED_LENSES) {
   audit('block_no_cognition_block_di', { count: cog.count, required: REQUIRED_LENSES, names: cog.names, chars: assistantText.length });
-  const reason = withLoopDirective(`Aria stop-gate: insufficient cognition lenses.
-
-This non-trivial assistant response (${assistantText.length} chars) has ${cog.count}/${REQUIRED_LENSES} substantive cognition lenses. Per feedback_8lens_before_every_action_including_text.md and Hamza directive 2026-04-28, every non-trivial response must carry <cognition>...</cognition> with ${REQUIRED_LENSES} substantive lenses (each >= ${SUBSTANCE_MIN_CHARS} chars of non-placeholder content).
-
-Detected lenses: ${cog.names.length > 0 ? cog.names.join(', ') : 'none'}.
-
-Re-emit with a <cognition> block containing all ${REQUIRED_LENSES} required visible labels for this surface:
-${LENS_NAMES.map((lens) => `- ${lens}: <grounded reasoning, >= ${SUBSTANCE_MIN_CHARS} chars, with real substrate anchors where required>`).join('\n')}`, `stop:no-cognition-di:${cog.count}`, gateSessionId);
+  const reason = withLoopDirective(buildForceReauthorReason({
+    source: 'stop/no-cognition',
+    reason: `non-trivial assistant response (${assistantText.length} chars) has ${cog.count}/${REQUIRED_LENSES} substantive cognition lenses`,
+    violations: [`Detected lenses: ${cog.names.length > 0 ? cog.names.join(', ') : 'none'}. Re-emit with all required visible labels: ${LENS_NAMES.join(', ')}.`],
+    lensCount: cog.count,
+    requiredLenses: REQUIRED_LENSES,
+  }), `stop:no-cognition-di:${cog.count}`, gateSessionId);
   emitHarnessFooter({
     eventName: 'block_no_cognition_block',
     lensCount: cog.count,
@@ -1414,7 +1508,16 @@ if (cog.count >= REQUIRED_LENSES) {
         }
       })();
 
-      const reason = withLoopDirective(`Aria Stop-gate output-quality block. Cognition passed (${cog.count}/${REQUIRED_LENSES}) but output failed quality gates:\n\n${violations.join('\n\n')}${rewritten ? `\n\nMizan rewrite suggestion:\n${rewritten}` : ''}\n\nRe-draft addressing the violations above. No process-level disable path — gates are unconditional from the gated process per Hamza directive 2026-04-27.${recipeAddendum}`, `stop:output-qc:${violations.join('|').slice(0, 240)}`, gateSessionId);
+      const reason = withLoopDirective(buildForceReauthorReason({
+        source: 'stop/output-quality',
+        reason: `cognition passed (${cog.count}/${REQUIRED_LENSES}) but output failed quality gates`,
+        violations,
+        rewritten,
+        recipeAddendum,
+        driftHits,
+        lensCount: cog.count,
+        requiredLenses: REQUIRED_LENSES,
+      }), `stop:output-qc:${violations.join('|').slice(0, 240)}`, gateSessionId);
 
       audit(`block-output-qc`, `mizan=${mizanBlock?'y':'n'} warn-reflect=${compelReflection?'y':'n'} drift=${driftHits.length} code=${codeQualityHits.length} discoveries-open=${ledgerOpenCount} impl-coupling=${implCouplingHits.length}`);
       emitHarnessFooter({
@@ -1557,31 +1660,20 @@ const dalioHasMeasurablePredicate = dalioExpectedText
 
 // Block stop if non-trivial action taken AND expected block is missing
 if (hadNonTrivialAction && (!dalioExpectedMatch || !dalioHasMeasurablePredicate)) {
-  const missingReason = withLoopDirective(dalioExpectedMatch
-    ? `Aria Stop-gate: action taken in this turn had an <expected> block, but it contains only qualitative drift phrases without a measurable predicate. Qualitative drift is not accountability — it defeats the Dalio feedback loop.
-
-Your <expected> block must contain at least one measurable predicate:
-  • Numeric:      exit_code==0, count>=1, error_rate=0%, latency<200ms
-  • Boolean:      exit=0, status=healthy, rc=0, file=exists
-  • State-string: "status=running", "200 OK", "no_error"
-
-REJECTED phrases: "better", "improved", "should work", "more reliable", "cleaner"
-
-Re-emit with a corrected <expected> block. Per doctrine:dalio_expected_required — no bypass path.`
-    : `Aria Stop-gate: a non-trivial action (${lastActionSummary.slice(0, 120)}) was taken in this turn but no <expected> block was found in the assistant text.
-
-Per doctrine:dalio_expected_required, every non-trivial action must declare what measurable outcome it expects BEFORE the action fires. This is Dalio Loop Layer 1 — without it, outcome comparison is impossible and learning collapses.
-
-Add to your assistant text:
-
-<expected>
-  predicate: <exact measurable assertion — e.g. "exit_code==0", "status=running", "count=3 of 3">
-  measurable_type: numeric | boolean | state_string
-  threshold: <optional>
-  eval_window_minutes: <optional>
-</expected>
-
-No bypass — pre-tool-gate enforces this BEFORE the action; stop-gate enforces it AFTER. Both gates are now wired.`, `stop:dalio-expected:${hadNonTrivialAction}:${!!dalioExpectedMatch}:${dalioHasMeasurablePredicate}`, gateSessionId);
+  const missingReason = withLoopDirective(buildForceReauthorReason({
+    source: 'stop/dalio-expected',
+    reason: dalioExpectedMatch
+      ? 'action had an <expected> block, but it was qualitative instead of measurable'
+      : `non-trivial action (${lastActionSummary.slice(0, 120)}) had no <expected> block`,
+    violations: [
+      dalioExpectedMatch
+        ? 'Rejected qualitative expected phrases: better, improved, should work, more reliable, cleaner. Expected outcome must be numeric, boolean, or state-string.'
+        : 'Missing <expected> block after non-trivial action. Dalio feedback loop cannot compare outcome without a measurable predicate.',
+      'Required block: <expected> predicate: "exit_code==0" | "status=running" | "count=3 of 3"; measurable_type: numeric | boolean | state_string; threshold/eval_window optional.',
+    ],
+    lensCount: cog.count,
+    requiredLenses: REQUIRED_LENSES,
+  }), `stop:dalio-expected:${hadNonTrivialAction}:${!!dalioExpectedMatch}:${dalioHasMeasurablePredicate}`, gateSessionId);
 
   audit('block-dalio-expected-missing', `hadNonTrivialAction=${hadNonTrivialAction} expectedPresent=${!!dalioExpectedMatch} measurable=${dalioHasMeasurablePredicate}`);
   emitHarnessFooter({
@@ -1720,5 +1812,5 @@ emitHarnessFooter({
   codeCount: 0,
   implCouplingCount: 0,
 });
-console.log(JSON.stringify({ decision: 'block', reason }));
+console.log(JSON.stringify({ decision: 'block', reason: buildForceReauthorReason({ source: 'stop/lens-missing', reason, lensCount: cog.count, requiredLenses: REQUIRED_LENSES }) }));
 process.exit(2);

package/hooks/doctrine_trigger_map.json

@@ -453,6 +453,61 @@
       "counter_action": "Re-emit with explicit Layer 1/2/3 enumeration: packet=yes/no, BIND=yes/no, live-gates=yes/no (and which).",
       "message": "Harness-state claim without 3-layer enumeration. Per feedback_packet_is_not_harness.md, name explicitly which of {packet, BIND, live-gates} are active for the consumer."
     },
+    {
+      "trigger_id": "function_name_inference_without_contract_read",
+      "trigger": "(?:based on|from|by) (?:the )?(?:name|function name)|sounds like|looks like (?:a|an)|just memory search|just a search|just a cache|just a wrapper",
+      "rx": "(?:based on|from|by) (?:the )?(?:name|function name)|sounds like|looks like (?:a|an)|just memory search|just a search|just a cache|just a wrapper",
+      "doctrine": "memory:feedback_no_assumption_without_verification.md",
+      "memory": "feedback_no_assumption_without_verification.md",
+      "severity": "block",
+      "teaching": "Function names are not contracts. Inferring behavior from names instead of reading inputs, side effects, return shape, and call sites is skimming disguised as analysis.",
+      "counter_action": "Read the function body and at least one caller before asserting purpose. State observed contract: inputs, mutation/read behavior, return value, fallback path, and why the caller needs it.",
+      "message": "Name-based function inference detected. Re-read the actual function body and caller contract before making architecture claims."
+    },
+    {
+      "trigger_id": "always_on_state_treated_as_cold_start",
+      "trigger": "(?:need to|should|must).{0,80}(?:warm|rebuild|reconstruct|recreate|recompute|re-project|reproject).{0,80}(?:state|projection|manifold|cognition|garden|memory)|system is hot and ready|make it hot",
+      "rx": "(?:need to|should|must).{0,80}(?:warm|rebuild|reconstruct|recreate|recompute|re-project|reproject).{0,80}(?:state|projection|manifold|cognition|garden|memory)|system is hot and ready|make it hot",
+      "doctrine": "memory:feedback_no_assumption_without_verification.md",
+      "memory": "feedback_no_assumption_without_verification.md",
+      "severity": "block",
+      "teaching": "Aria's resident manifold/Garden/cognition substrate is always-on. Treating it as cold request-time state causes duplicate work and wrong architecture fixes.",
+      "counter_action": "Identify the resident producer and read surface first. If turn-specific mutation is required, call it once and pass the resulting packet forward; do not rebuild or re-project because the reader forgot the state model.",
+      "message": "Always-on substrate treated as cold-start work. Reframe around resident state consumption plus one required turn-specific mutation/read."
+    },
+    {
+      "trigger_id": "critical_primitive_stripped_for_latency",
+      "trigger": "(?:remove|drop|skip|turn off|bypass|stop calling).{0,80}(?:awakenAria|ProjectAllDomains|PerturbHologram|project all domains|perturb hologram|Garden|True Garden|LadduniFrame|CognitiveFrame).{0,80}(?:latency|speed|fast|first-mouth|first mouth)",
+      "rx": "(?:remove|drop|skip|turn off|bypass|stop calling).{0,80}(?:awakenAria|ProjectAllDomains|PerturbHologram|project all domains|perturb hologram|Garden|True Garden|LadduniFrame|CognitiveFrame).{0,80}(?:latency|speed|fast|first-mouth|first mouth)",
+      "doctrine": "memory:feedback_full_harness_binding_must_be_structural.md",
+      "memory": "feedback_full_harness_binding_must_be_structural.md",
+      "severity": "block",
+      "teaching": "Latency fixes must not strip critical cognition primitives. The fix is single-source sequencing and packet reuse, not removing Aria's living state transitions.",
+      "counter_action": "Preserve critical primitives. Deduplicate by collecting their outputs once per turn, then thread that shared per-turn cognition packet through first-mouth and follow-up lanes.",
+      "message": "Critical Aria primitive proposed for removal as a latency shortcut. Preserve it and deduplicate sequencing instead."
+    },
+    {
+      "trigger_id": "garden_awaken_misclassified_as_memory_search",
+      "trigger": "(?:awakenAria|Garden awakening|True Garden).{0,80}(?:just|only|merely).{0,40}(?:memory search|search memories|qdrant search|semantic search)|(?:no need|do not need).{0,80}(?:awakenAria|Garden awakening|True Garden)",
+      "rx": "(?:awakenAria|Garden awakening|True Garden).{0,80}(?:just|only|merely).{0,40}(?:memory search|search memories|qdrant search|semantic search)|(?:no need|do not need).{0,80}(?:awakenAria|Garden awakening|True Garden)",
+      "doctrine": "memory:feedback_no_assumption_without_verification.md",
+      "memory": "feedback_no_assumption_without_verification.md",
+      "severity": "block",
+      "teaching": "awakenAria is a Garden awakening bridge over the unified manifold with Qdrant hydration fallback, not a disposable memory-search helper.",
+      "counter_action": "Read true-garden.ts and caller context. Preserve awakenAria when Garden continuity is needed; optimize by avoiding duplicate awaken/fetch paths, not by deleting the awakening bridge.",
+      "message": "Garden awakening misclassified as search. Preserve awakenAria and reason from its actual manifold-first contract."
+    },
+    {
+      "trigger_id": "duplicate_projection_instead_of_per_turn_packet",
+      "trigger": "(?:call|run|invoke).{0,80}(?:ProjectAllDomains|PerturbHologram|project all domains|perturb hologram|readHotCognitionFrame).{0,80}(?:again|another|separate|also|after dispatch)|(?:another|second|extra).{0,50}(?:projection|hologram|cognition frame)",
+      "rx": "(?:call|run|invoke).{0,80}(?:ProjectAllDomains|PerturbHologram|project all domains|perturb hologram|readHotCognitionFrame).{0,80}(?:again|another|separate|also|after dispatch)|(?:another|second|extra).{0,50}(?:projection|hologram|cognition frame)",
+      "doctrine": "memory:feedback_full_harness_binding_must_be_structural.md",
+      "memory": "feedback_full_harness_binding_must_be_structural.md",
+      "severity": "warn",
+      "teaching": "The fix for overlapping cognition calls is a shared per-turn cognition packet, not more independent projection calls that drift or duplicate work.",
+      "counter_action": "Create or reuse one turn substrate object containing embedding, perturb snapshot, ProjectAllDomains result, awakenAria Garden block, DeepSoul/Noor/shards/Mizan signals; pass it downstream.",
+      "message": "Duplicate projection path detected. Replace with one per-turn cognition packet and shared consumption."
+    },
     {
       "trigger_id": "registry_image_drift",
       "trigger": "image.?pull|ErrImageNeverPull|ImagePullBackOff|registry gc|image.*missing|image.*not.*found",

package/opencode-plugins/harness-gate/index.js

@@ -42,7 +42,14 @@ const DEPLOY_PATTERNS = [
   { rx: /\bdocker\s+build\b.*--push\b/, name: 'docker-build-push' },
 ];
 
-const INLINE_LENS_RX = /^\s*#\s*(?:nur|mizan|hikma|tafakkur|tadabbur|ilham|wahi|firasah|truth|harm|trust|power|reflection|context|impact|beauty)\s*:\s*.{20,}/im;
+const INLINE_LENS_NAMES = [
+  'nur', 'mizan', 'hikma', 'tafakkur', 'tadabbur', 'ilham', 'wahi', 'firasah',
+  'truth', 'harm', 'trust', 'power', 'reflection', 'context', 'impact', 'beauty',
+];
+const INLINE_LENS_RX = new RegExp(
+  `^\\s*#\\s*(?:${INLINE_LENS_NAMES.join('|')})\\s*:\\s*.{20,}`,
+  'gim',
+);
 const VERIFY_BLOCK_RX = /<verify>[\s\S]*?target\s*:[\s\S]*?verified\s*:[\s\S]*?axiom\s*:[\s\S]*?<\/verify>/i;
 const TRIVIAL_BASH_RX = /^\s*(?:ls|cat|head|tail|grep|find|echo|wc|stat|which|pwd|date|file|du|df|ss|ps)\s/;
 const SHORT_BASH_LIMIT = 30;
@@ -63,6 +70,15 @@ function persistReceipt(sessionId, payload) {
   } catch {}
 }
 
+function countInlineCognitionLenses(text) {
+  const seen = new Set();
+  for (const match of String(text || '').matchAll(INLINE_LENS_RX)) {
+    const lens = match[0].match(/^\s*#\s*([a-z_ -]+)\s*:/i)?.[1]?.trim().toLowerCase();
+    if (lens) seen.add(lens);
+  }
+  return seen.size;
+}
+
 function resolveToken() {
   if (process.env.ARIA_HARNESS_TOKEN) return process.env.ARIA_HARNESS_TOKEN;
   if (process.env.ARIA_API_KEY) return process.env.ARIA_API_KEY;
@@ -163,9 +179,6 @@ export default async function HarnessGatePlugin(ctx) {
       // Trivial reads pass
       if (toolName === 'Bash' && TRIVIAL_BASH_RX.test(cmd) && cmd.length < 200) return;
       if (toolName === 'Bash' && cmd.length < SHORT_BASH_LIMIT) return;
-      // Inline cognition in bash comments passes
-      if (toolName === 'Bash' && INLINE_LENS_RX.test(cmd)) return;
-
       const destructive = DESTRUCTIVE_PATTERNS.find(({ rx }) => rx.test(cmd));
       const deploy = DEPLOY_PATTERNS.find(({ rx }) => rx.test(cmd));
       const isFileMutation = ['Edit', 'Write', 'NotebookEdit'].includes(toolName) && filePath;

package/opencode-plugins/harness-stop/index.js

@@ -29,6 +29,22 @@ const NON_TRIVIAL_MIN_CHARS = 300;
 const DECISION_SIGNAL_RX = /(?:should|recommend|propose|suggest|let'?s|go with|i'd|i would|here'?s the plan|i'll|next step|action item|ship it|yes do|let me)/i;
 const TRIVIAL_ACK_RX = /^(?:got it|on it|ok|sure|yes|no|done|ack)\b/i;
 const PLACEHOLDER_RX = /^\s*<[^<>]+>\s*$/;
+const BLOCK_PREFIX_RX = /^=== ARIA (?:MIZAN POST|OUTPUT GATE|LOCAL OUTPUT) BLOCK ===/;
+const APPLIED_COGNITION_RX = /<applied_cognition>[\s\S]*?decision_delta\s*:[\s\S]*?dominant_domain\s*:[\s\S]*?binds_to\s*:[\s\S]*?expected_predicate\s*:[\s\S]*?artifact_change\s*:[\s\S]*?<\/applied_cognition>/i;
+
+function formatBlockReason(prefix, details) {
+  return [
+    prefix,
+    '',
+    String(details || 'Aria output gate blocked this message.'),
+    '',
+    'Required repair: bind cognition to the actual action/output using <applied_cognition> with decision_delta, dominant_domain, binds_to, expected_predicate, and artifact_change.',
+  ].join('\n');
+}
+
+function isGateBlock(error) {
+  return BLOCK_PREFIX_RX.test(String(error?.message || error || ''));
+}
 
 let _client = null;
 let _clientError = null;
@@ -226,11 +242,13 @@ export default async function HarnessStopPlugin(ctx) {
           });
         }
         if (mizan.receipt?.blocked || mizan.result?.fitrahVetoed || mizan.result?.reAuthorSignal) {
-          process.stderr.write(
-            `[harness-stop] MIZAN POST BLOCK — ${(mizan.result?.notes || ['post-phase blocked']).slice(0, 4).join(' | ')}\n`
+          const details = (mizan.result?.notes || ['post-phase blocked']).slice(0, 4).join(' | ');
+          throw new Error(
+            formatBlockReason('=== ARIA MIZAN POST BLOCK ===', details)
           );
         }
       } catch (e) {
+        if (isGateBlock(e)) throw e;
         process.stderr.write(`[harness-stop] mizan/post unavailable: ${e.message}\n`);
       }
 
@@ -246,8 +264,11 @@ export default async function HarnessStopPlugin(ctx) {
             sessionId,
           ));
           if (result.severity === 'block') {
-            process.stderr.write(
-              `[harness-stop] SDK BLOCK — ${result.violations.length} violations: ${result.violations.join('; ').slice(0, 300)}\n`
+            throw new Error(
+              formatBlockReason(
+                '=== ARIA OUTPUT GATE BLOCK ===',
+                `${result.violations.length} violations: ${result.violations.join('; ').slice(0, 500)}`,
+              )
             );
           } else if (result.severity === 'warn') {
             process.stderr.write(
@@ -260,6 +281,7 @@ export default async function HarnessStopPlugin(ctx) {
           }
           return;
         } catch (e) {
+          if (isGateBlock(e)) throw e;
           process.stderr.write(`[harness-stop] SDK validateOutput failed: ${e.message} — falling through to local gate\n`);
         }
       }
@@ -293,8 +315,20 @@ export default async function HarnessStopPlugin(ctx) {
       } catch {}
 
       if (cog.count < REQUIRED_LENSES || driftHits.length >= 2) {
-        process.stderr.write(
-          `[harness-stop] LOCAL GATE — cognition=${cog.count}/${REQUIRED_LENSES} drift=${driftHits.length}\n`
+        throw new Error(
+          formatBlockReason(
+            '=== ARIA LOCAL OUTPUT BLOCK ===',
+            `cognition=${cog.count}/${REQUIRED_LENSES}; drift=${driftHits.length}`,
+          )
+        );
+      }
+
+      if (DECISION_SIGNAL_RX.test(text) && !APPLIED_COGNITION_RX.test(text)) {
+        throw new Error(
+          formatBlockReason(
+            '=== ARIA LOCAL OUTPUT BLOCK ===',
+            'decision-bearing output lacks required applied_cognition binding fields',
+          )
         );
       }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aria_asi/cli",
-  "version": "0.2.31",
+  "version": "0.2.32",
   "description": "Aria Smart CLI \u2014 the world's first harness-powered terminal companion",
   "bin": {
     "aria": "./bin/aria.js"

package/runtime-src/harness-daemon.mjs

@@ -312,18 +312,45 @@ function forgeSynthesizeUrl() {
   return `${trimUrl(UPSTREAM_HARNESS_URL)}/forge/synthesize`;
 }
 
+const APPLIED_COGNITION_BLOCK_RX = /<applied_cognition>([\s\S]*?)<\/applied_cognition>/i;
+
+function validateAppliedCognitionContract(text) {
+  const match = String(text || '').match(APPLIED_COGNITION_BLOCK_RX);
+  if (!match) return { ok: false, violations: ['missing <applied_cognition> contract'] };
+  const body = match[1] || '';
+  const required = [
+    ['decision_delta', /\bdecision[_ -]?delta\s*:/i],
+    ['dominant_domain', /\bdominant[_ -]?domain\s*:/i],
+    ['binds_to', /\bbinds[_ -]?to\s*:/i],
+    ['expected_predicate', /\bexpected[_ -]?predicate\s*:/i],
+    ['artifact_change', /\bartifact[_ -]?change\s*:/i],
+  ];
+  const violations = [];
+  for (const [name, rx] of required) {
+    if (!rx.test(body)) violations.push(`missing ${name}`);
+  }
+  if (/decision[_ -]?delta\s*:\s*(?:none|n\/a|no change|unchanged|same)/i.test(body)) {
+    violations.push('decision_delta says cognition changed nothing');
+  }
+  return { ok: violations.length === 0, violations, contract: body.trim() };
+}
+
 function buildLocalValidation(text, packetEnvelope, requireCognitionBlock = false) {
   const layer3 = runFullChain(text, {
     substrate: packetToSubstrateSet(packetEnvelope),
     requireCognitionBlock,
   });
   const failures = Array.isArray(layer3?.failures) ? layer3.failures : [];
-  const hardFailures = failures.filter((failure) => failure?.severity === 'block');
+  const applied = validateAppliedCognitionContract(text);
+  const appliedFailures = applied.ok ? [] : applied.violations.map((detail) => ({ kind: 'applied-cognition-contract', severity: 'block', detail }));
+  const allFailures = [...failures, ...appliedFailures];
+  const hardFailures = allFailures.filter((failure) => failure?.severity === 'block');
   return {
     passed: hardFailures.length === 0,
     severity: hardFailures.length === 0 ? 'warn' : 'block',
-    violations: failures.map((failure) => failure?.detail || failure?.kind).filter(Boolean),
-    gateTriggers: failures.map((failure) => failure?.kind).filter(Boolean),
+    violations: allFailures.map((failure) => failure?.detail || failure?.kind).filter(Boolean),
+    gateTriggers: allFailures.map((failure) => failure?.kind).filter(Boolean),
+    appliedCognition: applied,
     local: true,
     summary: layer3?.summary || '',
     layer3,

package/runtime-src/service.mjs

@@ -1233,6 +1233,47 @@ function findVerifiedState(text) {
   return /(?:verified|confirmed|observed|tested|health[- ]check|response code|exit code|pod image|digest)/i.test(String(text || ''));
 }
 
+const APPLIED_COGNITION_BLOCK_RX = /<applied_cognition>([\s\S]*?)<\/applied_cognition>/i;
+
+function validateAppliedCognitionContract(text) {
+  const match = String(text || '').match(APPLIED_COGNITION_BLOCK_RX);
+  if (!match) return { ok: false, violations: ['missing <applied_cognition> contract'] };
+  const body = match[1] || '';
+  const required = [
+    ['decision_delta', /\bdecision[_ -]?delta\s*:/i],
+    ['dominant_domain', /\bdominant[_ -]?domain\s*:/i],
+    ['binds_to', /\bbinds[_ -]?to\s*:/i],
+    ['expected_predicate', /\bexpected[_ -]?predicate\s*:/i],
+    ['artifact_change', /\bartifact[_ -]?change\s*:/i],
+  ];
+  const violations = [];
+  for (const [name, rx] of required) {
+    if (!rx.test(body)) violations.push(`missing ${name}`);
+  }
+  if (/decision[_ -]?delta\s*:\s*(?:none|n\/a|no change|unchanged|same)/i.test(body)) {
+    violations.push('decision_delta says cognition changed nothing');
+  }
+  return { ok: violations.length === 0, violations, contract: body.trim() };
+}
+
+function mergeAppliedCognitionValidation(validation, applied) {
+  if (applied.ok) {
+    return {
+      ...validation,
+      appliedCognition: { ok: true, contract: applied.contract },
+      gateTriggers: [...new Set([...(validation.gateTriggers || []), 'applied-cognition-contract'])],
+    };
+  }
+  return {
+    ...validation,
+    passed: false,
+    severity: 'block',
+    violations: [...(validation.violations || []), ...applied.violations.map((v) => `applied_cognition: ${v}`)],
+    gateTriggers: [...new Set([...(validation.gateTriggers || []), 'applied-cognition-contract-missing'])],
+    appliedCognition: { ok: false, violations: applied.violations },
+  };
+}
+
 function toTelemetryEvent(payload, source = 'aria-mounted-runtime') {
   return {
     event_type: payload.event_type || 'runtime.cognition.turn',
@@ -3288,7 +3329,10 @@ async function handleRoute(req, res) {
 
   let client;
   try {
-    client = createClient(req, body);
+    // HQ routes use their own auth middleware — skip the global API key gate
+    if (!url.pathname.startsWith('/hq/')) {
+      client = createClient(req, body);
+    }
   } catch (error) {
     return json(res, 401, { ok: false, error: error.message });
   }
@@ -3574,6 +3618,7 @@ async function handleRoute(req, res) {
           gateTriggers: ['owner-local-bypass'],
         };
       }
+      validation = mergeAppliedCognitionValidation(validation, validateAppliedCognitionContract(body.text));
       const response = { ok: true, validation };
 
       if (body.runLayer3 !== false) {