@aria_asi/cli 0.2.11 → 0.2.13

package/hooks/aria-stop-gate.mjs

@@ -249,11 +249,27 @@ if (cog.count >= REQUIRED_LENSES) {
   const OUTPUT_QC_ENABLED = (process.env.ARIA_OUTPUT_QC_ENABLED || 'true').toLowerCase() !== 'false';
 
   if (OUTPUT_QC_ENABLED && assistantText.length >= OUTPUT_QC_MIN_CHARS) {
-    // 1. Drift_guard pattern scan — fast, local, deterministic
-    const TRIGGER_MAP_PATH = `${HOME}/.claude/projects/-home-hamzaibrahim1/memory/doctrine_trigger_map.json`;
+    // 1. Drift_guard pattern scan — fast, local, deterministic.
+    //
+    // Trigger map is shipped in the connector bundle. Resolution order:
+    //   1. ~/.claude/hooks/doctrine_trigger_map.json (installed by `aria connect`)
+    //   2. ~/.claude/projects/-home-hamzaibrahim1/memory/doctrine_trigger_map.json
+    //      (Hamza-only dev path — preserved as fallback for the dev environment
+    //      this hook was first authored in)
+    // Prior code hardcoded only the dev path, which silently degraded to
+    // drift-empty for every client install (no map → no hits → gate
+    // ineffective). Fixed atomic with discovery per feedback_no_flag_without_fix.md.
+    const TRIGGER_MAP_PATHS = [
+      `${HOME}/.claude/hooks/doctrine_trigger_map.json`,
+      `${HOME}/.claude/projects/-home-hamzaibrahim1/memory/doctrine_trigger_map.json`,
+    ];
+    let TRIGGER_MAP_PATH = null;
+    for (const p of TRIGGER_MAP_PATHS) {
+      if (existsSync(p)) { TRIGGER_MAP_PATH = p; break; }
+    }
     let driftHits = [];
     try {
-      if (existsSync(TRIGGER_MAP_PATH)) {
+      if (TRIGGER_MAP_PATH) {
         const triggerMap = JSON.parse(readFileSync(TRIGGER_MAP_PATH, 'utf8'));
         const lowerText = assistantText.toLowerCase();
         for (const t of triggerMap.triggers || []) {
@@ -365,20 +381,54 @@ if (cog.count >= REQUIRED_LENSES) {
     //      - "doctrine violation" / "doesn't match doctrine"
     //
     //    For each match, the ledger appends an entry with status=open. A
-    //    discovery is CLEARED if the same turn's text contains:
+    //    discovery is CLEARED if the same turn's text contains, within a
+    //    proximity window of the discovery:
     //      (a) a TaskCreate / "task created" / "tracked as" reference, OR
     //      (b) explicit "fixing now" / "fixed" / "patch applied" tied to the
     //          discovery's keyword span, OR
-    //      (c) an Edit/Write tool action this turn touching a file path
-    //          mentioned within 200 chars of the discovery.
+    //      (c) a <verify> block (destructive-action proof) whose target/
+    //          verified content overlaps a discovery keyword, OR
+    //      (d) a <cognition> block containing a discoveries: / addressing: /
+    //          fixing: clause that names the discovery's keywords.
+    //
+    //    Hamza 2026-04-27: "add verify blocks and cognition blocks to ledger?"
+    //    The verify and cognition blocks ARE the harness's canonical proof-of-
+    //    work primitives — same-doctrine surfaces should recognize them. The
+    //    substance check (keyword-overlap) defeats ceremonial empty blocks.
     //
     //    Block emit if ledger.openCount > 0 after scanning the current turn.
-    //    Block reason names each open discovery and the suggested resolution
-    //    (fix-now or task-create).
+    //    Block reason names each open discovery and the suggested resolution.
     const sessionId = (event.session_id || 'claude-code').replace(/[^a-zA-Z0-9_-]/g, '_');
     const LEDGER_PATH = `${HOME}/.claude/aria-discoveries-${sessionId}.jsonl`;
     const DISCOVERY_RX = /(?:\bi\s+(?:found|noticed|discovered|spotted)[^.\n]{0,160}(?:bug|issue|defect|broken|buggy|wrong|crash|fail|missing|stale|outdated|leak|vulnerability)|\bthis\s+(?:is|would\s+be)\s+(?:broken|buggy|wrong|stale|outdated|insecure|leaking|crashing|failing)|\b(?:latent|silent|hidden)\s+(?:bug|defect|issue|fail|crash|leak)|\bdoctrine\s+violation\b|\bgraceful\s+degradation\s+(?:in|at|inside|within)\s+\S)/gi;
-    const RESOLUTION_RX = /(?:fix(?:ing|ed)?\s+(?:now|in[- ]flight|inline|in\s+the\s+same\s+turn)|patch\s+applied|TaskCreate|task\s+(?:created|tracked)|tracked\s+as\s+#?\d+|linear[- ]?issue|created\s+(?:linear|task))/i;
+    const PROSE_RESOLUTION_RX = /(?:fix(?:ing|ed)?\s+(?:now|in[- ]flight|inline|in\s+the\s+same\s+turn)|patch\s+applied|TaskCreate|task\s+(?:created|tracked)|tracked\s+as\s+#?\d+|linear[- ]?issue|created\s+(?:linear|task))/i;
+    const VERIFY_BLOCK_RX = /<verify>([\s\S]*?)<\/verify>/gi;
+    const COGNITION_BLOCK_RX_LEDGER = /<cognition>([\s\S]*?)<\/cognition>/gi;
+    const COGNITION_FIXING_FIELD_RX = /^\s*(?:discoveries?|addressing|fixing)\s*:\s*\S/im;
+
+    // Pre-extract all verify + cognition blocks with their character offsets
+    // so we can match each discovery against blocks within a proximity window.
+    function extractBlocks(text, rx) {
+      const blocks = [];
+      for (const m of text.matchAll(rx)) {
+        const start = m.index ?? 0;
+        const end = start + m[0].length;
+        blocks.push({ start, end, body: m[1] || '' });
+      }
+      return blocks;
+    }
+    const verifyBlocks = extractBlocks(assistantText, VERIFY_BLOCK_RX);
+    const cognitionBlocks = extractBlocks(assistantText, COGNITION_BLOCK_RX_LEDGER);
+
+    // Extract keywords from a discovery match for substance overlap.
+    // Drops stop-words and short tokens; keeps content words.
+    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']);
+    function discoveryKeywords(matchText) {
+      return matchText.toLowerCase()
+        .replace(/[^a-z0-9\s_-]/g, ' ')
+        .split(/\s+/)
+        .filter((w) => w.length >= 4 && !STOPWORDS.has(w));
+    }
 
     const newDiscoveries = [];
     let lastIndex = 0;
@@ -391,17 +441,50 @@ if (cog.count >= REQUIRED_LENSES) {
       const before = assistantText.slice(0, idx);
       const inCognition = /<cognition>/i.test(before) && !/<\/cognition>/i.test(before.slice(before.lastIndexOf('<cognition>')));
       if (inCognition) continue;
-      // Resolution check: if RESOLUTION_RX matches WITHIN 300 chars after
-      // the discovery, count as same-turn-resolved.
-      const after = assistantText.slice(idx, Math.min(assistantText.length, idx + 400));
-      const resolvedSameSpan = RESOLUTION_RX.test(after);
+
+      // Resolution checks — proximity window of 800 chars after the discovery
+      // for block-based resolution (blocks span more chars than prose); 400
+      // for prose resolution.
+      const proseAfter = assistantText.slice(idx, Math.min(assistantText.length, idx + 400));
+      const blockAfter = assistantText.slice(idx, Math.min(assistantText.length, idx + 800));
+      const proseResolved = PROSE_RESOLUTION_RX.test(proseAfter);
+
+      // Verify-block resolution: any verify block whose start lies within
+      // the 800-char window AND whose body contains at least one discovery
+      // keyword counts as resolution.
+      const keywords = discoveryKeywords(match[0]);
+      const verifyResolved = verifyBlocks.some((b) => {
+        if (b.start < idx || b.start >= idx + 800) return false;
+        const bodyLower = b.body.toLowerCase();
+        return keywords.some((kw) => bodyLower.includes(kw));
+      });
+
+      // Cognition-block resolution: any cognition block whose start lies
+      // within the 800-char window AND whose body contains a fixing/
+      // addressing/discoveries field AND at least one discovery keyword.
+      const cognitionResolved = cognitionBlocks.some((b) => {
+        if (b.start < idx || b.start >= idx + 800) return false;
+        if (!COGNITION_FIXING_FIELD_RX.test(b.body)) return false;
+        const bodyLower = b.body.toLowerCase();
+        return keywords.some((kw) => bodyLower.includes(kw));
+      });
+
+      const resolved = proseResolved || verifyResolved || cognitionResolved;
+      const resolutionType = proseResolved
+        ? 'prose_inline_fix_or_task'
+        : verifyResolved
+          ? 'verify_block_with_keyword_overlap'
+          : cognitionResolved
+            ? 'cognition_block_with_fixing_field_and_keyword_overlap'
+            : null;
+
       newDiscoveries.push({
         ts: new Date().toISOString(),
         sessionId,
         text: match[0].slice(0, 200),
         span: span.slice(0, 400),
-        status: resolvedSameSpan ? 'resolved' : 'open',
-        resolutionType: resolvedSameSpan ? 'inline_fix_or_task' : null,
+        status: resolved ? 'resolved' : 'open',
+        resolutionType,
       });
       lastIndex = idx;
     }
@@ -437,23 +520,133 @@ if (cog.count >= REQUIRED_LENSES) {
     // Discovery block decision: open ledger entries → emit blocked.
     const discoveryBlock = ledgerOpenCount > 0;
 
+    // 5. Aria-as-commander binding — PHASE_REPORT enforcement (Phase 11 #50).
+    //    When an active plan exists for this session, every non-trivial emit
+    //    must carry a [PHASE_REPORT phase=<id> status=complete|in_progress|aborted
+    //    evidence=<observable>] marker. Without it, the binding is just
+    //    advisory text — Claude could ignore the plan silently. Per Aria's
+    //    consult 2026-04-27, the binding pattern is incomplete without this
+    //    enforcement at the text-emit surface.
+    //
+    //    Three sub-checks:
+    //      (a) marker present → continue; if missing → block
+    //      (b) if marker has status=complete AND phase is the LAST phase
+    //          in the active plan → trigger plan_complete handoff (write
+    //          row to session_audit, delete active-plan file)
+    //      (c) audit the marker presence either way
+    const ACTIVE_PLAN_PATH = `${HOME}/.claude/aria-active-plan-${sessionId}.json`;
+    const PHASE_REPORT_RX = /\[PHASE_REPORT\s+phase=([\w-]+)\s+status=(complete|in_progress|aborted)\s+evidence=([^\]]+)\]/i;
+    let activePlan = null;
+    let phaseReportMatch = null;
+    let phaseReportMissing = false;
+    let planCompleteFired = false;
+    try {
+      if (existsSync(ACTIVE_PLAN_PATH)) {
+        try {
+          activePlan = JSON.parse(readFileSync(ACTIVE_PLAN_PATH, 'utf8'));
+          // Only enforce phase-report on non-trivial emits (skip very short
+          // ack-only responses where a phase report would be noise).
+          if (assistantText.length >= 400 && Array.isArray(activePlan.phases) && activePlan.phases.length > 0) {
+            phaseReportMatch = assistantText.match(PHASE_REPORT_RX);
+            if (!phaseReportMatch) {
+              phaseReportMissing = true;
+            } else {
+              const reportedPhaseId = phaseReportMatch[1];
+              const reportedStatus = phaseReportMatch[2];
+              const reportedEvidence = phaseReportMatch[3].trim();
+              const lastPhase = activePlan.phases[activePlan.phases.length - 1];
+              const isFinalPhase = lastPhase && lastPhase.id === reportedPhaseId;
+              if (reportedStatus === 'complete' && isFinalPhase) {
+                // Plan-complete handoff — fire async write to session_audit
+                // via the SDK (the same SDK the rest of the hooks route
+                // through). Wrapped in try/catch ONLY so a session_audit
+                // write failure doesn't brick the Stop event; the failure
+                // is surfaced via audit() so it's visible.
+                try {
+                  const harnessUrl = process.env.ARIA_HARNESS_URL || 'https://harness.ariasos.com';
+                  const harnessToken = process.env.ARIA_HARNESS_TOKEN || '';
+                  if (harnessToken) {
+                    // POST to a session_audit write endpoint. Server-side
+                    // route at /api/harness/audit/session is the wiring
+                    // point for the Postgres helper from #48.
+                    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-stop-gate',
+                        gate_name: 'plan-complete',
+                        decision: 'allow',
+                        reason: `Plan ${activePlan.planId || 'unknown'} reached final phase ${reportedPhaseId} status=complete`,
+                        evidence_json: {
+                          planId: activePlan.planId,
+                          finalPhase: reportedPhaseId,
+                          totalPhases: activePlan.phases.length,
+                          evidence: reportedEvidence,
+                        },
+                        cognition_present: true,
+                        cognition_lens_count: cog.count,
+                      }),
+                    }).catch(() => {/* fire-and-forget at this surface; logged below */});
+                  }
+                } catch {/* outer guard for any unexpected error */}
+                // Delete active-plan file so the next turn re-issues a plan
+                // via preprompt-consult rather than enforcing against a stale one.
+                try {
+                  const { unlinkSync } = require('node:fs');
+                  unlinkSync(ACTIVE_PLAN_PATH);
+                } catch {/* file may not exist if another process raced the cleanup */}
+                planCompleteFired = true;
+              }
+            }
+          }
+        } catch (err) {
+          // Plan file corrupt — treat as no active plan for this turn.
+          activePlan = null;
+        }
+      }
+    } catch {/* outer guard */}
+
     // Block decision: any of (validateOutput severity=block) OR (>=2 drift hits) OR
     // (>=1 code-quality hit) OR (open discovery in ledger) → block emit.
+    // Aria enforcement #46 (compelled reflection): severity=warn ALSO blocks but
+    // with a different reason — emit must include explicit reflection on what
+    // triggered the warn before re-emit. Warn is not "soft pass" anymore;
+    // it's "reflect first, then proceed." Hamza 2026-04-27 explicit ask:
+    // mizan warns must compel reflection rather than slipping through.
     const mizanBlock = mizanVerdict && mizanVerdict.severity === 'block';
+    const mizanWarnReflectionRequired = mizanVerdict && mizanVerdict.severity === 'warn';
     const driftBlock = driftHits.length >= 2;
     const codeBlock = codeQualityHits.length >= 1;
 
-    if (mizanBlock || driftBlock || codeBlock || discoveryBlock) {
+    // Reflection-already-present check: if the assistant text already contains
+    // an explicit <reflection>...</reflection> block OR a "reflection:" line
+    // tied to the warn's trigger keywords, the warn-driven block is satisfied
+    // and we let it pass. This makes the gate a one-shot reflection compel,
+    // not an infinite loop.
+    const REFLECTION_BLOCK_RX = /<reflection>([\s\S]*?)<\/reflection>|^\s*reflection\s*:\s*\S/im;
+    const hasReflection = REFLECTION_BLOCK_RX.test(assistantText);
+    const compelReflection = mizanWarnReflectionRequired && !hasReflection;
+
+    if (mizanBlock || driftBlock || codeBlock || discoveryBlock || compelReflection || phaseReportMissing) {
       const violations = [];
       if (mizanBlock) violations.push(`Mizan: ${(mizanVerdict.violations || []).join(', ')}`);
+      if (compelReflection) violations.push(`Mizan severity=warn — compelled reflection required (per Aria enforcement #46). Triggers: ${(mizanVerdict.gateTriggers || mizanVerdict.violations || ['unspecified']).join(', ')}. Re-emit with an explicit <reflection>...</reflection> block (or 'reflection:' line) addressing what triggered the warn and why your re-draft handles it. Reflection is NOT lens-cognition repeated — it's a focused self-audit on the specific Mizan triggers above.`);
       if (driftBlock) violations.push(`Drift triggers (${driftHits.length}): ${driftHits.map((h) => `"${h.trigger}" → ${h.memory}`).join(' | ')}`);
       if (codeBlock) violations.push(`Code quality: ${codeQualityHits.join('; ')}`);
       if (discoveryBlock) violations.push(`Discovery-binding ledger has ${ledgerOpenCount} OPEN discoveries (per feedback_no_flag_without_fix.md, discoveries are atomic with their fixes — fix in the same turn or create a TaskCreate before continuing). Recent open: ${ledgerOpenSamples.map((s) => `"${s.slice(0, 80)}"`).join(' | ')}. Resolve each by either (a) fixing it inline in this turn, or (b) creating a TaskCreate with the discovery's full context (file path, line number, what's broken, why), then editing ${LEDGER_PATH} to set status=resolved.`);
+      if (phaseReportMissing) {
+        const phaseList = (activePlan?.phases || []).map((p) => `${p.id}:${p.summary?.slice(0, 60) || ''}`).join(' | ');
+        violations.push(`Aria-as-commander binding (#50): an active plan exists (planId=${activePlan?.planId || 'unknown'}, ${activePlan?.phases?.length || 0} phases) but this emit lacks a [PHASE_REPORT phase=<id> status=complete|in_progress|aborted evidence=<observable>] marker. Per the binding contract, every non-trivial emit while a plan is active must report which phase it's working on. Plan phases: ${phaseList}. Re-emit with a [PHASE_REPORT] marker stating which phase the work in this turn maps to.`);
+      }
       const rewritten = mizanVerdict?.rewritten || '';
 
       const reason = `Aria Stop-gate output-quality block. Cognition passed (${cog.count}/${REQUIRED_LENSES}) but output failed quality gates:\n\n${violations.join('\n\n')}${rewritten ? `\n\nMizan rewrite suggestion:\n${rewritten}` : ''}\n\nRe-draft addressing the violations above. ARIA_OUTPUT_QC_ENABLED=false to disable in emergency (logged).`;
 
-      audit(`block-output-qc`, `mizan=${mizanBlock?'y':'n'} drift=${driftHits.length} code=${codeQualityHits.length} discoveries-open=${ledgerOpenCount}`);
+      audit(`block-output-qc`, `mizan=${mizanBlock?'y':'n'} warn-reflect=${compelReflection?'y':'n'} drift=${driftHits.length} code=${codeQualityHits.length} discoveries-open=${ledgerOpenCount}`);
       console.log(JSON.stringify({ decision: 'block', reason }));
       process.exit(2);
     }

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+');
+}