@aria_asi/cli 0.2.30 → 0.2.32

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/hooks/lib/canonical-lenses.mjs

@@ -1,14 +1,15 @@
 export const LENS_NAMES_OLDER = ['nur', 'mizan', 'hikma', 'tafakkur', 'tadabbur', 'ilham', 'wahi', 'firasah'];
 export const LENS_NAMES_NEWER = ['zahir', 'batin', 'sabab', 'hikmah', 'aqibah', 'ilham', 'meta', 'fitrah'];
-export const LENS_NAMES_GENERIC = ['truth', 'harm', 'trust', 'power', 'reflection', 'context', 'impact', 'beauty'];
 
 export const PRIMARY_OWNER_LENS_NAMES = LENS_NAMES_OLDER;
-export const PRIMARY_CLIENT_LENS_NAMES = LENS_NAMES_GENERIC;
+// Readability must not rewrite the lens semantics. Client surfaces may need
+// friendlier prose inside each lens, but the visible lens labels themselves
+// stay canonical so the meaning is preserved.
+export const PRIMARY_CLIENT_LENS_NAMES = LENS_NAMES_OLDER;
 
 export const ALL_LENS_NAMES = [...new Set([
   ...LENS_NAMES_OLDER,
   ...LENS_NAMES_NEWER,
-  ...LENS_NAMES_GENERIC,
 ])];
 
 export function lensNamesForTier(isOwner) {
@@ -19,7 +20,7 @@ export function canonicalLensCorrectionText() {
   return [
     `Owner canonical lenses: ${LENS_NAMES_OLDER.join(', ')}.`,
     `Owner mapped counterparts that must remain represented in phase reasoning and receipts: ${LENS_NAMES_NEWER.join(', ')}.`,
-    `Readable client-safe alternatives: ${LENS_NAMES_GENERIC.join(', ')}.`,
+    `Canonical lens labels are preserved on every surface. Readability comes from the explanatory prose inside each lens, never from renaming the lens itself.`,
   ].join(' ');
 }
 
@@ -57,7 +58,7 @@ export function detectCognitionLenses(text, {
   }
 
   const matchedSet =
-    [LENS_NAMES_OLDER, LENS_NAMES_NEWER, LENS_NAMES_GENERIC]
+    [LENS_NAMES_OLDER, LENS_NAMES_NEWER]
       .find((candidateSet) => candidateSet.every((name) => names.includes(name))) || null;
 
   return { count: names.length, names, matchedSet };

package/hooks/lib/gate-loop-state.mjs

@@ -0,0 +1,50 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+
+const MAX_RECORDS = 300;
+
+export function registerGateBlock({
+  gate,
+  sessionId,
+  signature,
+  statePath,
+  threshold = 2,
+  windowMs = 10 * 60 * 1000,
+}) {
+  const now = Date.now();
+  let rows = [];
+  try {
+    if (existsSync(statePath)) {
+      const raw = JSON.parse(readFileSync(statePath, 'utf8'));
+      if (Array.isArray(raw)) rows = raw;
+    }
+  } catch {}
+
+  const freshRows = rows.filter((row) =>
+    row &&
+    typeof row.ts === 'number' &&
+    typeof row.sessionId === 'string' &&
+    typeof row.gate === 'string' &&
+    typeof row.signature === 'string' &&
+    (now - row.ts) <= windowMs,
+  );
+
+  const priorMatches = freshRows.filter((row) =>
+    row.sessionId === sessionId &&
+    row.gate === gate &&
+    row.signature === signature,
+  );
+
+  freshRows.push({ ts: now, sessionId, gate, signature });
+
+  try {
+    mkdirSync(dirname(statePath), { recursive: true });
+    writeFileSync(statePath, JSON.stringify(freshRows.slice(-MAX_RECORDS), null, 2) + '\n');
+  } catch {}
+
+  return {
+    loopDetected: priorMatches.length >= threshold,
+    priorCount: priorMatches.length,
+    totalCount: priorMatches.length + 1,
+  };
+}

package/hooks/lib/hook-message-window.mjs

@@ -0,0 +1,121 @@
+function withGlobalRegex(regex) {
+  if (!(regex instanceof RegExp)) return null;
+  const flags = regex.flags.includes('g') ? regex.flags : `${regex.flags}g`;
+  return new RegExp(regex.source, flags);
+}
+
+export function normalizeRole(entry) {
+  if (entry?.message?.role) return entry.message.role;
+  if (entry?.role) return entry.role;
+  if (entry?.type === 'assistant' || entry?.type === 'user') return entry.type;
+  return null;
+}
+
+export function normalizeContent(entry) {
+  return entry?.message?.content ?? entry?.content ?? [];
+}
+
+export function extractTextFromContent(content) {
+  if (Array.isArray(content)) {
+    return content
+      .filter((block) => block && block.type === 'text')
+      .map((block) => (typeof block.text === 'string' ? block.text : ''))
+      .filter(Boolean)
+      .join('\n');
+  }
+  return typeof content === 'string' ? content : '';
+}
+
+export function isToolResultOnlyContent(content) {
+  return (
+    Array.isArray(content) &&
+    content.length > 0 &&
+    content.every((block) => block && block.type === 'tool_result')
+  );
+}
+
+export function isMostlySystemReminder(text, systemReminderRx, threshold = 0.6) {
+  if (!text || !(systemReminderRx instanceof RegExp)) return false;
+  const reminderRx = withGlobalRegex(systemReminderRx);
+  if (!reminderRx) return false;
+  const matches = text.match(reminderRx) || [];
+  if (matches.length === 0) return false;
+  const reminderChars = matches.reduce((sum, match) => sum + match.length, 0);
+  return reminderChars / Math.max(1, text.length) >= threshold;
+}
+
+export function collectRecentAssistantTextsFromMessages(messages, {
+  compactSummaryRx = null,
+  hardLookbackCap = 50,
+  systemReminderRx = null,
+  systemReminderThreshold = 0.6,
+  userBoundariesToCross = 1,
+} = {}) {
+  if (!Array.isArray(messages) || messages.length === 0) return [];
+  const recentAssistantTexts = [];
+  let scanned = 0;
+  let userBoundariesCrossed = 0;
+
+  for (let i = messages.length - 1; i >= 0 && scanned < hardLookbackCap; i--) {
+    const entry = messages[i];
+    const role = normalizeRole(entry);
+    const content = normalizeContent(entry);
+    if (role === 'user') {
+      if (isToolResultOnlyContent(content)) continue;
+      const textContent = extractTextFromContent(content);
+      if (isMostlySystemReminder(textContent, systemReminderRx, systemReminderThreshold)) {
+        continue;
+      }
+      userBoundariesCrossed++;
+      if (userBoundariesCrossed > userBoundariesToCross) break;
+      continue;
+    }
+    if (role !== 'assistant') continue;
+    scanned++;
+    const text = extractTextFromContent(content);
+    if (!text) continue;
+    if (compactSummaryRx instanceof RegExp && compactSummaryRx.test(text) && text.length > 4000) {
+      continue;
+    }
+    recentAssistantTexts.push(text);
+  }
+
+  return recentAssistantTexts.reverse();
+}
+
+export function collectTurnWindowFromMessages(messages, {
+  systemReminderRx = null,
+  systemReminderThreshold = 0.6,
+} = {}) {
+  if (!Array.isArray(messages) || messages.length === 0) {
+    return { assistantText: '', lastUserMessage: '' };
+  }
+
+  const textChunks = [];
+  let lastUserMessage = '';
+
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const entry = messages[i];
+    const role = normalizeRole(entry);
+    const content = normalizeContent(entry);
+
+    if (role === 'user') {
+      if (isToolResultOnlyContent(content)) continue;
+      const textContent = extractTextFromContent(content);
+      if (isMostlySystemReminder(textContent, systemReminderRx, systemReminderThreshold)) {
+        continue;
+      }
+      lastUserMessage = textContent || lastUserMessage;
+      break;
+    }
+
+    if (role !== 'assistant') continue;
+    const text = extractTextFromContent(content);
+    if (text) textChunks.push(text);
+  }
+
+  return {
+    assistantText: textChunks.reverse().join('\n\n'),
+    lastUserMessage,
+  };
+}

package/hooks/test-tier-lens-labeling.mjs

@@ -1,13 +1,12 @@
 #!/usr/bin/env node
-// Smoke test: Phase 11 #59 — tier-aware lens labeling
+// Smoke test: Phase 11 #59 — canonical lens labeling
 //
 // Verifies that aria-pre-tool-gate.mjs and aria-stop-gate.mjs:
 //   1. Show canonical Arabic lens names (nur, mizan, etc.) when the harness
 //      packet has isHamza/hamza=true (OWNER tier).
-//   2. Show neutral generic labels (perception, balance, etc.) when the
-//      harness packet is client-surface (CLIENT tier).
+//   2. Preserve those same canonical labels on client-surface execution too.
 //   3. Gate enforcement (block on insufficient cognition) fires in both
-//      tiers — label swap does not change gate substance.
+//      tiers without renaming the lenses.
 //
 // Usage: node hooks/test-tier-lens-labeling.mjs
 // Exit:  0 = all assertions passed, 1 = failure
@@ -24,9 +23,8 @@ const HOME = process.env.HOME || '/tmp';
 const CLAUDE_DIR = `${HOME}/.claude`;
 const PACKET_PATH = `${CLAUDE_DIR}/.aria-harness-last-packet.json`;
 
-// ── Canonical vs generic label sets ────────────────────────────────────────
+// ── Canonical label set ────────────────────────────────────────────────────
 const CANONICAL = ['nur', 'mizan', 'hikma', 'tafakkur', 'tadabbur', 'ilham', 'wahi', 'firasah'];
-const GENERIC   = ['perception', 'balance', 'wisdom', 'reflection', 'foresight', 'insight', 'revelation', 'discernment'];
 
 // ── Assertion helpers ───────────────────────────────────────────────────────
 let passed = 0;
@@ -225,21 +223,17 @@ console.log('Test 1: aria-pre-tool-gate — OWNER tier shows canonical lens name
     blockReason.slice(0, 400),
   );
 
-  // Must NOT mention generic labels — no IP exposure for owner
-  // (owner should only see canonical; absence of generic is nice-to-verify
-  // but not a hard requirement since some generic words may appear in prose)
-  // Instead check the first lens label is canonical not generic:
+  // The first visible lens label must be canonical.
   const firstCanonicalIdx = blockReason.indexOf(`${CANONICAL[0]}:`);
-  const firstGenericIdx = blockReason.indexOf(`${GENERIC[0]}:`);
   assert(
-    'T1: first lens label is canonical (nur:), not generic (perception:)',
-    firstCanonicalIdx >= 0 && (firstGenericIdx < 0 || firstCanonicalIdx < firstGenericIdx),
-    `firstCanonicalIdx=${firstCanonicalIdx} firstGenericIdx=${firstGenericIdx}`,
+    'T1: first lens label is canonical (nur:)',
+    firstCanonicalIdx >= 0,
+    `firstCanonicalIdx=${firstCanonicalIdx}`,
   );
 }
 
-// ── Test 2: pre-tool-gate, CLIENT tier → generic labels in block reason ──
-console.log('\nTest 2: aria-pre-tool-gate — CLIENT tier shows generic lens labels');
+// ── Test 2: pre-tool-gate, CLIENT tier → canonical labels in block reason ──
+console.log('\nTest 2: aria-pre-tool-gate — CLIENT tier keeps canonical lens labels');
 {
   writeClientPacket();
   writeEmptyTranscript(tmpTranscript);
@@ -259,32 +253,15 @@ console.log('\nTest 2: aria-pre-tool-gate — CLIENT tier shows generic lens lab
     blockReason = result.stdout || '';
   }
 
-  // Must mention at least one generic label
-  const hasGeneric = GENERIC.some((name) => blockReason.includes(`${name}:`));
+  const hasCanonical = CANONICAL.some((name) => blockReason.includes(`${name}:`));
   assert(
-    'T2: block reason mentions generic label (e.g. perception:)',
-    hasGeneric,
+    'T2: block reason mentions canonical label (e.g. nur:)',
+    hasCanonical,
     blockReason.slice(0, 400),
   );
-
-  // Must NOT expose canonical Arabic names
-  const exposesCanonical = CANONICAL.some((name) =>
-    blockReason.includes(`${name}:`),
-  );
-  assert(
-    'T2: block reason does NOT expose canonical Arabic lens names',
-    !exposesCanonical,
-    `canonical leak: ${CANONICAL.filter((n) => blockReason.includes(`${n}:`)).join(', ')} in: ${blockReason.slice(0, 300)}`,
-  );
-
-  // Check doctrine memory filename is neutralized (no feedback_no_flag_without_fix.md for client)
-  const noDocFileLeak = !blockReason.includes('feedback_no_flag_without_fix.md');
-  // (This specific file only appears in discovery-unresolved path; just verify
-  // that the block reason itself also neutralizes EIGHT_LENS_DOCTRINE references if any)
-  // For this test we just assert the generic label set is present.
   assert(
-    'T2: first generic label (perception:) appears in block reason',
-    blockReason.includes(`${GENERIC[0]}:`),
+    'T2: first visible lens label is canonical (nur:)',
+    blockReason.includes(`${CANONICAL[0]}:`),
     blockReason.slice(0, 400),
   );
 }
@@ -318,8 +295,8 @@ console.log('\nTest 3: aria-stop-gate — OWNER tier shows canonical lens names'
   );
 }
 
-// ── Test 4: stop-gate, CLIENT tier → generic labels, no canonical leak ──
-console.log('\nTest 4: aria-stop-gate — CLIENT tier shows generic labels, no canonical leak');
+// ── Test 4: stop-gate, CLIENT tier → canonical labels ──────────────────────
+console.log('\nTest 4: aria-stop-gate — CLIENT tier keeps canonical lens labels');
 {
   writeClientPacket();
   writeNoCognitionStopTranscript(tmpTranscriptStop);
@@ -339,23 +316,16 @@ console.log('\nTest 4: aria-stop-gate — CLIENT tier shows generic labels, no c
     blockReason = result.stdout || '';
   }
 
-  const hasGeneric = GENERIC.some((name) => blockReason.includes(`${name}:`));
+  const hasCanonical = CANONICAL.some((name) => blockReason.includes(`${name}:`));
   assert(
-    'T4: stop-gate block reason mentions generic label',
-    hasGeneric,
+    'T4: stop-gate block reason mentions canonical label',
+    hasCanonical,
     blockReason.slice(0, 400),
   );
-
-  const exposesCanonical = CANONICAL.some((name) => blockReason.includes(`${name}:`));
-  assert(
-    'T4: stop-gate block reason does NOT expose canonical lens names',
-    !exposesCanonical,
-    `canonical leak: ${CANONICAL.filter((n) => blockReason.includes(`${n}:`)).join(', ')}`,
-  );
 }
 
-// ── Test 5: packet missing → defaults to CLIENT tier (fail-safe) ──────────
-console.log('\nTest 5: missing packet cache → defaults to CLIENT tier (fail-safe)');
+// ── Test 5: packet missing → defaults to canonical labels (fail-safe) ─────
+console.log('\nTest 5: missing packet cache → defaults to canonical labels');
 {
   // Remove the packet cache
   try { unlinkSync(PACKET_PATH); } catch {}
@@ -376,13 +346,11 @@ console.log('\nTest 5: missing packet cache → defaults to CLIENT tier (fail-sa
     blockReason = result.stdout || '';
   }
 
-  // With no packet, should default to generic (client-safe fail direction)
-  const hasGeneric = GENERIC.some((name) => blockReason.includes(`${name}:`));
-  const exposesCanonical = CANONICAL.some((name) => blockReason.includes(`${name}:`));
+  const hasCanonical = CANONICAL.some((name) => blockReason.includes(`${name}:`));
   assert(
-    'T5: defaults to generic labels when packet is absent',
-    hasGeneric && !exposesCanonical,
-    `generic=${hasGeneric} canonicalLeak=${exposesCanonical} reason=${blockReason.slice(0, 300)}`,
+    'T5: defaults to canonical labels when packet is absent',
+    hasCanonical,
+    `canonical=${hasCanonical} reason=${blockReason.slice(0, 300)}`,
   );
 }
 

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

@@ -2,7 +2,7 @@
  * Aria Harness Gate — pre-tool cognition enforcement for OpenCode.
  * Routes through HTTPHarnessClient SDK for substrate-backed validation.
  */
-import { existsSync, readFileSync } from 'node:fs';
+import { existsSync, readFileSync, mkdirSync, writeFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 
@@ -15,6 +15,7 @@ const SDK_CANDIDATES = [
 const OWNER_TOKEN_PATH = join(HOME, '.aria', 'owner-token');
 const LICENSE_PATH = join(HOME, '.aria', 'license.json');
 const RUNTIME_URL = (process.env.ARIA_RUNTIME_URL || 'http://127.0.0.1:4319').replace(/\/+$/, '');
+const RECEIPT_DIR = join(HOME, '.opencode', 'aria-mizan-receipts');
 
 const DESTRUCTIVE_PATTERNS = [
   { rx: /(?:^|[;&|]\s*|\$\(\s*|`\s*)sudo\s+\S/, name: 'sudo' },
@@ -41,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;
@@ -51,6 +59,26 @@ let _clientError = null;
 let _lastMizanReceipt = null;
 let _lastActionSummary = '';
 
+function receiptPath(sessionId) {
+  return join(RECEIPT_DIR, `${String(sessionId || 'opencode').replace(/[^a-zA-Z0-9_-]/g, '_')}.json`);
+}
+
+function persistReceipt(sessionId, payload) {
+  try {
+    mkdirSync(RECEIPT_DIR, { recursive: true, mode: 0o755 });
+    writeFileSync(receiptPath(sessionId), JSON.stringify(payload, null, 2) + '\n');
+  } 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;
@@ -151,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;
@@ -182,6 +207,16 @@ export default async function HarnessGatePlugin(ctx) {
           },
         });
         _lastMizanReceipt = pre.receipt || null;
+        if (_lastMizanReceipt) {
+          persistReceipt(sessionId, {
+            updatedAt: new Date().toISOString(),
+            sessionId,
+            receipt: _lastMizanReceipt,
+            preResult: pre.result || null,
+            preContract: pre.contract || null,
+            preSummary: pre.summary || null,
+          });
+        }
         _lastActionSummary = cmdPreview;
         if (pre.receipt?.blocked || pre.result?.fitrahVetoed || pre.result?.reAuthorSignal) {
           throw new Error(