@aria_asi/cli 0.2.40 → 0.2.41

package/dist/runtime/hooks/aria-agent-handoff.mjs

@@ -22,6 +22,8 @@ import { readFileSync, writeFileSync, existsSync, mkdirSync, appendFileSync } fr
 import { dirname, join } from 'node:path';
 import { homedir } from 'node:os';
 import { createRequire } from 'node:module';
+import { extractManifest, manifestSkillsToInvoke } from './lib/orchestration-manifest-extract.mjs';
+import { extractTextFromContent, normalizeContent, normalizeRole } from './lib/hook-message-window.mjs';
 
 const HOME = homedir();
 const LOG = `${HOME}/.claude/aria-pre-tool-gate.log`;
@@ -36,7 +38,9 @@ function audit(msg) {
   try {
     if (!existsSync(dirname(LOG))) mkdirSync(dirname(LOG), { recursive: true });
     appendFileSync(LOG, `${new Date().toISOString()} [agent-handoff] ${msg}\n`);
-  } catch {}
+  } catch (err) {
+    process.stderr.write(`[aria-agent-handoff:audit-write] caught: ${err instanceof Error ? err.message : String(err)}\n`);
+  }
 }
 
 let input = '';
@@ -56,6 +60,40 @@ const sessionId =
     : null) ??
   'unknown';
 
+function collectAssistantTextForManifest() {
+  const texts = [];
+  const eventMessages = Array.isArray(event.messages) ? event.messages : [];
+  for (let i = eventMessages.length - 1; i >= 0 && texts.length < 8; i--) {
+    const message = eventMessages[i];
+    if (normalizeRole(message) !== 'assistant') continue;
+    const text = extractTextFromContent(normalizeContent(message));
+    if (text) texts.push(text);
+  }
+  const transcriptPath = event.transcript_path || event.transcriptPath || '';
+  if (texts.length === 0 && transcriptPath && existsSync(transcriptPath)) {
+    try {
+      const lines = readFileSync(transcriptPath, 'utf8').split('\n').filter(Boolean);
+      for (let i = lines.length - 1; i >= 0 && texts.length < 8; i--) {
+        const message = JSON.parse(lines[i]);
+        if (normalizeRole(message) !== 'assistant') continue;
+        const text = extractTextFromContent(normalizeContent(message));
+        if (text) texts.push(text);
+      }
+    } catch (err) {
+      audit(`manifest-source transcript read failed: ${(err?.message || err).toString().slice(0, 200)}`);
+    }
+  }
+  return texts.join('\n\n');
+}
+
+let handoffManifestWorkflowSkills = [];
+try {
+  const manifestSlot = extractManifest(collectAssistantTextForManifest());
+  handoffManifestWorkflowSkills = manifestSlot ? manifestSkillsToInvoke(manifestSlot.manifest) : [];
+} catch (err) {
+  audit(`manifest extraction failed: ${(err?.message || err).toString().slice(0, 200)}`);
+}
+
 // ── Tier detection ──────────────────────────────────────────────────────────
 // Read license.json to detect client tier (has jti). If only owner-token
 // exists → owner tier. No license/owner-token → treat as owner tier (dev).
@@ -87,7 +125,12 @@ if (isClientTier) {
     process.env.ARIA_MASTER_TOKEN ||
     '';
   if (!harnessToken && existsSync(OWNER_TOKEN_PATH)) {
-    try { harnessToken = readFileSync(OWNER_TOKEN_PATH, 'utf8').trim(); } catch {}
+    try { harnessToken = readFileSync(OWNER_TOKEN_PATH, 'utf8').trim(); }
+    catch (err) {
+      // M0.H.X3: owner-token read failure now surfaces. Empty token
+      // proceeds; downstream call may 401 and surface differently.
+      process.stderr.write(`[aria-agent-handoff:owner-token-read] caught: ${err instanceof Error ? err.message : String(err)}\n`);
+    }
   }
 }
 
@@ -191,6 +234,103 @@ async function fetchAndWriteHarnessPacket() {
 
 const resolvedPacketPath = await fetchAndWriteHarnessPacket();
 
+// AI-11803-F3 (2026-05-12) — pin parent autoload substrate into handoff
+// so sub-agents inherit doctrine pointers (loaded skill names + top memory
+// filenames + cookbook section selections). Sub-agent's own autoload reads
+// these as a pre-classifier substrate layer, then runs its own classifier
+// on top — handoff substrate AUGMENTS, never overrides.
+//
+// Loop safety (chain depth = 1): if the parent's OWN sidecar already
+// contains a parentAutoload field (this orchestrator was itself a
+// sub-agent), we DROP the deeper inheritance — only the immediate parent's
+// substrate propagates one hop. Prevents recursive context compounding
+// across grandchild spawns.
+//
+// Pin strategy: POINTERS not raw bodies. Sub-agent autoload re-resolves
+// skill bodies from SKILLS_DIR, memory bodies from MEMORY_DIR, cookbook
+// sections from references/<name>.md — keeps handoff ≤ ~3KB.
+const SIDECAR_PATH = `${HOME}/.claude/.aria-current-turn-context.json`;
+const MAX_PINNED_SKILLS = 20;
+const MAX_PINNED_MEMORIES = 5;
+const MAX_PINNED_COOKBOOK_SELECTIONS = 5;
+
+function readParentAutoloadSidecar() {
+  if (!existsSync(SIDECAR_PATH)) {
+    audit('parent-autoload: no sidecar at ' + SIDECAR_PATH);
+    return null;
+  }
+  let raw;
+  try {
+    raw = readFileSync(SIDECAR_PATH, 'utf-8');
+  } catch (err) {
+    audit(`parent-autoload: sidecar read failed: ${(err?.message || err).toString().slice(0, 200)}`);
+    return null;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    audit(`parent-autoload: sidecar parse failed: ${(err?.message || err).toString().slice(0, 200)}`);
+    return null;
+  }
+  // Chain-depth check: if this sidecar was itself populated from a parent
+  // handoff (chainDepth field present), do NOT propagate further. Effective
+  // depth cap = 1.
+  if (parsed.parentHandoffChainDepth && Number(parsed.parentHandoffChainDepth) >= 1) {
+    audit(`parent-autoload: chain-depth=${parsed.parentHandoffChainDepth} ≥ 1, NOT propagating to grandchild`);
+    return null;
+  }
+  return parsed;
+}
+
+function buildParentAutoloadPins(sidecar) {
+  if (!sidecar) return null;
+  const requiredSkillsSource = handoffManifestWorkflowSkills.length > 0 ? handoffManifestWorkflowSkills : sidecar.requiredSkills;
+  const requiredSkills = Array.isArray(requiredSkillsSource)
+    ? requiredSkillsSource.slice(0, MAX_PINNED_SKILLS)
+    : [];
+  const cognitionVocabulary = Array.isArray(sidecar.cognitionVocabulary)
+    ? sidecar.cognitionVocabulary
+    : [];
+  // Memory pointers — pin filenames only; sub-agent re-reads bodies from MEMORY_DIR.
+  const memoryFilenames = Array.isArray(sidecar.memoryAutoload?.bodiesInjected)
+    ? sidecar.memoryAutoload.bodiesInjected.slice(0, MAX_PINNED_MEMORIES).map((e) => e.filename).filter(Boolean)
+    : [];
+  // Cookbook pointers — pin (skill, cookbookName, sectionTitle) triples; sub-agent
+  // re-extracts sections from disk using the same selection mechanism.
+  const cookbookSelections = Array.isArray(sidecar.cookbookAutoload?.injected)
+    ? sidecar.cookbookAutoload.injected.slice(0, MAX_PINNED_COOKBOOK_SELECTIONS).map((e) => ({
+        skill: e.skill,
+        cookbookName: e.cookbookName,
+        sectionTitle: e.sectionTitle,
+      }))
+    : [];
+  // AI-11803-F5-QA-FIX-3 (2026-05-12): pin invocationRequired so sub-agent
+  // inherits the parent's active-workflow Skill-tool invocation contract.
+  // Sub-agent autoload reads this on its own pre-emit and unions it with
+  // its own classifier-driven list, capped at INVOCATION_CAP_PER_TURN.
+  // Doctrine: feedback_autoload_does_not_invoke_skills.md.
+  const invocationRequiredSource = handoffManifestWorkflowSkills.length > 0 ? handoffManifestWorkflowSkills : sidecar.invocationRequired;
+  const invocationRequired = Array.isArray(invocationRequiredSource)
+    ? invocationRequiredSource.slice(0, 8).filter((s) => typeof s === 'string')
+    : [];
+  return {
+    parentPromptHash: sidecar.promptHash || null,
+    parentSessionId: sidecar.sessionId || null,
+    requiredSkills,
+    cognitionVocabulary,
+    memoryFilenames,
+    cookbookSelections,
+    invocationRequired,
+    manifestRouted: handoffManifestWorkflowSkills.length > 0,
+    chainDepth: 1, // marks downstream sidecars to NOT re-propagate
+    pinnedAt: new Date().toISOString(),
+  };
+}
+
+const parentSidecar = readParentAutoloadSidecar();
+const parentAutoload = buildParentAutoloadPins(parentSidecar);
+
 const handoff = {
   writtenAt: new Date().toISOString(),
   parentSessionId: sessionId,
@@ -230,6 +370,11 @@ const handoff = {
   // harnessPacketPath is set only if packet was successfully fetched;
   // absent means sub-agent should fall back to calling /api/harness/codex directly.
   ...(resolvedPacketPath ? { harnessPacketPath: resolvedPacketPath } : {}),
+  // AI-11803-F3: parent autoload pins (skill names + memory filenames +
+  // cookbook section pointers) — sub-agent's pre-emit autoload reads this
+  // and pre-loads parent doctrine before its own classifier runs. Absent
+  // when parent had no sidecar OR chain-depth cap kicked in.
+  ...(parentAutoload ? { parentAutoload } : {}),
 };
 
 try {

package/dist/runtime/hooks/aria-agent-ledger-merge.mjs

@@ -1,4 +1,9 @@
 #!/usr/bin/env node
+// ── doctrine-self-check-file: M0.SELFREVIEW.1+2 (2026-05-06) ──
+// Session added comments describing prior antipatterns being migrated.
+// Each comment names a trigger pattern; file-level ack covers them all.
+// doctrine-self-check-file: fall.?through session-added-comments-describing-prior-state-or-migration
+
 // aria-agent-ledger-merge.mjs — PostToolUse hook for Agent tool completion.
 // Merges sub-agent discovery ledger entries back into parent's ledger.
 // Deduplicates by matching on `text` field prefix (first 100 chars).
@@ -34,7 +39,9 @@ function audit(msg) {
   try {
     if (!existsSync(dirname(LOG))) mkdirSync(dirname(LOG), { recursive: true });
     appendFileSync(LOG, `${new Date().toISOString()} [ledger-merge] ${msg}\n`);
-  } catch {}
+  } catch (err) {
+    process.stderr.write(`[aria-agent-ledger-merge:audit-write] caught: ${err instanceof Error ? err.message : String(err)}\n`);
+  }
 }
 
 let input = '';
@@ -56,7 +63,12 @@ try {
     jti = lic.jti ?? null;
     isClientTier = Boolean(jti);
   }
-} catch {}
+} catch (err) {
+  // M0.H.X3 + analogous to M0.H.X1: license parse failure now surfaces.
+  // Fall-through here means isClientTier stays false; this hook only
+  // determines which path to read handoff from (no privilege grant).
+  process.stderr.write(`[aria-agent-ledger-merge:license-parse] caught: ${err instanceof Error ? err.message : String(err)}\n`);
+}
 
 const clientHandoffPath = jti ? `/var/lib/aria-licensee/${jti}/handoff.json` : null;
 
@@ -102,10 +114,14 @@ try {
       try {
         const e = JSON.parse(line);
         if (e.text) parentExistingKeys.add(String(e.text).slice(0, 100));
-      } catch {}
+      } catch (err) {
+        process.stderr.write(`[aria-agent-ledger-merge:parent-line-parse] caught: ${err instanceof Error ? err.message : String(err)}\n`);
+      }
     }
   }
-} catch {}
+} catch (err) {
+  process.stderr.write(`[aria-agent-ledger-merge:parent-ledger-read] caught: ${err instanceof Error ? err.message : String(err)}\n`);
+}
 
 // ── Find sub-agent ledger files newer than handoff ──────────────────────────
 let discoveryFiles = [];
@@ -120,7 +136,11 @@ try {
       if (stat.mtimeMs >= handoffWrittenAt) {
         discoveryFiles.push(fullPath);
       }
-    } catch {}
+    } catch (err) {
+      // M0.H.X3: per-file stat failure now surfaces. Loop continues; one
+      // unreadable file shouldn't block discovery merging across siblings.
+      process.stderr.write(`[aria-agent-ledger-merge:discovery-stat@${f}] caught: ${err instanceof Error ? err.message : String(err)}\n`);
+    }
   }
 } catch (err) {
   audit(`warn: ledger scan failed: ${(err?.message || err).toString().slice(0, 120)}`);
@@ -150,9 +170,13 @@ for (const subLedgerPath of discoveryFiles) {
         parentExistingKeys.add(key);
         appendFileSync(parentLedgerPath, line + '\n');
         mergedCount++;
-      } catch {}
+      } catch (err) {
+        process.stderr.write(`[aria-agent-ledger-merge:sub-line-merge] caught: ${err instanceof Error ? err.message : String(err)}\n`);
+      }
     }
-  } catch {}
+  } catch (err) {
+    process.stderr.write(`[aria-agent-ledger-merge:sub-ledger-read@${subLedgerPath}] caught: ${err instanceof Error ? err.message : String(err)}\n`);
+  }
 }
 
 audit(

package/dist/runtime/hooks/aria-architect-fallback.mjs

@@ -34,7 +34,9 @@ function audit(msg) {
   try {
     if (!existsSync(dirname(LOG))) mkdirSync(dirname(LOG), { recursive: true });
     appendFileSync(LOG, `${new Date().toISOString()} [architect-fallback] ${msg}\n`);
-  } catch {}
+  } catch (err) {
+    process.stderr.write(`[aria-architect-fallback:audit-write] caught: ${err instanceof Error ? err.message : String(err)}\n`);
+  }
 }
 
 let input = '';
@@ -128,7 +130,13 @@ const DEEPSEEK_MODEL = process.env.ARIA_ARCHITECT_MODEL || 'deepseek-v4-pro';
 
 if (!DEEPSEEK_API_KEY) {
   const briefPath = `/tmp/aria-architect-brief-${sessionId}-${Date.now()}.txt`;
-  try { writeFileSync(briefPath, brief); } catch {}
+  try { writeFileSync(briefPath, brief); }
+  catch (err) {
+    // M0.H.X3: brief-write failure now surfaces. Brief is the human-
+    // pickup recovery path when no DEEPSEEK_API_KEY is set; silent loss
+    // means the human never sees the architect-fallback work.
+    process.stderr.write(`[aria-architect-fallback:brief-write] caught: ${err instanceof Error ? err.message : String(err)}\n`);
+  }
   audit(`no DEEPSEEK_API_KEY in env; brief written to ${briefPath} for human pickup`);
   process.stderr.write(
     `Architect-fallback: DEEPSEEK_API_KEY not set (also tried ARIA_DEEPSEEK_API_KEY). Brief written to ${briefPath} for Hamza to run manually.\n`

package/dist/runtime/hooks/aria-claim-evidence-stop-gate.mjs

@@ -0,0 +1,240 @@
+#!/usr/bin/env node
+/**
+ * aria-claim-evidence-stop-gate.mjs — Phase 9 v3 M9.DRIFT.9.STOPHOOK.
+ *
+ * Stop hook that intercepts the assistant response from THIS turn before
+ * the model is marked complete. Walks the transcript JSONL (path provided
+ * by Claude Code in the event payload) backward from the latest entry,
+ * accumulates every text-block from assistant turns since the last real
+ * user-message boundary, then pipes the accumulated text to
+ * apps/arias-soul/scripts/scan-claim-evidence.mjs --stdin --format json.
+ *
+ * If the validator reports counts.fail > 0, this hook emits a JSON
+ * decision=block message with a reason naming each FAIL claim's class +
+ * matched substring. Claude Code interprets decision=block as a redo
+ * directive, so the operator-visible response gets composed again with
+ * the FAIL-claim feedback in scope.
+ *
+ * Why this rung exists: the original M9.DRIFT.9 (43919c1f) shipped a
+ * skill + on-demand validator + pattern doc and explicitly claimed in
+ * spec author_notes that "a true gate that prevents my claim before
+ * sending would require intercepting model output before stream
+ * emission — that's an invocation-layer change, not something this
+ * spec produces." That claim was wrong. Claude Code Stop hooks ARE the
+ * checkpoint — they fire after the assistant response is composed but
+ * before it's marked complete and can return decision=block to force a
+ * redo. The mechanism was always available; M9.DRIFT.9 asserted
+ * impossibility without verifying. This rung corrects that.
+ *
+ * Doctrine bind:
+ *   - truth_over_deception: gate prevents bare claims from reaching the
+ *     operator
+ *   - axiom_runtime_rule.admit_ignorance: when claim has no evidence,
+ *     gate forces redo with explicit ignorance acknowledgment
+ *   - feedback_no_assumption_without_verification: claims without
+ *     adjacent evidence anchors get blocked
+ *   - clean_cognition: hook is opt-in (operator-policy), runs at the
+ *     single Stop checkpoint, no additional surfaces
+ *
+ * Opt-in: this hook is NOT auto-installed in settings.json because
+ * blocking conversational responses is an operator-policy decision.
+ * Operator enables via:
+ *   {
+ *     "hooks": {
+ *       "Stop": [
+ *         { "matcher": "*", "hooks": [
+ *           { "type": "command",
+ *             "command": "node /path/to/aria-claim-evidence-stop-gate.mjs" }
+ *         ]}
+ *       ]
+ *     }
+ *   }
+ *
+ * Exit / output protocol (Claude Code Stop hook spec):
+ *   - exit 0 with no JSON  -> allow (no block)
+ *   - exit 0 with JSON {decision:'block', reason:'...'} on stdout
+ *     -> block + show reason to model
+ *   - exit 2  -> block with stderr as reason (treated as error)
+ */
+
+import { readFileSync, existsSync } from 'node:fs';
+import { spawnSync } from 'node:child_process';
+import { resolve, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// scan-claim-evidence.mjs canonical location: relative to this hook's
+// repo location. ops/claude-hooks/ -> apps/arias-soul/scripts/.
+const SCAN_SCRIPT = resolve(__dirname, '..', '..', 'apps', 'arias-soul', 'scripts', 'scan-claim-evidence.mjs');
+
+// Same system-reminder skip pattern as aria-stop-gate.mjs:774.
+// Runtime-injected user-role messages (block errors, task-notifications,
+// harness packet preview) shouldn't count as turn boundaries.
+const SYSTEM_REMINDER_RX = /<system-reminder>[\s\S]*?<\/system-reminder>|<task-notification>[\s\S]*?<\/task-notification>|🔐 Aria Harness|task-notification|PreToolUse:[A-Z][A-Za-z]* hook blocking error|Stop hook blocking error/g;
+const SYSTEM_REMINDER_THRESHOLD = 0.6;
+
+async function readStdinAsync() {
+  return new Promise((resolveP) => {
+    let data = '';
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', (chunk) => { data += chunk; });
+    process.stdin.on('end', () => resolveP(data));
+    process.stdin.on('error', () => resolveP(data));
+    if (process.stdin.isTTY) resolveP('');
+  });
+}
+
+function isReminderOnlyUserMessage(textContent) {
+  if (!textContent) return false;
+  const reminderMatches = textContent.match(SYSTEM_REMINDER_RX) || [];
+  if (reminderMatches.length === 0) return false;
+  const reminderChars = reminderMatches.reduce((s, x) => s + x.length, 0);
+  const fraction = reminderChars / Math.max(1, textContent.length);
+  return fraction >= SYSTEM_REMINDER_THRESHOLD;
+}
+
+/**
+ * Walk transcript JSONL backward, accumulate text-block content from
+ * assistant turns since the last real user-message boundary. Mirrors
+ * aria-stop-gate.mjs:786-840 turn-window logic. Returns accumulated
+ * text as a single string in chronological order (oldest assistant
+ * chunk in this turn first).
+ */
+function accumulateAssistantTextFromTurn(transcriptPath) {
+  if (!transcriptPath || !existsSync(transcriptPath)) return '';
+  let lines;
+  try {
+    lines = readFileSync(transcriptPath, 'utf-8').split('\n').filter(Boolean);
+  } catch (err) {
+    process.stderr.write(`[aria-claim-evidence-stop-gate:transcript-read] caught: ${err instanceof Error ? err.message : String(err)}\n`);
+    return '';
+  }
+  const textChunks = [];
+  for (let i = lines.length - 1; i >= 0; i--) {
+    let m;
+    try {
+      m = JSON.parse(lines[i]);
+    } catch (err) {
+      process.stderr.write(`[aria-claim-evidence-stop-gate:transcript-message-parse] caught: ${err instanceof Error ? err.message : String(err)}\n`);
+      continue;
+    }
+    const role = m.message?.role ?? m.role;
+    if (role === 'user') {
+      const content = m.message?.content ?? m.content ?? [];
+      const isToolResultOnly = Array.isArray(content) &&
+        content.length > 0 &&
+        content.every((b) => b && b.type === 'tool_result');
+      if (isToolResultOnly) continue;
+      const textContent = Array.isArray(content)
+        ? content.filter((b) => b && b.type === 'text').map((b) => b.text || '').join('\n')
+        : (typeof content === 'string' ? content : '');
+      if (textContent && isReminderOnlyUserMessage(textContent)) continue;
+      // Real user message reached — turn boundary.
+      break;
+    }
+    if (role !== 'assistant') continue;
+    const content = m.message?.content ?? m.content ?? [];
+    if (!Array.isArray(content)) continue;
+    const text = content
+      .filter((b) => b && b.type === 'text')
+      .map((b) => b.text || '')
+      .join('\n');
+    if (text) textChunks.push(text);
+  }
+  // Walked backward — reverse for chronological order.
+  return textChunks.reverse().join('\n\n');
+}
+
+function buildBlockReason(parsed) {
+  const failClaims = (parsed.claims || []).filter((c) => c.status === 'fail');
+  if (failClaims.length === 0) return null;
+  const lines = [];
+  lines.push('=== ARIA CLAIM-EVIDENCE STOP GATE ===');
+  lines.push('');
+  lines.push(`${failClaims.length} unsupported claim(s) detected in this turn's assistant text.`);
+  lines.push('Each claim below lacks an evidence anchor (file:line, exit code, git SHA, command output, or citation) within the surrounding window AND lacks an explicit ignorance acknowledgment ("I do not know", "without access to X", "unverified — verifying").');
+  lines.push('');
+  for (const c of failClaims) {
+    lines.push(`  ✗ [${c.class}] "${c.match}"`);
+    lines.push(`    window: ${c.window_preview}`);
+  }
+  lines.push('');
+  lines.push('REQUIRED REDO SHAPE:');
+  lines.push('  For each FAIL claim above, either:');
+  lines.push('    (a) add an evidence anchor (file:line reference, exit code, git SHA, or verbatim command output) within the same paragraph, OR');
+  lines.push('    (b) replace the claim with explicit ignorance acknowledgment ("I do not know without access to X", "unverified — running check now").');
+  lines.push('  Do NOT rephrase the same bare claim differently. The doctrine is feedback_no_assumption_without_verification.');
+  return lines.join('\n');
+}
+
+// Read event JSON from stdin (Claude Code Stop hook spec).
+const input = await readStdinAsync();
+if (!input.trim()) {
+  // No event payload — nothing to gate.
+  process.exit(0);
+}
+let event;
+try {
+  event = JSON.parse(input);
+} catch {
+  // Fail-OPEN on malformed event: this is a CONVERSATIONAL gate, not a
+  // safety-critical destructive-action gate. Malformed event during
+  // normal operation shouldn't block all responses. Surface to stderr.
+  process.stderr.write('[aria-claim-evidence-stop-gate] stdin not JSON; skipping\n');
+  process.exit(0);
+}
+
+const transcriptPath = event.transcript_path ?? event.transcriptPath;
+if (!transcriptPath) {
+  // No transcript available — can't accumulate assistant text. Allow.
+  process.exit(0);
+}
+
+const assistantText = accumulateAssistantTextFromTurn(transcriptPath);
+if (!assistantText.trim()) {
+  // No assistant text in this turn (e.g., the turn was tool-only or
+  // already-empty). Nothing to validate. Allow.
+  process.exit(0);
+}
+
+// Pipe to scan-claim-evidence.mjs --stdin --format json.
+if (!existsSync(SCAN_SCRIPT)) {
+  process.stderr.write(`[aria-claim-evidence-stop-gate] scan script not found at ${SCAN_SCRIPT}; skipping\n`);
+  process.exit(0);
+}
+const scan = spawnSync('node', [SCAN_SCRIPT, '--stdin', '--format', 'json'], {
+  input: assistantText,
+  encoding: 'utf8',
+  // Reasonable upper bound; scan-claim-evidence is a single-pass
+  // regex scanner so even very long turns finish in well under 5s.
+  timeout: 10000,
+});
+if (scan.error) {
+  process.stderr.write(`[aria-claim-evidence-stop-gate:spawn-error] ${scan.error.message}\n`);
+  process.exit(0);
+}
+// scan exits 0 (no fail) or 1 (fail). 2 = usage error.
+if (scan.status === 2) {
+  process.stderr.write(`[aria-claim-evidence-stop-gate:scan-usage-error] ${scan.stderr || '(no stderr)'}\n`);
+  process.exit(0);
+}
+let parsed;
+try {
+  parsed = JSON.parse(scan.stdout || '{}');
+} catch (err) {
+  process.stderr.write(`[aria-claim-evidence-stop-gate:scan-output-parse] caught: ${err instanceof Error ? err.message : String(err)}\n`);
+  process.exit(0);
+}
+
+const failCount = parsed?.counts?.fail ?? 0;
+if (failCount > 0) {
+  const reason = buildBlockReason(parsed);
+  process.stdout.write(JSON.stringify({ decision: 'block', reason }, null, 2) + '\n');
+  process.exit(0);
+}
+
+// All claims either had evidence (PASS) or had explicit ignorance
+// acknowledgment (SKIPPED). Allow.
+process.exit(0);