@aria_asi/cli 0.2.33 → 0.2.35

package/dist/runtime/hooks/aria-trigger-autolearn.mjs

@@ -0,0 +1,229 @@
+#!/usr/bin/env node
+// aria-trigger-autolearn.mjs — UserPromptSubmit hook that scans Hamza's
+// (or any user's) corrections for novel doctrine-violation patterns and
+// queues them as candidate trigger entries for doctrine_trigger_map.json.
+//
+// Doctrine: Aria enforcement #47 (drift-guard auto-learning queue) +
+// feedback_no_flag_without_fix.md + project_phase_10_endless_army_orchestration.md
+// (the harness teaches itself by absorbing corrections, not staying frozen
+// at hand-curated rules).
+//
+// Mechanics: when a user prompt contains correction/doctrine-language
+// (e.g. "don't ___", "stop ___ing", "no ___", "we said ___", "doctrine ___"),
+// the hook extracts the candidate pattern + a context window from the
+// recent assistant transcript (the offending behavior the user is correcting)
+// and appends a JSONL entry to ~/.claude/aria-trigger-queue.jsonl.
+//
+// The queue is reviewable via `cat ~/.claude/aria-trigger-queue.jsonl` or
+// (Phase 11) a future `aria triggers review` CLI subcommand. Each entry
+// carries enough context that a human can decide:
+//   1. Add to doctrine_trigger_map.json as a new trigger
+//   2. Refine an existing trigger entry's regex
+//   3. Discard (false positive — user correction wasn't a doctrine teaching)
+//
+// Hook is non-blocking: never returns decision=block. Failure modes degrade
+// to silent skip (queue file unwritable = no auto-learn, but session
+// continues). This is the ONE permitted graceful path because the hook is
+// purely additive — its absence doesn't break correctness, just slows
+// learning.
+//
+// No env-var kill-switch (Hamza 2026-04-27 — env-var disable paths gave
+// the gated process free escape; doctrine violation). Disable = remove
+// hook entry from ~/.claude/settings.json.
+
+import { appendFileSync, existsSync, mkdirSync, readFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+
+const HOME = process.env.HOME || '/tmp';
+const LOG = `${HOME}/.claude/aria-autolearn.log`;
+const QUEUE = `${HOME}/.claude/aria-trigger-queue.jsonl`;
+
+function audit(decision, summary) {
+  try {
+    if (!existsSync(dirname(LOG))) mkdirSync(dirname(LOG), { recursive: true });
+    appendFileSync(LOG, `${new Date().toISOString()} ${decision} ${summary}\n`);
+  } catch {}
+}
+
+// Kill-switch
+// Env-var kill-switch removed 2026-04-27 per Hamza directive.
+
+// Read event JSON from stdin
+let input = '';
+for await (const chunk of process.stdin) input += chunk;
+
+let event;
+try {
+  event = JSON.parse(input);
+} catch {
+  audit('skip-parse-error', 'stdin not JSON');
+  process.exit(0);
+}
+
+const userPrompt = (event.prompt ?? event.user_message ?? event.message ?? '').toString();
+const sessionId = event.session_id ?? event.sessionId ?? 'claude-code-unknown';
+const transcriptPath = event.transcript_path ?? event.transcriptPath;
+
+// Trivial prompts skip — too short to carry doctrine teaching.
+if (!userPrompt || userPrompt.length < 20) {
+  audit('skip-trivial', `chars=${userPrompt.length}`);
+  process.exit(0);
+}
+
+// Skip slash commands — they're CLI-internal, not doctrine corrections.
+if (/^\s*\//.test(userPrompt) && userPrompt.length < 200) {
+  audit('skip-slash-command', userPrompt.slice(0, 60));
+  process.exit(0);
+}
+
+// Correction-pattern detector. Each pattern below extracts a CANDIDATE
+// trigger phrase (the action/pattern the user is correcting) along with
+// the framing word ("don't", "stop", etc.). Patterns are intentionally
+// high-recall + low-precision — the queue is for human review, not
+// auto-promotion.
+//
+// Pattern groups:
+//   1. Direct prohibitions: "don't ___", "do not ___", "never ___", "stop ___"
+//   2. Doctrine assertions: "we said ___", "we don't ___", "we never ___"
+//   3. Pattern-naming: "this is ___", "that's ___", "you're ___ing"
+//   4. Doctrine vocabulary: anything containing "doctrine", "graceful", "fallback",
+//      "convenience", "shortcut", "lazy", "hack" with a 100-char neighborhood
+//   5. Frustration markers: ALL-CAPS phrases ≥3 words (anger = high-priority signal)
+const CORRECTION_PATTERNS = [
+  {
+    name: 'direct-prohibition',
+    rx: /\b(don'?t|do not|never|stop|quit|cease|enough)\s+(\w[\w\s]{4,80}?)(?=[.,!?\n]|$)/gi,
+    extractGroup: 2,
+  },
+  {
+    name: 'doctrine-assertion',
+    rx: /\b(we (?:said|don'?t|never|always|need to|don'?t use|never use)|i (?:said|told you|asked))\s+(\w[\w\s]{4,80}?)(?=[.,!?\n]|$)/gi,
+    extractGroup: 2,
+  },
+  {
+    name: 'pattern-naming',
+    rx: /\b(this is|that'?s|you'?re|you are|you keep|you'?re always)\s+(\w[\w\s]{4,80}?)(?=[.,!?\n]|$)/gi,
+    extractGroup: 2,
+  },
+  {
+    name: 'doctrine-vocab',
+    rx: /\b(doctrine|graceful|fallback|convenience|shortcut|lazy|hack|cheat|circumvent|bypass|skip|ignore|forget)[^.!?\n]{0,100}/gi,
+    extractGroup: 0,
+  },
+  {
+    name: 'frustration-allcaps',
+    rx: /\b([A-Z]{3,}\s+[A-Z]{3,}(?:\s+[A-Z]{3,})*)\b/g,
+    extractGroup: 1,
+  },
+];
+
+const candidates = [];
+for (const { name, rx, extractGroup } of CORRECTION_PATTERNS) {
+  for (const match of userPrompt.matchAll(rx)) {
+    const phrase = (match[extractGroup] || '').trim();
+    if (phrase.length < 8 || phrase.length > 200) continue;
+    candidates.push({
+      patternType: name,
+      phrase,
+      surroundingContext: match[0].slice(0, 240),
+      sourceIndex: match.index ?? 0,
+    });
+  }
+}
+
+// Deduplicate candidates that share the same first 30 chars (pattern variants
+// of the same correction).
+const seen = new Set();
+const unique = [];
+for (const c of candidates) {
+  const key = c.phrase.toLowerCase().slice(0, 30);
+  if (seen.has(key)) continue;
+  seen.add(key);
+  unique.push(c);
+}
+
+if (unique.length === 0) {
+  audit('skip-no-candidates', `chars=${userPrompt.length}`);
+  process.exit(0);
+}
+
+// Pull the most recent assistant text (last 2KB) so the queue entry shows
+// what behavior the user is correcting. Without this, "don't do X" entries
+// have no anchor to which assistant action triggered them.
+let recentAssistantContext = '';
+if (transcriptPath && existsSync(transcriptPath)) {
+  try {
+    const lines = readFileSync(transcriptPath, 'utf8').split('\n').filter(Boolean);
+    for (let i = lines.length - 1; i >= 0; i--) {
+      try {
+        const m = JSON.parse(lines[i]);
+        const role = m.message?.role ?? m.role;
+        if (role !== 'assistant') continue;
+        const content = m.message?.content ?? m.content ?? [];
+        if (!Array.isArray(content)) continue;
+        const text = content
+          .filter((b) => b?.type === 'text')
+          .map((b) => b.text || '')
+          .join('\n');
+        if (text) {
+          recentAssistantContext = text.slice(-2000);
+          break;
+        }
+      } catch {}
+    }
+  } catch {}
+}
+
+// Append candidates to the queue. Each entry is human-reviewable:
+//   - patternType: which detector caught it
+//   - candidatePhrase: the extracted phrase
+//   - userPromptExcerpt: 240 chars of context around the phrase
+//   - recentAssistantContext: what Claude did right before this correction
+//   - sessionId, ts: for traceability
+try {
+  if (!existsSync(dirname(QUEUE))) mkdirSync(dirname(QUEUE), { recursive: true });
+  for (const c of unique) {
+    const entry = {
+      ts: new Date().toISOString(),
+      sessionId,
+      patternType: c.patternType,
+      candidatePhrase: c.phrase,
+      userPromptExcerpt: c.surroundingContext,
+      recentAssistantContext: recentAssistantContext.slice(0, 1500),
+      reviewStatus: 'pending',
+      proposedTriggerRegex: phraseToCandidateRegex(c.phrase),
+      proposedMemoryFile: null,
+      proposedTeaching: null,
+    };
+    appendFileSync(QUEUE, JSON.stringify(entry) + '\n');
+  }
+  audit('queued', `count=${unique.length} types=${[...new Set(unique.map((c) => c.patternType))].join(',')}`);
+} catch (err) {
+  audit('skip-write-error', (err && err.message ? err.message : String(err)).slice(0, 200));
+}
+
+// Hook is non-blocking — UserPromptSubmit accepts no decision blocker for
+// pure side-effect hooks. Exit clean so the harness packet + preprompt
+// consult chain continues uninterrupted.
+process.exit(0);
+
+// ── Helpers ──────────────────────────────────────────────────────────────
+
+// Convert a candidate phrase into a regex skeleton for the trigger map.
+// Replaces tokens with character classes that allow minor variation (verb
+// endings, plurals, optional punctuation). Output is a SUGGESTION; human
+// reviewer refines before adding to doctrine_trigger_map.json.
+function phraseToCandidateRegex(phrase) {
+  // Lowercase + escape regex specials.
+  const lower = phrase.toLowerCase();
+  const escaped = lower.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  // Allow optional trailing 's' or 'ing' on the last word for verb forms.
+  const tokens = escaped.split(/\s+/);
+  if (tokens.length === 0) return escaped;
+  const last = tokens[tokens.length - 1];
+  // Don't bloat single-letter tokens.
+  if (last.length >= 4 && !last.endsWith('s') && !last.endsWith('ing')) {
+    tokens[tokens.length - 1] = `${last}(?:s|ing|ed)?`;
+  }
+  return tokens.join('\\s+');
+}

package/dist/runtime/hooks/aria-userprompt-abandon-detect.mjs

@@ -0,0 +1,192 @@
+#!/usr/bin/env node
+// aria-userprompt-abandon-detect.mjs — UserPromptSubmit hook that detects
+// mid-turn plan abandonment.
+//
+// When Aria's preprompt-consult issued a binding plan
+// (~/.claude/aria-active-plan-${sessionId}.json) and the user's NEXT prompt
+// changes direction without overlapping any active phase's keywords, that's
+// a CONSCIOUS OVERRIDE — not silent context loss. The hook surfaces it to
+// the session_audit table (gate_name='plan-abandonment', decision='warn')
+// so orchestrators can detect mid-execution direction changes.
+//
+// Per Aria's consult 2026-04-27: "if the orchestrator sends a plan, then
+// gets a user message that changes direction mid-execution, the binding
+// needs to surface that as a *conscious override*, not a silent context
+// loss." That gap was the third completion criterion for Aria-as-commander
+// binding (#50).
+//
+// Detection algorithm:
+//   1. Load active plan (skip if none — no plan = no abandonment possible)
+//   2. Extract keywords from each active phase's summary + successCriterion
+//   3. Tokenize incoming user prompt, drop stop-words
+//   4. Compute keyword overlap between prompt tokens and phase keywords
+//   5. If overlap < THRESHOLD (default: 1 keyword match across all phases),
+//      mark abandonment: write session_audit row + emit a brief warning
+//      injected into the next turn's context
+//
+// Non-blocking — UserPromptSubmit hooks don't block the user's prompt.
+// Audit-only surface; the orchestrator decides what to do with the warning.
+//
+// No env-var kill-switch (Hamza 2026-04-27 — env-var disable paths gave
+// the gated process free escape; doctrine violation). Disable = remove
+// hook entry from ~/.claude/settings.json.
+
+import { appendFileSync, existsSync, mkdirSync, readFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+
+const HOME = process.env.HOME || '/tmp';
+const LOG = `${HOME}/.claude/aria-abandon-detect.log`;
+
+function audit(decision, summary) {
+  try {
+    if (!existsSync(dirname(LOG))) mkdirSync(dirname(LOG), { recursive: true });
+    appendFileSync(LOG, `${new Date().toISOString()} ${decision} ${summary}\n`);
+  } catch {}
+}
+
+// Env-var kill-switch removed 2026-04-27 per Hamza directive.
+
+let input = '';
+for await (const chunk of process.stdin) input += chunk;
+
+let event;
+try {
+  event = JSON.parse(input);
+} catch {
+  audit('skip-parse-error', 'stdin not JSON');
+  process.exit(0);
+}
+
+const userPrompt = (event.prompt ?? event.user_message ?? event.message ?? '').toString();
+const sessionId = (event.session_id ?? event.sessionId ?? 'claude-code-unknown').replace(/[^a-zA-Z0-9_-]/g, '_');
+
+// Trivial prompts skip — too short to evaluate phase overlap meaningfully.
+if (!userPrompt || userPrompt.length < 30) {
+  audit('skip-trivial', `chars=${userPrompt.length}`);
+  process.exit(0);
+}
+
+// Slash commands are CLI-internal, not direction changes.
+if (/^\s*\//.test(userPrompt) && userPrompt.length < 200) {
+  audit('skip-slash-command', userPrompt.slice(0, 60));
+  process.exit(0);
+}
+
+const ACTIVE_PLAN_PATH = `${HOME}/.claude/aria-active-plan-${sessionId}.json`;
+
+if (!existsSync(ACTIVE_PLAN_PATH)) {
+  audit('skip-no-active-plan', `session=${sessionId}`);
+  process.exit(0);
+}
+
+let plan;
+try {
+  plan = JSON.parse(readFileSync(ACTIVE_PLAN_PATH, 'utf8'));
+} catch (err) {
+  audit('skip-plan-parse-error', (err?.message || String(err)).slice(0, 120));
+  process.exit(0);
+}
+
+if (!plan || !Array.isArray(plan.phases) || plan.phases.length === 0) {
+  audit('skip-empty-plan', `planId=${plan?.planId || 'unknown'}`);
+  process.exit(0);
+}
+
+// Stop-words filter — same set as the auto-learn hook for consistency.
+const STOPWORDS = new Set([
+  'the','a','an','of','to','in','at','by','for','on','with','i','is','was','are',
+  'were','this','that','as','it','and','or','but','from','into','about','have',
+  'has','had','do','does','did','will','would','could','should','can','may',
+  'might','must','shall','be','been','being','here','there','what','which','who',
+  'how','why','when','where','some','any','all','each','every','no','not',
+]);
+
+function tokenize(text) {
+  return new Set(
+    text.toLowerCase()
+      .replace(/[^a-z0-9\s_-]/g, ' ')
+      .split(/\s+/)
+      .filter((w) => w.length >= 4 && !STOPWORDS.has(w))
+  );
+}
+
+const promptTokens = tokenize(userPrompt);
+
+// Aggregate phase keywords across all phases.
+const phaseKeywordsSet = new Set();
+for (const phase of plan.phases) {
+  const summary = String(phase.summary || '');
+  const successCriterion = String(phase.successCriterion || '');
+  const id = String(phase.id || '');
+  for (const t of tokenize(`${summary} ${successCriterion} ${id}`)) {
+    phaseKeywordsSet.add(t);
+  }
+}
+
+const overlap = [...promptTokens].filter((t) => phaseKeywordsSet.has(t));
+// Threshold default raised to 2 per Aria consult 2026-04-27 — single-keyword
+// match fires too often on benign intent shifts (especially in exploratory
+// sessions); 2 filters noise while still catching genuine abandonment before
+// drift compounds.
+const OVERLAP_THRESHOLD = Number(process.env.ARIA_ABANDON_THRESHOLD || '2');
+const isAbandonment = overlap.length < OVERLAP_THRESHOLD;
+
+if (!isAbandonment) {
+  audit('aligned', `planId=${plan.planId || 'unknown'} overlap=${overlap.length} prompt-tokens=${promptTokens.size} phase-tokens=${phaseKeywordsSet.size}`);
+  process.exit(0);
+}
+
+// Abandonment detected — write session_audit row + emit warning context.
+const harnessUrl =
+  process.env.ARIA_HIVE_RUNTIME_URL ||
+  process.env.ARIA_HARNESS_BASE_URL ||
+  process.env.ARIA_HARNESS_URL ||
+  'https://harness.ariasos.com';
+const harnessToken = process.env.ARIA_HARNESS_TOKEN || '';
+
+if (harnessToken) {
+  // Fire-and-forget POST — don't block the user's turn waiting for audit
+  // write. The audit log entry below records whether the request was even
+  // attempted, so silence in this block means the audit is missing AND
+  // that fact is itself audited locally.
+  fetch(`${harnessUrl}/api/harness/audit/session`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      Authorization: `Bearer ${harnessToken}`,
+    },
+    body: JSON.stringify({
+      session_id: sessionId,
+      surface: 'claude-code-userprompt-abandon-detect',
+      gate_name: 'plan-abandonment',
+      decision: 'warn',
+      reason: `Mid-turn plan abandonment detected. Active plan ${plan.planId || 'unknown'} (${plan.phases.length} phases) has ${phaseKeywordsSet.size} aggregate phase-keywords; incoming user prompt (${promptTokens.size} content-tokens) overlaps only ${overlap.length} (threshold=${OVERLAP_THRESHOLD}).`,
+      evidence_json: {
+        planId: plan.planId,
+        promptExcerpt: userPrompt.slice(0, 400),
+        overlapTokens: overlap,
+        promptTokenCount: promptTokens.size,
+        phaseKeywordCount: phaseKeywordsSet.size,
+        phaseSummaries: plan.phases.map((p) => ({ id: p.id, summary: String(p.summary || '').slice(0, 120) })),
+        threshold: OVERLAP_THRESHOLD,
+      },
+    }),
+  }).catch(() => {/* network-level failure surfaces in audit log below */});
+}
+
+audit('abandonment-detected', `planId=${plan.planId || 'unknown'} overlap=${overlap.length}/${OVERLAP_THRESHOLD} prompt-tokens=${promptTokens.size} phase-tokens=${phaseKeywordsSet.size}`);
+
+// Inject a warning into the next turn's context so the orchestrator (Claude)
+// sees the abandonment signal explicitly rather than treating the new prompt
+// as plan-aligned. The orchestrator can decide to: (a) acknowledge the
+// override + clear the active plan, or (b) ask the user whether to continue
+// the prior plan after this excursion.
+const context = `[ARIA_PLAN_ABANDONMENT_DETECTED — active plan ${plan.planId || 'unknown'} has ${plan.phases.length} phase(s); incoming user prompt overlaps only ${overlap.length} keyword(s) with active phases (threshold=${OVERLAP_THRESHOLD}). This is a CONSCIOUS USER OVERRIDE, not silent context loss. Orchestrator should: (1) acknowledge the direction change to the user, (2) decide whether to clear the active plan or keep it for resumption, (3) write the decision to session_audit. Active phases were: ${plan.phases.map((p) => `${p.id}: ${String(p.summary || '').slice(0, 80)}`).join(' | ')}]`;
+
+console.log(JSON.stringify({
+  hookSpecificOutput: {
+    hookEventName: 'UserPromptSubmit',
+    additionalContext: context,
+  },
+}));
+process.exit(0);