@aria_asi/cli 0.2.26 → 0.2.30

package/dist/assets/hooks/aria-pre-emit-dryrun.mjs

@@ -0,0 +1,294 @@
+#!/usr/bin/env node
+// aria-pre-emit-dryrun.mjs (#140)
+//
+// Pre-emit dry-run validator. CLI tool the model invokes BEFORE actually
+// emitting an assistant response, to self-validate against the same gates
+// that run at Stop time (substrate-binding, drift-triggers, discovery-
+// binding, owner-decision-marker).
+//
+// Owner directive 2026-04-28: structural prevention of the cosmetic-loop
+// pattern where Claude emits → gate blocks → re-drafts → emits → blocked
+// again. With this dry-run, the model can self-check the draft against
+// the loaded substrate manifest (#142) and the drift-trigger list before
+// sending. Catches forgery + drift + missing first_principle locally.
+//
+// Usage:
+//   echo '{"draft":"<full assistant response text>","action_type":"deploy|edit|bash|text"}' \
+//     | node ~/.claude/hooks/aria-pre-emit-dryrun.mjs
+//
+// Output JSON:
+//   {
+//     pass: bool,
+//     failures: [
+//       {kind: "substrate_anchor_forgery", lens: "nur", anchor: "axiom:made_up", reason: "..."},
+//       {kind: "drift_trigger", word: "wrapper", position: 1234},
+//       {kind: "missing_first_principle"},
+//       {kind: "lens_count_below_threshold", count: 5, required: 8},
+//       {kind: "lens_substance_below", lens: "mizan", chars: 12, required: 40},
+//       ...
+//     ],
+//     summary: "X failures: <one-line summary>"
+//   }
+//
+// Exit code:
+//   0  if pass=true (draft would pass the gates)
+//   1  if pass=false (draft would be rejected; failures array names the issues)
+//   2  if input is malformed (cannot parse draft)
+//
+// Substrate source: reads ~/.claude/.aria-loaded-substrate.json written by
+// aria-cognition-substrate-binding.mjs each turn. If that file is missing
+// or stale, the dry-run still runs but substrate-anchor forgery checks
+// degrade to "warn" instead of "fail" (LOUD log on stderr).
+
+import { readFileSync, existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+
+const HOME = process.env.HOME || homedir() || '/tmp';
+const SUBSTRATE_DUMP_PATH = `${HOME}/.claude/.aria-loaded-substrate.json`;
+const MEMORY_DIR = `${HOME}/.claude/projects/-home-hamzaibrahim1/memory`;
+
+// Mirror the canonical gate constants — keep in sync if the gates change.
+const LENS_NAMES = ['nur', 'mizan', 'hikma', 'tafakkur', 'tadabbur', 'ilham', 'wahi', 'firasah'];
+const REQUIRED_LENSES = 8;
+const SUBSTANCE_MIN_AFTER_ANCHOR_STRIP = 40;
+const ANCHOR_RX = /\b(axiom|frame|memory|doctrine|packet|language):[a-z0-9_\-./]+/gi;
+const COGNITION_BLOCK_RX = /<cognition>([\s\S]*?)<\/cognition>/i;
+const FIRST_PRINCIPLE_RX = /\b(first[_\s-]?principle[s]?|first_principle=)\b/i;
+
+// Drift trigger patterns (mirror aria-stop-gate.mjs canonical list).
+// Keep this conservative — false negatives are tolerable (real gate will
+// catch); false positives waste model time.
+const DRIFT_TRIGGERS = [
+  { rx: /\b(want me to|should i)\b/i, doctrine: 'feedback_use_harness_to_architect.md' },
+  { rx: /\b(i think|i guess|i assume)\b/i, doctrine: 'feedback_doctrine_first.md' },
+  { rx: /\b(shadow|proxy|wrapper)\b/i, doctrine: 'feedback_aria_already_has_fleet_use_existing_substrate.md' },
+  { rx: /\b(patch|hotfix|band[- ]?aid)\b/i, doctrine: 'feedback_gates_enforce_form_not_substance.md' },
+  { rx: /\b(preferred over|optional|fallback layer)\b/i, doctrine: 'feedback_pretoolgate_covers_all_action_tools.md' },
+  { rx: /\b(non[- ]?blocking|fail[- ]?open|silent[- ]?pass|fire[- ]?and[- ]?forget|graceful[- ]?degradation)\b/i, doctrine: 'feedback_non_blocking_errors_unacceptable.md' },
+  { rx: /\bdemo\b/i, doctrine: 'feedback_no_demos.md' },
+  { rx: /\b(fail loud|crash on missing)\b/i, doctrine: 'feedback_no_graceful_degradation.md' },
+  { rx: /\b(just context|advisory|read[. ]only)\b/i, doctrine: 'feedback_full_harness_binding_must_be_structural.md' },
+];
+
+function loadSubstrate() {
+  if (!existsSync(SUBSTRATE_DUMP_PATH)) return null;
+  try {
+    return JSON.parse(readFileSync(SUBSTRATE_DUMP_PATH, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function extractLensTexts(cognitionInner) {
+  const out = {};
+  for (const lens of LENS_NAMES) {
+    const lensRx = new RegExp(
+      `\\b${lens}\\s*:\\s*([^\\n]*(?:\\n(?!\\s*(?:${LENS_NAMES.join('|')})\\s*:|<\\/cognition>)[^\\n]*)*)`,
+      'i',
+    );
+    const m = cognitionInner.match(lensRx);
+    if (m) out[lens] = (m[1] || '').trim();
+  }
+  return out;
+}
+
+function lensSubstanceLength(text) {
+  if (!text) return 0;
+  return text.replace(ANCHOR_RX, '').replace(/\s+/g, ' ').trim().length;
+}
+
+function verifyAnchor(anchor, substrate) {
+  const [kind, ...nameParts] = anchor.split(':');
+  const name = nameParts.join(':').toLowerCase().replace(/[.,;:!?]+$/, '');
+  const kindLc = kind.toLowerCase();
+  if (!substrate) return { ok: true, reason: 'substrate_dump_missing_so_warn_only' };
+  if (kindLc === 'axiom') {
+    const ok = (substrate.axioms || []).map((a) => a.toLowerCase()).includes(name)
+            || (substrate.axioms || []).map((a) => a.toLowerCase().replace(/_/g, '')).includes(name);
+    return { ok, reason: ok ? '' : `axiom '${name}' not in loaded set (loaded: ${(substrate.axioms || []).slice(0, 8).join(', ')}…)` };
+  }
+  if (kindLc === 'frame') {
+    const ok = (substrate.frames || []).map((f) => f.toLowerCase()).includes(name);
+    return { ok, reason: ok ? '' : `frame '${name}' not loaded` };
+  }
+  if (kindLc === 'memory') {
+    const baseName = name.endsWith('.md') ? name : `${name}.md`;
+    const ok = (substrate.memories || []).map((m) => m.toLowerCase()).includes(baseName);
+    return { ok, reason: ok ? '' : `memory '${baseName}' not in MEMORY.md index` };
+  }
+  if (kindLc === 'doctrine') {
+    const ok = (substrate.doctrines_acceptable_via_memory || []).includes(name)
+            || (substrate.memories || []).some((m) => m.toLowerCase() === `feedback_${name}.md` || m.toLowerCase() === `${name}.md`);
+    return { ok, reason: ok ? '' : `doctrine '${name}' has no backing memory file` };
+  }
+  if (kindLc === 'packet') {
+    const ok = (substrate.packets || []).map((p) => p.toLowerCase()).includes(name)
+            || (substrate.packets || []).map((p) => p.toLowerCase()).includes(`${name}_rule`)
+            || (substrate.packets || []).map((p) => p.toLowerCase()).includes(`${name}_block`);
+    return { ok, reason: ok ? '' : `packet '${name}' not in loaded packet sections` };
+  }
+  if (kindLc === 'language') {
+    const langOk = (substrate.languages_loaded || []).includes(name);
+    const stateOk = name === 'nadia' ? !!substrate.languages_state_active?.nadia
+                  : name === 'noor' ? !!substrate.languages_state_active?.noor
+                  : true;
+    const ok = langOk && stateOk;
+    return { ok, reason: ok ? '' : `language '${name}' ${langOk ? 'state inactive (preStateGate)' : 'not loaded'}` };
+  }
+  return { ok: true, reason: '' };
+}
+
+// ── Read draft from stdin ─────────────────────────────────────────────
+let stdin = '';
+try {
+  for await (const chunk of process.stdin) stdin += chunk;
+} catch {
+  process.stderr.write('aria-pre-emit-dryrun: failed to read stdin\n');
+  process.exit(2);
+}
+
+let payload;
+try {
+  payload = JSON.parse(stdin);
+} catch {
+  process.stderr.write('aria-pre-emit-dryrun: stdin not valid JSON; expected {"draft":"...","action_type":"..."}\n');
+  process.exit(2);
+}
+
+const draft = String(payload.draft || '');
+const actionType = String(payload.action_type || 'text').toLowerCase();
+
+if (draft.length < 10) {
+  console.log(JSON.stringify({ pass: true, failures: [], summary: 'draft too short to validate (trivial)' }));
+  process.exit(0);
+}
+
+const substrate = loadSubstrate();
+const failures = [];
+
+// ── Cognition block presence + lens count + substance ─────────────────
+const cogMatch = draft.match(COGNITION_BLOCK_RX);
+const cognitionInner = cogMatch ? cogMatch[1] : '';
+
+if (!cogMatch && draft.length >= 300) {
+  failures.push({ kind: 'missing_cognition_block', message: 'Non-trivial draft lacks <cognition>...</cognition> block' });
+}
+
+let presentLenses = [];
+if (cogMatch) {
+  const lensTexts = extractLensTexts(cognitionInner);
+  presentLenses = LENS_NAMES.filter((l) => lensSubstanceLength(lensTexts[l] || '') >= SUBSTANCE_MIN_AFTER_ANCHOR_STRIP);
+  if (presentLenses.length < REQUIRED_LENSES) {
+    failures.push({
+      kind: 'lens_count_below_threshold',
+      count: presentLenses.length,
+      required: REQUIRED_LENSES,
+      lenses_substantive: presentLenses,
+      lenses_missing_or_thin: LENS_NAMES.filter((l) => !presentLenses.includes(l)),
+    });
+  }
+
+  // Anchor verification per lens
+  for (const lens of presentLenses) {
+    const text = lensTexts[lens];
+    const anchors = text.match(ANCHOR_RX) || [];
+    if (anchors.length === 0) {
+      failures.push({ kind: 'lens_no_anchor', lens });
+      continue;
+    }
+    const validAnchors = [];
+    const invalidAnchors = [];
+    for (const a of anchors) {
+      const r = verifyAnchor(a, substrate);
+      if (r.ok) validAnchors.push(a);
+      else invalidAnchors.push({ anchor: a, reason: r.reason });
+    }
+    if (validAnchors.length === 0 && invalidAnchors.length > 0) {
+      failures.push({ kind: 'lens_only_fake_anchors', lens, invalid: invalidAnchors });
+    } else if (invalidAnchors.length > 0) {
+      // Some valid + some invalid — warn but lens passes if ≥1 valid
+      failures.push({ kind: 'lens_some_fake_anchors_warn', lens, invalid: invalidAnchors, severity: 'warn' });
+    }
+  }
+
+  // First-principle reference
+  const hasFirstPrinciple = FIRST_PRINCIPLE_RX.test(cognitionInner) ||
+    (substrate?.first_principle_text && cognitionInner.toLowerCase().includes(String(substrate.first_principle_text).toLowerCase().slice(0, 30)));
+  if (!hasFirstPrinciple) {
+    failures.push({ kind: 'missing_first_principle', message: 'Cognition block must reference first_principle' });
+  }
+
+  // Nadia citation forgery
+  const nadiaCited = /\blanguage:nadia\b/i.test(cognitionInner);
+  if (nadiaCited && substrate && !substrate.languages_state_active?.nadia) {
+    failures.push({ kind: 'nadia_citation_invalid', message: 'language:nadia cited but nadia_state_absent in harness' });
+  }
+}
+
+// ── Drift triggers ────────────────────────────────────────────────────
+for (const trigger of DRIFT_TRIGGERS) {
+  const match = draft.match(trigger.rx);
+  if (match) {
+    failures.push({
+      kind: 'drift_trigger',
+      pattern: trigger.rx.source,
+      doctrine: trigger.doctrine,
+      match_text: match[0],
+      match_position: match.index,
+    });
+  }
+}
+
+// ── Deploy-class checks (when action_type indicates deploy) ────────────
+if (
+  actionType === 'deploy' ||
+  /\bbash\s+(?:\.\/)?scripts\/deploy-service\.sh\b/.test(draft) ||
+  /\bkubectl\s+rollout\s+(?:restart|undo)\b/.test(draft)
+) {
+  const verifyMatch = draft.match(/<verify>([\s\S]*?)<\/verify>/i);
+  if (!verifyMatch) {
+    failures.push({ kind: 'deploy_missing_verify_block' });
+  } else {
+    const verifyBody = verifyMatch[1];
+    const requiredFields = [
+      { rx: /\b(?:commit|HEAD|SHA|files\s+changed)\b/i, name: 'commit_or_files' },
+      { rx: /\b(?:tsc|type[\s-]?check|build|npm\s+run\s+build)\b/i, name: 'build_or_typecheck' },
+      { rx: /\b(?:admission[\s_-]?policy|validatingadmissionpolicy)\b/i, name: 'admission_policy' },
+    ];
+    const missingFields = requiredFields.filter(({ rx }) => !rx.test(verifyBody)).map(({ name }) => name);
+    if (missingFields.length > 0) {
+      failures.push({ kind: 'deploy_verify_missing_fields', missing: missingFields });
+    }
+  }
+}
+
+// ── Expected block (Dalio Layer 1) ─────────────────────────────────────
+if (actionType !== 'text' && actionType !== 'trivial') {
+  const expectedMatch = draft.match(/<expected>([\s\S]*?)<\/expected>/i);
+  if (!expectedMatch) {
+    failures.push({ kind: 'missing_expected_block', message: 'Non-trivial action requires <expected> block per doctrine:dalio_expected_required' });
+  } else {
+    const expectedBody = expectedMatch[1];
+    const QUALITATIVE_DRIFT = /\b(better|improved|more\s+robust|cleaner|nicer|should\s+work|hopefully|more\s+reliable|enhanced)\b/i;
+    if (QUALITATIVE_DRIFT.test(expectedBody)) {
+      failures.push({ kind: 'expected_qualitative_drift', message: 'Expected block contains qualitative-only language' });
+    }
+  }
+}
+
+// ── Final verdict ─────────────────────────────────────────────────────
+const hardFailures = failures.filter((f) => f.severity !== 'warn');
+const pass = hardFailures.length === 0;
+const summary = pass
+  ? `pass — lenses=${presentLenses.length}/${REQUIRED_LENSES}, anchors verified${substrate ? '' : ' (substrate dump missing)'}`
+  : `${hardFailures.length} hard failures: ${hardFailures.map((f) => f.kind).join(', ')}`;
+
+console.log(JSON.stringify({
+  pass,
+  failures,
+  summary,
+  lenses_present: presentLenses,
+  substrate_loaded: !!substrate,
+}, null, 2));
+
+process.exit(pass ? 0 : 1);

package/dist/assets/hooks/aria-pre-text-gate.mjs

@@ -0,0 +1,112 @@
+#!/usr/bin/env node
+// aria-pre-text-gate.mjs — Stop / PreCompact hook validating state-dependent
+// claims in assistant prose against probe evidence in this turn.
+//
+// Closes the "WHEN TO LOOK before speaking" gap. Existing gates fire on tool
+// calls (aria-pre-tool-gate.mjs) and prose drift triggers (aria-stop-gate.mjs);
+// neither validates whether claims about live state are grounded.
+//
+// Doctrine: pre_hook_rule (was advisory, now enforced),
+//           feedback_implementation_coupled_cognition.md,
+//           feedback_gates_enforce_form_not_substance.md.
+
+import { readFileSync, existsSync, appendFileSync, mkdirSync } from 'node:fs';
+import { dirname } from 'node:path';
+import { homedir } from 'node:os';
+
+const HOME = homedir();
+const LOG = `${HOME}/.claude/aria-pre-text-gate.log`;
+const LICENSE_PATH = `${HOME}/.aria/license.json`;
+
+function audit(msg) {
+  try {
+    if (!existsSync(dirname(LOG))) mkdirSync(dirname(LOG), { recursive: true });
+    appendFileSync(LOG, `${new Date().toISOString()} [pre-text-gate] ${msg}\n`);
+  } catch {}
+}
+
+let input = '';
+for await (const chunk of process.stdin) input += chunk;
+let event;
+try { event = JSON.parse(input); } catch { process.exit(0); }
+
+const draftText =
+  event.assistant_text ??
+  event.draft ??
+  event.text ??
+  (typeof event.tool_input?.text === 'string' ? event.tool_input.text : '') ??
+  '';
+
+if (typeof draftText !== 'string' || draftText.length < 80) process.exit(0);
+
+let isClientTier = false;
+try {
+  if (existsSync(LICENSE_PATH)) {
+    const lic = JSON.parse(readFileSync(LICENSE_PATH, 'utf8'));
+    isClientTier = Boolean(lic?.jti);
+  }
+} catch {}
+
+const CLAIM_PATTERNS = [
+  { rx: /\bset\s+([A-Z][A-Z0-9_]{2,})\s+(?:before|to|=)/g,           kind: 'env-var-set',          probe: id => `echo "$${id}"` },
+  { rx: /\bexport\s+([A-Z][A-Z0-9_]{2,})\s*=/g,                       kind: 'env-var-export',       probe: id => `printenv ${id}` },
+  { rx: /\b([A-Z][A-Z0-9_]{2,})\s+is\s+(?:set|configured|present)\b/g, kind: 'env-var-state',        probe: id => `printenv ${id}` },
+  { rx: /\byou\s+have\s+([a-zA-Z][\w-]{2,})\b/g,                       kind: 'capability-claim',     probe: id => `which ${id} || ls -la ${id}` },
+  { rx: /\bthe\s+file\s+([\w./~-]{4,})\s+(?:exists|is|contains)/g,    kind: 'file-state',           probe: id => `ls -la "${id}"` },
+  { rx: /\bdirectory\s+([\w./~-]{4,})\s+(?:exists|is|contains)/g,     kind: 'dir-state',            probe: id => `ls -ld "${id}"` },
+  { rx: /\bthe\s+pod\s+([a-z][\w-]+)\s+is\s+(?:ready|running|healthy)/gi, kind: 'pod-state',         probe: id => `kubectl get pod ${id} -o jsonpath='{.status.phase}'` },
+  { rx: /\bthe\s+deploy(?:ment)?\s+([a-z][\w-]+)\s+(?:landed|rolled|succeeded)/gi, kind: 'deploy-state', probe: id => `kubectl rollout status deployment/${id}` },
+  { rx: /\bthe\s+build\s+(?:succeeded|completed|finished)\b/gi,        kind: 'build-state',         probe: () => `tail /tmp/aria-deploy-*.log` },
+  { rx: /\b(?:version|v)\s+([\d.]+)\s+is\s+(?:published|live|deployed)/g, kind: 'version-state',     probe: id => `npm view <pkg> version  # expect ${id}` },
+  { rx: /\b(\d{2,})\s+(?:incidents|rows|records|files)\s+(?:closed|open|present)/g, kind: 'count-state', probe: id => `(query the source table)` },
+];
+
+const groundingCorpus = (() => {
+  const parts = [];
+  if (Array.isArray(event.recent_tool_results)) {
+    for (const r of event.recent_tool_results) {
+      if (typeof r === 'string') parts.push(r);
+      else if (typeof r?.output === 'string') parts.push(r.output);
+      else if (typeof r?.stdout === 'string') parts.push(r.stdout);
+    }
+  }
+  if (typeof event.transcript === 'string') parts.push(event.transcript);
+  if (typeof event.recent_transcript === 'string') parts.push(event.recent_transcript);
+  return parts.join('\n');
+})();
+
+const ungrounded = [];
+for (const { rx, kind, probe } of CLAIM_PATTERNS) {
+  rx.lastIndex = 0;
+  let m;
+  while ((m = rx.exec(draftText)) !== null) {
+    const identifier = m[1];
+    if (!identifier) continue;
+    if (!groundingCorpus.includes(identifier)) {
+      ungrounded.push({ kind, claim: m[0].slice(0, 140), identifier, suggestedProbe: probe(identifier) });
+    }
+  }
+}
+
+if (ungrounded.length === 0) {
+  audit(`pass: ${draftText.length} chars, ${CLAIM_PATTERNS.length} patterns, 0 ungrounded`);
+  process.exit(0);
+}
+
+const message = [
+  `Aria Pre-Text gate: ${ungrounded.length} state-dependent claim(s) without grounding evidence in this turn's tool results.`,
+  '',
+  'Per pre_hook_rule + feedback_implementation_coupled_cognition.md: claims about live state require probe evidence in the same turn before emission.',
+  '',
+  'Ungrounded claims (re-emit after probing):',
+  ...ungrounded.slice(0, 6).map((u, i) =>
+    `  ${i + 1}. [${u.kind}] "${u.claim}"\n     suggested probe: ${u.suggestedProbe}`,
+  ),
+  '',
+  'Either: (a) run the suggested probe and re-emit with the result included, OR',
+  '        (b) reframe the claim as a question/recommendation rather than an assertion of state.',
+];
+
+audit(`BLOCK: ${ungrounded.length} ungrounded; first=${ungrounded[0]?.kind}/${ungrounded[0]?.identifier}`);
+process.stderr.write(message.join('\n') + '\n');
+process.exit(2);