@aria_asi/cli 0.2.30 → 0.2.32

package/hooks/aria-preprompt-consult.mjs

@@ -109,7 +109,27 @@ const HARNESS_URL =
   process.env.ARIA_HARNESS_BASE_URL ||
   process.env.ARIA_HARNESS_URL ||
   'https://harness.ariasos.com';
-const HARNESS_TOKEN = process.env.ARIA_HARNESS_TOKEN || '30b18f0a302b03ae862de8a75021238d23e47464fd5d8f6a9324240933745587';
+function resolveHarnessToken() {
+  if (process.env.ARIA_HARNESS_TOKEN) return process.env.ARIA_HARNESS_TOKEN;
+  if (process.env.ARIA_API_KEY) return process.env.ARIA_API_KEY;
+  if (process.env.ARIA_MASTER_TOKEN) return process.env.ARIA_MASTER_TOKEN;
+  try {
+    if (existsSync(OWNER_TOKEN_PATH)) {
+      const token = readFileSync(OWNER_TOKEN_PATH, 'utf8').trim();
+      if (token) return token;
+    }
+  } catch {}
+  try {
+    const licensePath = `${HOME}/.aria/license.json`;
+    if (existsSync(licensePath)) {
+      const license = JSON.parse(readFileSync(licensePath, 'utf8'));
+      if (license.harnessToken) return String(license.harnessToken).trim();
+      if (license.token) return String(license.token).trim();
+    }
+  } catch {}
+  return '';
+}
+const HARNESS_TOKEN = resolveHarnessToken();
 const MIN_PROMPT_CHARS = 40;        // skip auto-consult on trivial prompts
 const MAX_DIRECTION_CHARS = 4000;   // cap injected chunk size
 
@@ -248,6 +268,8 @@ Respond with EXACTLY this JSON shape:
       "successCriterion": "<observable signal of completion>",
       "abortCriterion": "<observable signal of failure>",
       "doctrineRefs": ["<memory_filename.md>", ...],
+      "cognitionUse": "<how Aria cognition should change the executor's tool/input/output shape for this phase>",
+      "evidenceRequired": ["<observable proof the executor must collect before reporting complete>"],
       "allowedActions": ["read", "edit:<path-pattern>", "kubectl_get", "consult", "bash_safe", "..."],
       "forbiddenActions": ["kubectl_apply", "edit:<path-pattern>", "..."]
     }
@@ -259,7 +281,9 @@ Respond with EXACTLY this JSON shape:
   }
 }
 
-Apply your 8 lenses + substrate. Phases are ordered + small (one logical step each). Doctrine refs cite memory files in /home/hamzaibrahim1/.claude/projects/-home-hamzaibrahim1/memory/. Be specific in allowedActions / forbiddenActions — Claude can ONLY do what's allowed for the current phase.` : `Pre-prompt direction request from Claude orchestrator.
+Apply your 8 lenses + substrate. Phases are ordered + small (one logical step each). Doctrine refs cite memory files in /home/hamzaibrahim1/.claude/projects/-home-hamzaibrahim1/memory/. Be specific in allowedActions / forbiddenActions — Claude can ONLY do what's allowed for the current phase.
+
+Every phase must include cognitionUse and evidenceRequired. cognitionUse tells Claude how Aria's cognition should improve the actual tool input, edit shape, review scope, or final output. evidenceRequired tells Claude what observation must be collected before reporting the phase complete.` : `Pre-prompt direction request from Claude orchestrator.
 
 The user just submitted this prompt:
 
@@ -280,6 +304,8 @@ thinking from training reflex. Be concrete:
      (NOT a reflexive "want me to" deferral).
   4. Mizan check: any risk patterns in this prompt — over-scope creep,
      over-replacement temptation, tier-substitution temptation, etc.
+  5. How should Aria cognition improve Claude's actual input/output shape —
+     what should be more specific, safer, more evidence-bound, or differently scoped?
 
 Keep direction under 1500 chars. This is the pre-load context for Claude's
 turn — not the final response. Claude will still emit cognition + action;

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
 
@@ -105,6 +129,37 @@ function readAnyJsonArtifact(filePath) {
   };
 }
 
+function unwrapHarnessPacketEnvelope(value) {
+  let current = value;
+  for (let depth = 0; depth < 3; depth++) {
+    if (!current || typeof current !== 'object' || Array.isArray(current)) break;
+    const nested = current.packet;
+    if (!nested || typeof nested !== 'object' || Array.isArray(nested)) break;
+    if (typeof current.timestamp !== 'string' && typeof current.version !== 'string') break;
+    current = nested;
+  }
+  return current && typeof current === 'object' && !Array.isArray(current) ? current : {};
+}
+
+function extractHarnessPromptText(packetArtifact) {
+  const packet = unwrapHarnessPacketEnvelope(packetArtifact);
+  const directHarness = typeof packet.harness === 'string' ? packet.harness : '';
+  if (directHarness.trim()) return directHarness;
+
+  const promptFullText = typeof packet?.prompt?.fullText === 'string' ? packet.prompt.fullText : '';
+  if (promptFullText.trim()) return promptFullText;
+
+  const promptPreview = typeof packet?.prompt?.preview === 'string' ? packet.prompt.preview : '';
+  if (promptPreview.trim()) return promptPreview;
+
+  const doctrine = Array.isArray(packet.doctrine) ? packet.doctrine.filter((x) => typeof x === 'string').join('\n') : '';
+  const memory = Array.isArray(packet.memory) ? packet.memory.filter((x) => typeof x === 'string').join('\n') : '';
+  const runtimeMode = typeof packet.runtimeOfflineBundle?.source === 'string'
+    ? `runtime_offline_bundle_source=${packet.runtimeOfflineBundle.source}`
+    : '';
+  return [doctrine, memory, runtimeMode].filter(Boolean).join('\n');
+}
+
 function detectArtifactSignals(sessionId) {
   let harnessArtifact = null;
   for (const packetPath of PACKET_CACHE_PATHS) {
@@ -160,36 +215,34 @@ function detectArtifactSignals(sessionId) {
     staleSubstrateArtifact = null;
   }
 
-  const harnessText = String(
-    harnessArtifact?.data?.harness ??
-    harnessArtifact?.data?.packet?.prompt?.fullText ??
-    '',
-  );
+  const harnessText = extractHarnessPromptText(harnessArtifact?.data);
   const substrateMemories = Array.isArray(substrateArtifact?.data?.memories)
     ? substrateArtifact.data.memories
     : [];
-  const staleHarnessText = String(
-    staleHarnessArtifact?.data?.harness ??
-    staleHarnessArtifact?.data?.packet?.prompt?.fullText ??
-    '',
-  );
+  const staleHarnessText = extractHarnessPromptText(staleHarnessArtifact?.data);
   const staleSubstrateMemories = Array.isArray(staleSubstrateArtifact?.data?.memories)
     ? staleSubstrateArtifact.data.memories
     : [];
   const packetMentionsMemory = MEMORY_REF_RX.test(harnessText);
   const stalePacketMentionsMemory = MEMORY_REF_RX.test(staleHarnessText);
+  const persistedDirectionUsable = Boolean(directionArtifact?.data?.usable === true);
+  const persistedOwnerBootstrap = Boolean(directionArtifact?.data?.ownerBootstrap === true);
+  const activePlanPresent = Boolean(
+    activePlanArtifact?.data?.phases &&
+    Array.isArray(activePlanArtifact.data.phases) &&
+    activePlanArtifact.data.phases.length > 0,
+  );
 
   return {
     hasHarnessPacket: Boolean(harnessText.trim()),
     hasAriaDirection: Boolean(
-      (directionArtifact?.data?.usable === true) ||
-      (activePlanArtifact?.data?.phases && Array.isArray(activePlanArtifact.data.phases) && activePlanArtifact.data.phases.length > 0),
+      persistedDirectionUsable || activePlanPresent,
     ),
     hasMemoryRef: Boolean(packetMentionsMemory || substrateMemories.length > 0),
     ownerBootstrap: {
-      hasHarnessPacket: Boolean(staleHarnessText.trim()),
+      hasHarnessPacket: Boolean(staleHarnessText.trim() || staleHarnessArtifact?.path),
       hasMemoryRef: Boolean(stalePacketMentionsMemory || staleSubstrateMemories.length > 0),
-      directionBootstrap: Boolean(directionArtifact?.data?.ownerBootstrap === true),
+      directionBootstrap: persistedOwnerBootstrap || persistedDirectionUsable || activePlanPresent,
     },
     detail: {
       packetPath: harnessArtifact?.path || null,
@@ -204,6 +257,9 @@ function detectArtifactSignals(sessionId) {
       ownerBootstrapSubstrateAgeMs: staleSubstrateArtifact?.ageMs ?? null,
       ownerBootstrapSubstrateMemoryCount: staleSubstrateMemories.length,
       ownerBootstrapPacketMentionsMemory: stalePacketMentionsMemory,
+      ownerBootstrapPersistedDirectionUsable: persistedDirectionUsable,
+      ownerBootstrapPersistedDirectionSource: directionArtifact?.data?.source ?? null,
+      ownerBootstrapActivePlanPresent: activePlanPresent,
     },
   };
 }
@@ -429,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) => ({
@@ -497,6 +557,13 @@ const ownerBootstrapSessionPresent =
   artifactSignals.ownerBootstrap.hasHarnessPacket &&
   artifactSignals.ownerBootstrap.hasMemoryRef;
 
+const ownerCompactionRecoveryPresent =
+  existsSync(OWNER_TOKEN_PATH) &&
+  !transcriptWindow.trim() &&
+  artifactSignals.ownerBootstrap.hasHarnessPacket &&
+  artifactSignals.ownerBootstrap.hasMemoryRef &&
+  (artifactSignals.ownerBootstrap.directionBootstrap || artifactSignals.detail.ownerBootstrapPersistedDirectionUsable);
+
 if (allSignalsPresent) {
   // Context was loaded — allow and record the fire timestamp for dedup.
   writeTurnState(sessionId, { lastTurnGateFiredAt: now, lastDecision: 'allow', signals, transcriptSignals, artifactSignals: artifactSignals.detail });
@@ -528,6 +595,16 @@ if (ownerBootstrapSessionPresent) {
   process.exit(0);
 }
 
+if (ownerCompactionRecoveryPresent) {
+  writeTurnState(sessionId, { lastTurnGateFiredAt: now, lastDecision: 'allow-owner-compaction-recovery', signals, transcriptSignals, artifactSignals: artifactSignals.detail });
+  auditLog(
+    'allow-owner-compaction-recovery',
+    `transcript compacted/empty; recovering from persisted owner artifacts. transcript=${JSON.stringify(transcriptSignals)} artifacts=${JSON.stringify(artifactSignals.detail)}`,
+    sessionId,
+  );
+  process.exit(0);
+}
+
 // ── Block with structured recovery signal ────────────────────────────
 // Per Aria's refined spec (consult 2026-04-27): soft-gate + structured
 // recovery. The orchestrator catches this and runs the context-loader.
@@ -556,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',
@@ -219,6 +242,8 @@ function isPolicyOrRuleDefinitionLine(line) {
   if (/\bno stubs?\b/.test(lower)) return true;
   if (/\bno placeholders?\b/.test(lower)) return true;
   if (/\bno fake implementations?\b/.test(lower)) return true;
+  if (lower.includes('no mock content is injected')) return true;
+  if (/\bplaceholder\s*=/.test(lower)) return true;
   return false;
 }
 
@@ -382,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);
   }