@aria_asi/cli 0.2.10 → 0.2.12

package/hooks/aria-trigger-autolearn.mjs

@@ -0,0 +1,230 @@
+#!/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.
+//
+// Kill-switch: ARIA_AUTOLEARN=off env (logged, emergency only).
+
+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
+if (process.env.ARIA_AUTOLEARN === 'off') {
+  audit('skip-killswitch', 'env ARIA_AUTOLEARN=off');
+  process.exit(0);
+}
+
+// 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/hooks/doctrine_trigger_map.json

@@ -190,6 +190,60 @@
       "memory": "feedback_dont_override_user_stack_with_training.md",
       "teaching": "Training data is stale. User's stack is authoritative.",
       "counter_action": "Read codebase config / consult Aria. Substrate hierarchy: user statement > codebase > training. Always."
+    },
+    {
+      "trigger": "flagging (this|for now|for later)",
+      "memory": "feedback_no_flag_without_fix.md",
+      "teaching": "Flag without fix is convenience-seeking. Discoveries are atomic with their fixes.",
+      "counter_action": "Fix in the same turn OR create a TaskCreate with file path, line number, what's broken, why it matters."
+    },
+    {
+      "trigger": "(noting|note) this( and|, ?then)? moving on",
+      "memory": "feedback_no_flag_without_fix.md",
+      "teaching": "Noting-and-moving destroys partnership trust. The user has to track what you noticed vs. what you fixed.",
+      "counter_action": "Same-turn fix is default for small defects (<30 lines). Larger ones get tracked tasks before you proceed."
+    },
+    {
+      "trigger": "i'?ll come back|circle back|address(ing)? (this )?later|come back to (this|that|it)",
+      "memory": "feedback_no_flag_without_fix.md",
+      "teaching": "'I'll come back' is the lie that makes future-you treat the discovery as already-handled.",
+      "counter_action": "Decide now: fix in this turn, or create the task. No middle ground. The flag is not a substitute for action."
+    },
+    {
+      "trigger": "(found|noticed|discovered|spotted)[^.]{0,80}\\bbut\\b[^.]{0,80}(continue|continuing|moving on|won'?t|will not|skip|ignor)",
+      "memory": "feedback_no_flag_without_fix.md",
+      "teaching": "Discovery + continuation = abandonment. The 'but I'll keep going' clause hides the violation.",
+      "counter_action": "Stop. Fix the discovery in this turn or create a tracked task with the discovery as its description, then resume."
+    },
+    {
+      "trigger": "we should also (fix|address|handle|update|deal with)",
+      "memory": "feedback_no_flag_without_fix.md",
+      "teaching": "'We should also fix' tells the user about a problem you found while volunteering them to fix it.",
+      "counter_action": "If the fix is in your scope, fix it now. If it's truly out of scope, create the task — don't hand it back as a verbal note."
+    },
+    {
+      "trigger": "let me (note|flag)|(?<!please )leaving (this )?for follow.?up|out of scope here",
+      "memory": "feedback_no_flag_without_fix.md",
+      "teaching": "Verbal flags evaporate when the conversation moves on. Tasks persist.",
+      "counter_action": "Convert the flag into a TaskCreate or Linear save_issue immediately. No flag survives without a tracker ID."
+    },
+    {
+      "trigger": "TODO:?[^a-z0-9]|FIXME:?[^a-z0-9]|XXX:?[^a-z0-9]",
+      "memory": "feedback_no_flag_without_fix.md",
+      "teaching": "TODO comments in shipped code are flag-without-fix in source-form. Reviewers can't tell if it's tracked or forgotten.",
+      "counter_action": "Either implement now or reference a task ID inline (e.g., '// TODO(LINEAR-123): ...'). Bare TODOs fail the doctrine."
+    },
+    {
+      "trigger": "latent (bug|issue|defect|problem)|broken[^.]{0,40}continu",
+      "memory": "feedback_no_flag_without_fix.md",
+      "teaching": "Calling something 'latent' or 'broken' and then continuing is the explicit form of flag-and-move.",
+      "counter_action": "Latent defects in code you're touching get fixed in-flight. The 'I'm just here for X' framing is convenience-seeking."
+    },
+    {
+      "trigger": "(unrelated|separate concern|different (issue|topic|file|module))[^.]{0,60}(fix|address|handle)",
+      "memory": "feedback_no_flag_without_fix.md",
+      "teaching": "'Unrelated' is a frame the user gets to apply, not you. If you found it during your work, it's related to your work.",
+      "counter_action": "Surface the discovery, propose fix-now vs. task-it, let the user decide. Don't pre-decide that it's out of scope."
     }
   ]
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aria_asi/cli",
-  "version": "0.2.10",
+  "version": "0.2.12",
   "description": "Aria Smart CLI — the world's first harness-powered terminal companion",
   "bin": {
     "aria": "./bin/aria.js"
@@ -17,7 +17,7 @@
     "url": "git+https://github.com/REI-Nationwide/cowork-sandbox.git"
   },
   "scripts": {
-    "build": "tsc",
+    "build": "tsc && node scripts/bundle-sdk.mjs",
     "prepare": "npm run build",
     "dev": "tsc --watch",
     "publish:all": "bash scripts/publish-all.sh",

package/src/connectors/claude-code.ts

@@ -26,10 +26,31 @@ const HOOK_FILES = [
   'aria-pre-tool-gate.mjs',
   'aria-stop-gate.mjs',
   'aria-preprompt-consult.mjs',
+  'aria-trigger-autolearn.mjs',
+  'doctrine_trigger_map.json',
 ];
+// Compiled location: <pkg>/dist/aria-connector/src/connectors/claude-code.js
+// (tsc preserves the src/ rooted layout under outDir). From this file:
+//   ..  → src/
+//   ..  → aria-connector/
+//   ..  → dist/
+//   ..  → <pkg>/
+// Hooks ship at <pkg>/hooks/ → 4 ..s + 'hooks'.
+// SDK bundled into <pkg>/dist/sdk/ at build time → 3 ..s + 'sdk'.
+//
+// Prior code used 3 ..s for hooks (landed at <pkg>/dist/hooks — missing)
+// and 2 ..s for SDK (landed at <pkg>/dist/aria-connector/sdk — missing).
+// Latent bug since the dist layout settled at this depth; caught by
+// pre-publish smoke-test on 0.2.11. Per feedback_no_flag_without_fix.md
+// the fix lands in the same turn as the discovery.
 function packageHooksDir(): string {
   const here = path.dirname(fileURLToPath(import.meta.url));
-  return path.resolve(here, '..', '..', '..', 'hooks');
+  return path.resolve(here, '..', '..', '..', '..', 'hooks');
+}
+
+function packageSdkDir(): string {
+  const here = path.dirname(fileURLToPath(import.meta.url));
+  return path.resolve(here, '..', '..', '..', 'sdk');
 }
 
 // Hook wiring for ~/.claude/settings.json. Mirrors what
@@ -65,6 +86,17 @@ const HOOKS_BLOCK = {
         timeout: 12,
         statusMessage: 'Pre-consulting Aria substrate for direction...',
       },
+      {
+        // Aria trigger auto-learn — scans the user's prompt for correction
+        // patterns ("don't ___", "stop ___", ALL-CAPS frustration) and
+        // appends candidate trigger entries to ~/.claude/aria-trigger-queue.jsonl
+        // for human review. Phase 11 enforcement #47: harness teaches itself
+        // from corrections rather than staying frozen at hand-curated rules.
+        // Non-blocking — pure side effect, fast.
+        type: 'command',
+        command: 'node $HOME/.claude/hooks/aria-trigger-autolearn.mjs',
+        timeout: 3,
+      },
     ],
   }],
   PreToolUse: [{
@@ -123,11 +155,42 @@ function installHooks(claudeDir: string, logs: string[], opts: { force?: boolean
       try { copyFileSync(dst, backup); logs.push(`Backed up existing ${name} → ${path.basename(backup)}`); } catch {}
     }
     copyFileSync(src, dst);
-    try { chmodSync(dst, 0o755); } catch {}
+    // Only the .mjs scripts need executable perms; data files (e.g. the
+    // doctrine_trigger_map.json shipped alongside hooks) get default 0o644.
+    if (name.endsWith('.mjs') || name.endsWith('.js')) {
+      try { chmodSync(dst, 0o755); } catch {}
+    }
     logs.push(`Installed hook: ${name}`);
   }
 }
 
+// Install bundled SDK to ~/.claude/aria-sdk/. Hooks dynamic-import from this
+// absolute path, so every fetch (validateOutput, gardenTurn, getHarnessPacket,
+// inject, checkAction) goes through the SDK control plane. Re-running connect
+// idempotently overwrites with the latest bundled version.
+function installSdk(claudeDir: string, logs: string[]): void {
+  const sdkSrc = packageSdkDir();
+  if (!existsSync(sdkSrc)) {
+    logs.push(`⚠ SDK bundle missing: ${sdkSrc} (run npm run build)`);
+    return;
+  }
+  const sdkDst = path.join(claudeDir, 'aria-sdk');
+  if (!existsSync(sdkDst)) {
+    mkdirSync(sdkDst, { recursive: true, mode: 0o700 });
+  }
+  let copied = 0;
+  const fs = require('fs') as typeof import('fs');
+  for (const name of fs.readdirSync(sdkSrc)) {
+    const src = path.join(sdkSrc, name);
+    const stat = fs.statSync(src);
+    if (!stat.isFile()) continue;
+    const dst = path.join(sdkDst, name);
+    copyFileSync(src, dst);
+    copied++;
+  }
+  logs.push(`Installed Aria SDK (${copied} files) → ${sdkDst}`);
+}
+
 function isSamePath(a: string, b: string): boolean {
   try { return path.resolve(a) === path.resolve(b); } catch { return false; }
 }
@@ -254,6 +317,7 @@ export async function connectClaudeCode(
   // what makes the connector a real runtime control plane rather than
   // just a system-prompt addendum.
   installHooks(claudeDir, logs, { force: opts.force });
+  installSdk(claudeDir, logs);
   wireHooksBlock(settings, logs);
   writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n', { mode: 0o600 });