@aria_asi/cli 0.2.31 → 0.2.33

package/dist/runtime/codex-bridge.mjs

@@ -1,10 +1,12 @@
 #!/usr/bin/env node
 
 import { appendFileSync, existsSync, mkdirSync, readFileSync } from 'node:fs';
+import { createHash, randomUUID } from 'node:crypto';
 import { homedir } from 'node:os';
 import { delimiter, dirname, resolve } from 'node:path';
 import { spawn, spawnSync } from 'node:child_process';
 import { createRequire } from 'node:module';
+import { evaluateSkillGate, formatSkillGateBlock } from '../../../ops/claude-hooks/lib/skill-autoload-gate.mjs';
 
 const require = createRequire(import.meta.url);
 const { WebSocketServer, WebSocket } = require('ws');
@@ -75,6 +77,24 @@ function sleep(ms) {
   return new Promise((resolvePromise) => setTimeout(resolvePromise, ms));
 }
 
+function stableEvidenceString(value) {
+  if (typeof value === 'string') return value;
+  try { return JSON.stringify(value); } catch { return String(value); }
+}
+
+function makeEvidenceRef(kind, value, metadata = {}) {
+  const raw = stableEvidenceString(value);
+  const sha256 = createHash('sha256').update(raw).digest('hex');
+  return {
+    evidenceId: `ev_${sha256.slice(0, 16)}`,
+    kind,
+    at: new Date().toISOString(),
+    sha256,
+    preview: raw.slice(0, 500),
+    metadata,
+  };
+}
+
 function readRuntimeToken() {
   const envToken = process.env.ARIA_HARNESS_TOKEN || process.env.ARIA_API_KEY || process.env.OPENAI_API_KEY || process.env.ARIA_MASTER_TOKEN;
   if (envToken) return envToken;
@@ -123,9 +143,10 @@ function ensureTurnState(threadId, turnId) {
       userText: '',
       preReceiptId: null,
       agentText: '',
-      bufferedAgentNotifications: [],
-      firstAgentItemId: null,
-    };
+        bufferedAgentNotifications: [],
+        firstAgentItemId: null,
+        traceId: `trace_${randomUUID()}`,
+      };
     turnState.set(key, state);
   }
   return state;
@@ -186,6 +207,16 @@ async function validateTurnText(threadId, turnId) {
   if (!text) {
     return { ok: false, reason: 'No assistant text exists for this turn yet. Codex must emit readable cognition before action.' };
   }
+  const skillGate = evaluateSkillGate({
+    sessionId: `codex:${threadId}:${turnId}`,
+    surface: 'codex-bridge-output',
+    text: [state.userText, text].join('\n'),
+    isOutputCloseout: true,
+    autoLoadAvailable: false,
+  });
+  if (!skillGate.ok) {
+    return { ok: false, reason: formatSkillGateBlock(skillGate), result: { skillGate } };
+  }
   const result = await postRuntime('/validate-output', {
     text,
     sessionId: `codex:${threadId}:${turnId}`,
@@ -198,6 +229,7 @@ async function validateTurnText(threadId, turnId) {
       stage: 'codex-turn',
       actor: 'codex-bridge',
       system: 'codex-bridge',
+      traceId: state.traceId,
     },
   });
   const pass = result?.pass === true && result?.validation?.passed !== false;
@@ -210,11 +242,29 @@ async function validateTurnText(threadId, turnId) {
       };
 }
 
-async function checkActionAgainstRuntime(action, target, threadId, turnId) {
+async function checkActionAgainstRuntime(action, target, threadId, turnId, metadata = {}) {
+  const state = ensureTurnState(threadId, turnId);
+  const skillGate = evaluateSkillGate({
+    sessionId: `codex:${threadId}:${turnId}`,
+    surface: 'codex-bridge-action',
+    text: target,
+    action: target,
+    toolName: action,
+    isDeploy: action === 'deploy',
+    isMutation: action === 'write',
+    autoLoadAvailable: false,
+  });
+  if (!skillGate.ok) {
+    return { ok: false, reason: formatSkillGateBlock(skillGate), result: { skillGate } };
+  }
   const result = await postRuntime('/check-action', {
     action,
     target,
     sessionId: `codex:${threadId}:${turnId}`,
+    actor: 'codex',
+    roleProfile: process.env.CODEX_ARIA_ROLE_PROFILE || process.env.ARIA_ROLE_PROFILE || null,
+    verifyText: state.agentText || '',
+    ...metadata,
   });
   if (result?.allowed === false) {
     return {
@@ -244,6 +294,8 @@ async function recordMizanPre(threadId, turnId) {
         surface: 'codex-bridge',
         platform: 'codex',
         userText: state.userText,
+        traceId: state.traceId,
+        evidenceRefs: [makeEvidenceRef('user_input', state.userText, { threadId, turnId, traceId: state.traceId })],
       },
     });
     state.preReceiptId = result?.receipt?.receiptId || null;
@@ -262,6 +314,8 @@ async function recordMizanPost(threadId, turnId, pass, summary) {
       evidence: {
         validated_output: pass,
         bridge: 'codex',
+        trace_id: state.traceId,
+        output_ref: makeEvidenceRef('assistant_output', state.agentText || summary, { threadId, turnId, traceId: state.traceId }),
       },
       context: {
         sessionId: `codex:${threadId}:${turnId}`,
@@ -269,6 +323,7 @@ async function recordMizanPost(threadId, turnId, pass, summary) {
         platform: 'codex',
         userText: state.userText,
         summary,
+        traceId: state.traceId,
       },
     });
   } catch (error) {
@@ -285,6 +340,8 @@ async function recordMizanPost(threadId, turnId, pass, summary) {
       details: {
         threadId,
         turnId,
+        traceId: state.traceId,
+        outputRef: makeEvidenceRef('assistant_output', state.agentText || summary, { threadId, turnId, traceId: state.traceId }),
       },
     });
   } catch (error) {
@@ -336,7 +393,9 @@ async function handleApprovalRequest(upstream, downstream, message) {
       cwd: params.cwd || null,
       commandActions: params.commandActions || params.parsedCmd || null,
     }).slice(0, 1500);
-    const actionCheck = await checkActionAgainstRuntime(action, target, threadId, turnId);
+    const actionCheck = await checkActionAgainstRuntime(action, target, threadId, turnId, {
+      requireVerify: action === 'delete' || action === 'deploy',
+    });
     if (!actionCheck.ok) {
       const reason = `Aria runtime denied ${action}: ${actionCheck.reason}`;
       upstream.send(JSON.stringify(makeGuardianWarning(threadId, reason)));
@@ -360,8 +419,9 @@ async function handleApprovalRequest(upstream, downstream, message) {
   }
 
   if (method === 'item/fileChange/requestApproval' || method === 'applyPatchApproval') {
-    const target = params.grantRoot || params.reason || params.itemId || 'file-change';
-    const actionCheck = await checkActionAgainstRuntime('write', String(target), threadId, turnId);
+    const target = params.grantRoot || params.path || params.filePath || params.reason || params.itemId || 'file-change';
+    const files = [params.path, params.filePath, params.grantRoot].filter((value) => typeof value === 'string' && value.trim());
+    const actionCheck = await checkActionAgainstRuntime('write', String(target), threadId, turnId, { files });
     if (!actionCheck.ok) {
       const reason = `Aria runtime denied file change: ${actionCheck.reason}`;
       upstream.send(JSON.stringify(makeGuardianWarning(threadId, reason)));
@@ -390,7 +450,10 @@ async function handleApprovalRequest(upstream, downstream, message) {
       permissions: params.permissions || null,
       reason: params.reason || null,
     }).slice(0, 1500);
-    const actionCheck = await checkActionAgainstRuntime('write', target, threadId, turnId);
+    const files = Array.isArray(params.permissions?.fileSystem?.entries)
+      ? params.permissions.fileSystem.entries.filter((value) => typeof value === 'string' && value.trim())
+      : [];
+    const actionCheck = await checkActionAgainstRuntime('write', target, threadId, turnId, { files });
     if (!actionCheck.ok) {
       const reason = `Aria runtime denied permissions request: ${actionCheck.reason}`;
       upstream.send(JSON.stringify(makeGuardianWarning(threadId, reason)));

package/dist/runtime/discipline/CLAUDE.md

@@ -164,6 +164,22 @@ Every non-trivial assistant turn must satisfy all three.
 
 **REJECTED (qualitative drift):** `better`, `improved`, `should work`, `more reliable`, `cleaner`, `nicer`. These are unmeasurable.
 
+### `<applied_cognition>` — required with every non-trivial cognition block
+
+The cognition block is not accepted as proof by itself. It must bind to a concrete action or output claim and state what changed because cognition ran.
+
+```
+<applied_cognition>
+  decision_delta: <what changed because cognition ran; not "none">
+  dominant_domain: <engineering_quality | trust | operations | security | product | ...>
+  binds_to: <the next tool/action/output claim this cognition constrains>
+  expected_predicate: <numeric, boolean, or state-string predicate proving success>
+  artifact_change: <how the produced artifact/action/output differs because cognition ran>
+</applied_cognition>
+```
+
+**Rejected:** missing fields, `decision_delta: none`, or a contract that does not bind to the next action/output. This is the structural enforcement for apply-lenses-don't-perform.
+
 ### `<verify>` — required for deploy commands
 
 A deploy is anything matching `deploy-service.sh|kubectl apply -f|kubectl set image|docker push|trivial deploy|fast path deploy`. Without a verify block, the pre-tool-gate hard-blocks.

package/dist/runtime/discipline/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/dist/runtime/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/dist/runtime/harness-daemon.mjs

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 
 import { createServer } from 'node:http';
+import { createHash } from 'node:crypto';
 import { createRequire } from 'node:module';
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
@@ -35,6 +36,7 @@ const LOCAL_FIRST_PRINCIPLE = 'Truth over deception. No harm. Sacred trust. Powe
 
 let cachedPacketEnvelope = loadCachedPacketEnvelope();
 let refreshInFlight = null;
+let refreshInFlightKey = '';
 let lastRefreshError = null;
 let lastRefreshStartedAt = null;
 let lastRefreshCompletedAt = cachedPacketEnvelope?.timestamp || null;
@@ -99,6 +101,46 @@ function sanitizePacketEnvelope(raw) {
   };
 }
 
+function stableIdentityValue(value) {
+  return String(value || '').trim().toLowerCase();
+}
+
+function requestCacheKey(body = {}, apiKey = '') {
+  const identity = {
+    stage: stableIdentityValue(body.stage || body.packetRequest?.stage),
+    actor: stableIdentityValue(body.actor || body.packetRequest?.actor),
+    system: stableIdentityValue(body.system || body.packetRequest?.system),
+    platform: stableIdentityValue(body.platform || body.packetRequest?.platform),
+    roleProfile: stableIdentityValue(body.roleProfile || body.role_profile || body.packetRequest?.roleProfile || body.packetRequest?.role_profile),
+    token: apiKey ? createHash('sha256').update(apiKey).digest('hex').slice(0, 16) : '',
+  };
+  return createHash('sha256').update(JSON.stringify(identity)).digest('hex');
+}
+
+function extractPacketField(packet, field) {
+  if (!packet || typeof packet !== 'object') return '';
+  const direct = packet[field];
+  if (typeof direct === 'string' && direct.trim()) return stableIdentityValue(direct);
+  for (const source of [packet.adapter, packet.harness]) {
+    if (typeof source !== 'string') continue;
+    const match = source.match(new RegExp(`(?:^|\\n)\\s*${field}\\s*=\\s*([^\\n\\s]+)`, 'i'));
+    if (match?.[1]) return stableIdentityValue(match[1]);
+  }
+  return '';
+}
+
+function cachedPacketMatchesRequest(envelope, body = {}) {
+  const packet = envelope?.packet;
+  if (!packet || typeof packet !== 'object') return false;
+  for (const field of ['stage', 'actor', 'system']) {
+    const expected = stableIdentityValue(body[field] || body.packetRequest?.[field]);
+    if (!expected) continue;
+    const actual = extractPacketField(packet, field);
+    if (actual && actual !== expected) return false;
+  }
+  return true;
+}
+
 function loadCachedPacketEnvelope() {
   const candidates = [LOCAL_PACKET_CACHE_PATH, ...LEGACY_PACKET_CACHE_CANDIDATES];
   for (const candidate of candidates) {
@@ -220,10 +262,15 @@ async function fetchJsonWithRetry(url, init, attempts = 3) {
 }
 
 async function refreshPacket(body = {}, apiKey = '') {
-  if (refreshInFlight) return refreshInFlight;
+  const cacheKey = requestCacheKey(body, apiKey);
+  if (refreshInFlight && refreshInFlightKey === cacheKey) return refreshInFlight;
+  if (refreshInFlight) {
+    await refreshInFlight.catch(() => {});
+  }
   if (isLoopedUpstream(UPSTREAM_HARNESS_URL)) {
     throw new Error(`upstream harness URL loops back to local daemon: ${UPSTREAM_HARNESS_URL}`);
   }
+  refreshInFlightKey = cacheKey;
   lastRefreshStartedAt = new Date().toISOString();
   lastRefreshError = null;
   refreshInFlight = (async () => {
@@ -258,6 +305,7 @@ async function refreshPacket(body = {}, apiKey = '') {
     throw error;
   } finally {
     refreshInFlight = null;
+    refreshInFlightKey = '';
   }
 }
 
@@ -268,7 +316,7 @@ function queuePacketRefresh(body, apiKey) {
 }
 
 async function resolvePacketEnvelope(packetRequest = {}, apiKey = '', message = '') {
-  if (cachedPacketEnvelope) {
+  if (cachedPacketEnvelope && cachedPacketMatchesRequest(cachedPacketEnvelope, packetRequest)) {
     queuePacketRefresh(packetRequest, apiKey);
     return cachedPacketEnvelope;
   }
@@ -312,18 +360,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/dist/runtime/manifest.json

@@ -1,5 +1,5 @@
 {
-  "bundledAt": "2026-04-30T13:56:07.672Z",
+  "bundledAt": "2026-05-02T19:32:12.150Z",
   "sdkFiles": 6,
   "runtimeTemplate": "/home/hamzaibrahim1/rei-ai-brain/packages/aria-connector/runtime-src",
   "gateRuntimeSource": "/home/hamzaibrahim1/rei-ai-brain/packages/aria-gate-runtime/dist",

package/dist/runtime/sdk/BUNDLED.json

@@ -1,5 +1,5 @@
 {
-  "bundledAt": "2026-04-30T13:56:07.664Z",
+  "bundledAt": "2026-05-02T19:32:12.146Z",
   "sdkSource": "/home/hamzaibrahim1/rei-ai-brain/harness/packages/harness-http-client/dist",
   "files": 6
 }

package/dist/runtime/sdk/index.d.ts

@@ -103,12 +103,21 @@ export interface HarnessBindingContext {
     includeAegisLearnings?: boolean;
     extraBody?: Record<string, unknown>;
 }
+export interface HarnessEvidenceRef {
+    evidenceId: string;
+    kind: string;
+    at: string;
+    sha256: string;
+    preview: string;
+    metadata?: Record<string, unknown>;
+}
 export interface BoundHarnessPromptResult {
     prompt: string;
     packet: HarnessPacket;
     harnessText: string;
     bindingBody: Record<string, unknown>;
 }
+export declare function createHarnessEvidenceRef(kind: string, value: unknown, metadata?: Record<string, unknown>): HarnessEvidenceRef;
 export interface RecordDiscoveryArgs {
     /** Finding text (min 4 chars). */
     text: string;
@@ -150,6 +159,11 @@ export interface ValidationResult {
     severity: 'pass' | 'warn' | 'block';
     rewritten?: string;
     gateTriggers: string[];
+    appliedCognition?: {
+        ok: boolean;
+        contract?: string;
+        violations?: string[];
+    };
 }
 export interface ActionCheck {
     allowed: boolean;

package/dist/runtime/sdk/index.js

@@ -2,7 +2,7 @@ import { readFile } from 'node:fs/promises';
 import { existsSync, readFileSync, statSync } from 'node:fs';
 import { homedir as _homedir } from 'node:os';
 import { resolve, isAbsolute } from 'node:path';
-import { randomUUID } from 'node:crypto';
+import { createHash, randomUUID } from 'node:crypto';
 const CLOUD_RUN_SOUL_URL = 'https://arias-soul-6zp3gtk2ca-uc.a.run.app';
 const PUBLIC_HARNESS_URL = 'https://harness.ariasos.com';
 const LOCAL_HARNESS_CANDIDATES = [
@@ -29,6 +29,28 @@ function normalizeHarnessPacketPayload(payload) {
         ? current
         : {};
 }
+function stableEvidenceString(value) {
+    if (typeof value === 'string')
+        return value;
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return String(value);
+    }
+}
+export function createHarnessEvidenceRef(kind, value, metadata) {
+    const raw = stableEvidenceString(value);
+    const sha256 = createHash('sha256').update(raw).digest('hex');
+    return {
+        evidenceId: `ev_${sha256.slice(0, 16)}`,
+        kind,
+        at: new Date().toISOString(),
+        sha256,
+        preview: raw.slice(0, 500),
+        ...(metadata && Object.keys(metadata).length > 0 ? { metadata } : {}),
+    };
+}
 // ── 8-Lens Cognition Block ─────────────────────────────────────────────────
 const EIGHT_LENS_BLOCK = `[ARIA SHELL PROTOCOL — You are a controlled surface]