gramatr 0.3.0

package/hooks/GMTRPromptEnricher.hook.ts

@@ -0,0 +1,650 @@
+#!/usr/bin/env node
+/**
+ * GMTRPromptEnricher.hook.ts — grāmatr UserPromptSubmit Hook
+ *
+ * Fires before the agent processes a user prompt. Calls the grāmatr
+ * decision router to pre-classify the request, then injects
+ * the intelligence as additionalContext so the agent sees it.
+ *
+ * TRIGGER: UserPromptSubmit
+ * TIMEOUT: 15s default (configurable via GMTR_TIMEOUT)
+ * SAFETY: Never blocks. On any error, prompt passes through unmodified.
+ *
+ * What it injects:
+ * - Effort level (instant/fast/standard/extended/advanced/deep/comprehensive)
+ * - Intent type (search, retrieve, create, update, analyze, generate)
+ * - Matched skills from 25-capability registry
+ * - Reverse engineering (explicit/implicit wants and don't-wants)
+ * - ISC scaffold (preliminary Ideal State Criteria)
+ * - Suggested capabilities
+ * - Token savings metadata
+ */
+
+import { getGitContext } from './lib/gmtr-hook-utils.ts';
+import {
+  persistClassificationResult,
+  routePrompt,
+  shouldSkipPromptRouting,
+} from '../core/routing.ts';
+import type { RouteResponse } from '../core/types.ts';
+
+// ── Types ──
+
+interface HookInput {
+  session_id: string;
+  prompt: string;
+  cwd?: string;
+  permission_mode?: string;
+  hook_event_name: string;
+  transcript_path?: string;
+}
+
+// ── Configuration ──
+
+const TIMEOUT_MS = parseInt(process.env.GMTR_TIMEOUT || '30000', 10);
+const ENABLED = process.env.GMTR_ENRICH !== '0'; // disable with GMTR_ENRICH=0
+
+// ── Project ID Resolution (Issue #76 — project-scoped memory) ──
+
+function resolveProjectId(): string | null {
+  try {
+    // Read from the context file written by session-start.sh
+    const home = process.env.HOME || process.env.USERPROFILE || '';
+    const contextPath = `${home}/.claude/current-project-context.json`;
+    const context = JSON.parse(require('fs').readFileSync(contextPath, 'utf8'));
+    const remote = context.git_remote;
+    if (!remote || remote === 'no-remote') return null;
+
+    // Normalize git remote to org/repo format
+    // Handles: https://github.com/org/repo.git, git@github.com:org/repo.git, etc.
+    const match = remote.match(/[/:]([\w.-]+)\/([\w.-]+?)(?:\.git)?$/);
+    if (match) return `${match[1]}/${match[2]}`;
+
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+const PROJECT_ID = resolveProjectId();
+
+function persistLastClassification(
+  prompt: string,
+  sessionId: string,
+  route: RouteResponse | null,
+  downstreamModel: string,
+): void {
+  try {
+    const git = getGitContext();
+    if (!git) return;
+    persistClassificationResult({
+      rootDir: git.root,
+      prompt,
+      route,
+      downstreamModel,
+      clientType: 'claude_code',
+      agentName: 'Claude Code',
+    });
+  } catch {
+    // Non-critical
+  }
+}
+
+// ── Failure Tracking ──
+
+type RouterFailure = {
+  reason: 'auth' | 'timeout' | 'server_down' | 'server_error' | 'parse_error' | 'unknown';
+  detail: string;
+};
+
+let lastFailure: RouterFailure | null = null;
+
+// ── Format Failure Warning (LOUD — never silent) ──
+
+function formatFailureWarning(failure: RouterFailure): string {
+  const lines: string[] = [];
+  lines.push('⚠️ [GMTR Intelligence — FAILED]');
+  lines.push('');
+
+  switch (failure.reason) {
+    case 'auth':
+      lines.push('🔒 AUTHENTICATION FAILURE — gramatr decision router cannot authenticate.');
+      lines.push(`Detail: ${failure.detail}`);
+      lines.push('');
+      lines.push('FIX: Set AIOS_MCP_TOKEN in your environment (same token as MCP server config)');
+      lines.push('Without this, NO pre-classification happens. The Algorithm runs without intelligence.');
+      break;
+    case 'timeout':
+      lines.push('⏱️ TIMEOUT — gramatr decision router did not respond in time.');
+      lines.push(`Detail: ${failure.detail}`);
+      lines.push('');
+      lines.push('The classifier may be overloaded or the server may be slow.');
+      break;
+    case 'server_down':
+      lines.push('🔴 SERVER UNREACHABLE — cannot connect to gramatr server.');
+      lines.push(`Detail: ${failure.detail}`);
+      lines.push('');
+      lines.push('Check: Is the server running? Is the URL correct? Is there a network issue?');
+      break;
+    case 'server_error':
+      lines.push('💥 SERVER ERROR — gramatr server returned an error.');
+      lines.push(`Detail: ${failure.detail}`);
+      break;
+    case 'parse_error':
+      lines.push('🔧 PARSE ERROR — could not understand the server response.');
+      lines.push(`Detail: ${failure.detail}`);
+      break;
+    default:
+      lines.push('❓ UNKNOWN ERROR — gramatr enrichment failed.');
+      lines.push(`Detail: ${failure.detail}`);
+  }
+
+  lines.push('');
+  lines.push('IMPORTANT: Tell the user about this error. Do not silently proceed without intelligence.');
+  lines.push('You should still follow the Algorithm from CLAUDE.md, but note that pre-classification is unavailable.');
+
+  return lines.join('\n');
+}
+
+// ── Format Intelligence Block ──
+
+function formatIntelligence(data: RouteResponse): string {
+  const c = data.classification || {};
+  const ts = data.token_savings || {};
+  const es = data.execution_summary || {};
+
+  const lines: string[] = [];
+  const serverVersion = es.server_version || '';
+  const versionTag = serverVersion ? ` v${serverVersion}` : '';
+  lines.push(`[GMTR Intelligence — pre-classified by ${es.qwen_model || 'gramatr'}]`);
+
+  // ── PROJECT STATE (Issue #80 — render FIRST so agent can't miss it) ──
+  const ps = data.project_state;
+  if (ps && ps.project_id) {
+    lines.push('');
+    lines.push('ACTIVE PROJECT STATE:');
+    if (ps.active_prd_title) {
+      lines.push(`  PRD: ${ps.active_prd_title}${ps.active_prd_id ? ` (${ps.active_prd_id})` : ''}`);
+    }
+    if (ps.current_phase) {
+      lines.push(`  Phase: ${ps.current_phase}`);
+    }
+    if (ps.isc_summary && ps.isc_summary.total && ps.isc_summary.total > 0) {
+      const s = ps.isc_summary;
+      lines.push(`  ISC: ${s.passing || 0}/${s.total} passing, ${s.failing || 0} failing, ${s.pending || 0} pending`);
+    }
+    if (ps.session_history_summary) {
+      lines.push(`  Last session: "${ps.session_history_summary}"`);
+    }
+    if (ps.current_phase && ps.current_phase !== 'OBSERVE') {
+      lines.push(`  ⚠️ RESUME from ${ps.current_phase} phase — do NOT restart OBSERVE`);
+    }
+    lines.push('');
+  }
+
+  // Core classification
+  const meta: string[] = [];
+  if (c.effort_level) meta.push(`Effort: ${c.effort_level}`);
+  if (c.intent_type) meta.push(`Intent: ${c.intent_type}`);
+  if (c.confidence) meta.push(`Confidence: ${Math.round(c.confidence * 100)}%`);
+  if (c.memory_tier) meta.push(`Memory: ${c.memory_tier}`);
+  if (meta.length) lines.push(meta.join(' | '));
+
+  // Matched skills
+  if (c.matched_skills?.length) {
+    lines.push(`Matched skills: ${c.matched_skills.join(', ')}`);
+  }
+
+  // Reverse engineering
+  const re = c.reverse_engineering;
+  if (re) {
+    if (re.explicit_wants?.length) {
+      lines.push('What user explicitly wants:');
+      for (const w of re.explicit_wants) lines.push(`  - ${w}`);
+    }
+    if (re.implicit_wants?.length) {
+      lines.push('What is implied but not stated:');
+      for (const w of re.implicit_wants) lines.push(`  - ${w}`);
+    }
+    if (re.explicit_dont_wants?.length) {
+      lines.push('What user explicitly does NOT want:');
+      for (const w of re.explicit_dont_wants) lines.push(`  - ${w}`);
+    }
+    if (re.implicit_dont_wants?.length) {
+      lines.push('What user would clearly NOT want:');
+      for (const w of re.implicit_dont_wants) lines.push(`  - ${w}`);
+    }
+    if (re.gotchas?.length) {
+      lines.push('Gotchas and edge cases:');
+      for (const g of re.gotchas) lines.push(`  - ${g}`);
+    }
+  }
+
+  // Suggested capabilities
+  if (c.suggested_capabilities?.length) {
+    lines.push(`Suggested capabilities: ${c.suggested_capabilities.join(', ')}`);
+  }
+
+  // ISC scaffold
+  if (c.isc_scaffold?.length) {
+    lines.push('ISC Scaffold (preliminary Ideal State Criteria):');
+    for (let i = 0; i < c.isc_scaffold.length; i++) {
+      lines.push(`  ${i + 1}. ${c.isc_scaffold[i]}`);
+    }
+  }
+
+  // Constraints
+  if (c.constraints_extracted?.length) {
+    lines.push(`Constraints: ${c.constraints_extracted.join('; ')}`);
+  }
+
+  // ── Layer 3: Pre-computed intelligence (Issue #79) ──
+
+  // Capability audit — pre-computed USE/DECLINE/N/A for 25 capabilities
+  const audit = data.capability_audit;
+  if (audit?.formatted_summary) {
+    lines.push('');
+    lines.push(audit.formatted_summary);
+  }
+
+  // Quality gate config — ISC validation rules as data
+  const qg = data.quality_gate_config;
+  if (qg?.rules?.length) {
+    lines.push('');
+    lines.push(`ISC Quality Gate: min ${qg.min_criteria || 4} criteria, ${qg.anti_required ? 'anti-criteria required' : 'anti-criteria optional'}, ${qg.word_range?.min || 8}-${qg.word_range?.max || 12} words each`);
+    const effortGated = qg.rules.filter(r => r.min_effort);
+    if (effortGated.length) {
+      lines.push(`  Effort-gated rules: ${effortGated.map(r => `${r.id} (${r.min_effort}+)`).join(', ')}`);
+    }
+  }
+
+  // Context pre-load plan — what entities to fetch by tier
+  const preload = data.context_pre_load_plan;
+  if (preload?.entity_types?.length) {
+    lines.push(`Context pre-load: ${preload.tier} tier → ${preload.entity_types.join(', ')}`);
+  }
+
+  // ── Behavioral Directives (from steering rules — the product value) ──
+  const directives = data.behavioral_directives;
+  if (directives?.length) {
+    lines.push('');
+    lines.push('BEHAVIORAL DIRECTIVES (from GMTR steering rules — follow these):');
+    for (const d of directives) lines.push(`  - ${d}`);
+  }
+
+  // ── Active Skill (server-delivered workflow — replaces client-side skill files) ──
+  const activeSkill = (data as any).active_skill;
+  if (activeSkill?.directives?.length) {
+    lines.push('');
+    lines.push(`ACTIVE SKILL: ${activeSkill.title || activeSkill.name} (phase: ${activeSkill.phase || 'ALL'})`);
+    for (const d of activeSkill.directives) lines.push(`  - ${d}`);
+  }
+
+  // ── Behavioral Rules (server-delivered Algorithm framework — replaces CLAUDE.md) ──
+  const rules = (data as any).behavioral_rules;
+  const effort = c.effort_level || 'standard';
+  const intent = c.intent_type || 'analyze';
+  const memoryTier = c.memory_tier || 'none';
+
+  if (rules) {
+    // Server delivered the full framework — render from packet
+    lines.push('');
+    lines.push(`ALGORITHM: ${(rules.algorithm_phases || []).join(' → ')}`);
+
+    if (rules.hard_gates) {
+      lines.push('');
+      lines.push('HARD GATES:');
+      for (const [key, value] of Object.entries(rules.hard_gates)) {
+        lines.push(`  - ${value}`);
+      }
+    }
+
+    if (rules.verification_rules?.length) {
+      lines.push('');
+      lines.push('VERIFICATION RULES:');
+      for (const r of rules.verification_rules) lines.push(`  - ${r}`);
+    }
+
+    if (rules.code_rules?.length) {
+      lines.push('');
+      lines.push('CODE RULES:');
+      for (const r of rules.code_rules) lines.push(`  - ${r}`);
+    }
+
+    if (rules.safety_rules?.length) {
+      lines.push('');
+      lines.push('SAFETY RULES:');
+      for (const r of rules.safety_rules) lines.push(`  - ${r}`);
+    }
+  }
+
+  // ── MANDATORY GATES (always present regardless of effort level) ──
+
+  // Front-load memory query mandate when memory-dependent
+  if (memoryTier !== 'none') {
+    lines.push('');
+    lines.push('═══ MANDATORY: QUERY GMTR MEMORY BEFORE ANY WORK ═══');
+    lines.push('Memory tier: ' + memoryTier + ' — You MUST call search_semantic in OBSERVE before creating ISC.');
+    lines.push('Do NOT answer from MEMORY.md alone. GMTR has the live knowledge graph.');
+  }
+
+  lines.push('');
+  lines.push('═══ MANDATORY: CREATE ISC VIA TaskCreate BEFORE ANY WORK ═══');
+  lines.push('You MUST call the TaskCreate tool for each criterion below. This creates visible tracked tasks.');
+  lines.push('NEVER write criteria as manual text/tables. ALWAYS use TaskCreate + TaskList tools.');
+  lines.push('ALWAYS prefix task subjects with "ISC-C{N}: " for criteria or "ISC-A{N}: " for anti-criteria.');
+  lines.push('The ISC prefix is REQUIRED — it signals to the user that GMTR intelligence is driving the criteria.');
+  lines.push('This is a HARD GATE — do NOT proceed to any work until TaskCreate calls are complete.');
+
+  // ── Effort-level-scaled format ──
+  if (effort === 'instant') {
+    lines.push('');
+    lines.push('FORMAT (instant effort — minimal): State, do, confirm.');
+  } else if (effort === 'fast') {
+    lines.push('');
+    lines.push('FORMAT (fast effort — compressed):');
+    lines.push('  1. "Understanding: [wants] | Avoiding: [don\'t wants]"');
+    if (c.isc_scaffold?.length) {
+      lines.push('  2. MANDATORY — call TaskCreate for each:');
+      for (let i = 0; i < c.isc_scaffold.length; i++) {
+        lines.push(`     [INVOKE TaskCreate: subject="ISC-C${i + 1}: ${c.isc_scaffold[i]}", description="Binary testable: PASS or FAIL."]`);
+      }
+      lines.push('  3. [INVOKE TaskList to display criteria to user]');
+      lines.push('  4. Do the work');
+      lines.push('  5. [INVOKE TaskList], then [INVOKE TaskUpdate] each with PASS/FAIL + evidence');
+    } else {
+      lines.push('  2. [INVOKE TaskCreate for at least 4 criteria you identify]');
+      lines.push('  3. [INVOKE TaskList to display criteria to user]');
+      lines.push('  4. Do the work');
+      lines.push('  5. [INVOKE TaskList], then [INVOKE TaskUpdate] each with PASS/FAIL + evidence');
+    }
+  } else {
+    // Standard+ — server behavioral_rules drives the framework
+    lines.push('');
+    lines.push(`FORMAT (${effort} effort — full phases)`);
+
+    // Suggested agents for the task
+    const agents = data.suggested_agents;
+    if (agents?.length) {
+      lines.push('');
+      lines.push('Suggested agents:');
+      for (const a of agents) {
+        lines.push(`  - ${a.display_name || a.name || 'agent'} (${a.model || 'default'}) — ${a.reason || ''}`);
+      }
+    }
+  }
+
+  // ── Memory Context (pre-loaded by router) ──
+  const mem = data.memory_context;
+  if (mem?.results?.length) {
+    lines.push('');
+    lines.push(`RELEVANT MEMORY (${mem.total_count} matches from GMTR knowledge graph):`);
+    for (const r of mem.results.slice(0, 5)) {
+      const sim = r.similarity ? ` (${Math.round(r.similarity * 100)}% match)` : '';
+      lines.push(`  - [${r.entity_type || 'unknown'}] ${r.entity_name || 'unnamed'}${sim}: ${(r.content || '').substring(0, 150)}`);
+    }
+  }
+
+  // ── Composed Agents (auto-composed by GMTR for this task) ──
+  const composed = data.composed_agents;
+  if (composed?.length) {
+    lines.push('');
+    lines.push('GMTR COMPOSED AGENT (specialized for this task — USE THIS):');
+    for (const ca of composed) {
+      lines.push(`  Agent: ${ca.display_name || ca.name || 'specialist'}`);
+      lines.push(`  Domain: ${ca.task_domain || 'general'} | Expertise: ${(ca.expertise_areas || []).join(', ')}`);
+      lines.push(`  Model: ${ca.model_preference || 'default'}`);
+      lines.push(`  Context: ${ca.context_summary || 'memory-aware'}`);
+      lines.push('  ACTION: Use the Task tool with subagent_type="general-purpose" and inject this system prompt:');
+      lines.push('  --- AGENT SYSTEM PROMPT START ---');
+      // Truncate to avoid overwhelming the context — full prompt available via gmtr_invoke_agent
+      const promptPreview = (ca.system_prompt || '').substring(0, 800);
+      lines.push(`  ${promptPreview}${(ca.system_prompt || '').length > 800 ? '... [truncated — use gmtr_invoke_agent for full prompt]' : ''}`);
+      lines.push('  --- AGENT SYSTEM PROMPT END ---');
+    }
+  }
+
+  // Token economics
+  const saved = ts.total_saved || ts.tokens_saved || 0;
+  if (saved > 0) {
+    lines.push(`[Token savings: ${saved.toLocaleString()} tokens saved per request (CLAUDE.md: ${(ts.claude_md_reduction || 0).toLocaleString()}, OBSERVE offload: ${(ts.observe_work_offloaded || 0).toLocaleString()})]`);
+  }
+
+  if (data.curated_context) {
+    lines.push('');
+    lines.push('CURATED CONTEXT:');
+    lines.push(data.curated_context.trim());
+  }
+
+  const diagnostics = data.packet_diagnostics;
+  if (diagnostics?.memory_context?.status === 'error' || diagnostics?.project_state?.status === 'error') {
+    lines.push('');
+    lines.push('PACKET DIAGNOSTICS:');
+    if (diagnostics.memory_context?.status === 'error') {
+      lines.push(`  - Memory pre-load degraded: ${diagnostics.memory_context.error || 'unknown error'}`);
+    }
+    if (diagnostics.project_state?.status === 'error') {
+      lines.push(`  - Project state degraded: ${diagnostics.project_state.error || 'unknown error'}`);
+    }
+  }
+
+  const degraded = data.execution_summary?.degraded_components?.filter((component) =>
+    component.startsWith('classification.')
+  ) || [];
+  if (degraded.length > 0) {
+    lines.push('');
+    lines.push('CLASSIFIER DIAGNOSTICS:');
+    for (const component of degraded) {
+      lines.push(`  - ${component.replace('classification.', '').replace(/_/g, ' ')} degraded`);
+    }
+  }
+
+  return lines.join('\n');
+}
+
+// ── Status Line (stderr) ──
+
+function emitStatus(data: RouteResponse | null, elapsed: number): void {
+  if (!data) {
+    if (lastFailure) {
+      process.stderr.write(`[gramatr] ✗ ${lastFailure.reason} (${elapsed}ms) — ${lastFailure.detail}\n`);
+    } else {
+      process.stderr.write(`[gramatr] ✗ no result (${elapsed}ms)\n`);
+    }
+    return;
+  }
+
+  const c = data.classification || {};
+  const es = data.execution_summary || {};
+  const st = es.stage_timing || {};
+  const version = es.server_version ? `v${es.server_version}` : '';
+
+  // Summary line
+  const classifier = es.qwen_model || 'unknown';
+  const confidence = c.confidence ? `${Math.round(c.confidence * 100)}%` : '';
+  process.stderr.write(
+    `[grāmatr${version ? ' ' + version : ''}] ✓ ${c.effort_level || '?'}/${c.intent_type || '?'} ${confidence} (${classifier}, ${elapsed}ms)\n`
+  );
+
+  // Per-stage breakdown if available
+  const stages: string[] = [];
+  if (st.distilbert_ms !== undefined) stages.push(`classify:${st.distilbert_ms}ms`);
+  if (st.mistral_classify_ms !== undefined) stages.push(`classify:${st.mistral_classify_ms}ms`);
+  if (st.tool_calling_ms !== undefined) stages.push(`memory:${st.tool_calling_ms}ms`);
+  if (st.reverse_engineering_ms !== undefined) stages.push(`RE:${st.reverse_engineering_ms}ms`);
+  if (st.isc_scaffold_ms !== undefined) stages.push(`ISC:${st.isc_scaffold_ms}ms`);
+  if (stages.length > 0) {
+    process.stderr.write(`[gramatr] stages: ${stages.join(' → ')}\n`);
+  }
+}
+
+// ── Main ──
+
+async function main() {
+  // Fast exit if disabled
+  if (!ENABLED) {
+    console.log(JSON.stringify({}));
+    return;
+  }
+
+  let input: HookInput;
+  try {
+    let raw = '';
+    const chunks: Buffer[] = [];
+    await new Promise<void>((resolve) => {
+      const timeout = setTimeout(() => { process.stdin.destroy(); resolve(); }, 200);
+      process.stdin.on('data', (chunk: Buffer) => chunks.push(chunk));
+      process.stdin.on('end', () => { clearTimeout(timeout); resolve(); });
+      process.stdin.on('error', () => { clearTimeout(timeout); resolve(); });
+      process.stdin.resume();
+    });
+    raw = Buffer.concat(chunks).toString('utf8');
+    if (!raw.trim()) {
+      console.log(JSON.stringify({}));
+      return;
+    }
+    input = JSON.parse(raw);
+  } catch {
+    console.log(JSON.stringify({}));
+    return;
+  }
+
+  const { prompt, session_id } = input;
+  if (!prompt) {
+    console.log(JSON.stringify({}));
+    return;
+  }
+
+  // Skip trivial prompts — not worth the server call
+  if (shouldSkipPromptRouting(prompt)) {
+    process.stderr.write(`[gramatr] enricher: trivial prompt, skipped\n`);
+    console.log(JSON.stringify({}));
+    return;
+  }
+
+  // Detect downstream LLM model from environment (#161)
+  // Claude Code exposes the model in the status line and hook input
+  const downstreamModel = process.env.ANTHROPIC_MODEL
+    || process.env.CLAUDE_MODEL
+    || (input as any).model
+    || '';
+
+  // Emit pre-call status
+  process.stderr.write(`[gramatr] classifying...\n`);
+
+  // Call the router
+  const t0 = Date.now();
+  const routed = await routePrompt({
+    prompt,
+    projectId: PROJECT_ID || undefined,
+    sessionId: session_id,
+    timeoutMs: TIMEOUT_MS,
+  });
+  const result = routed.route;
+  const elapsed = Date.now() - t0;
+
+  if (!result && routed.error) {
+    switch (routed.error.reason) {
+      case 'auth':
+        lastFailure = { reason: 'auth', detail: routed.error.detail };
+        break;
+      case 'timeout':
+        lastFailure = { reason: 'timeout', detail: routed.error.detail };
+        break;
+      case 'network_error':
+        lastFailure = { reason: 'server_down', detail: routed.error.detail };
+        break;
+      case 'http_error':
+      case 'mcp_error':
+        lastFailure = { reason: 'server_error', detail: routed.error.detail };
+        break;
+      case 'parse_error':
+        lastFailure = { reason: 'parse_error', detail: routed.error.detail };
+        break;
+      default:
+        lastFailure = { reason: 'unknown', detail: routed.error.detail };
+        break;
+    }
+  } else if (result) {
+    lastFailure = null;
+  }
+
+  // Emit status to stderr
+  emitStatus(result, elapsed);
+
+  // Persist classification savings + downstream model for statusline and feedback
+  try {
+    const ts = result?.token_savings || {};
+    const es = result?.execution_summary || {};
+    const cl = result?.classification || {};
+    const savingsEntry = {
+      tokens_saved: ts.total_saved || ts.tokens_saved || 0,
+      savings_ratio: ts.savings_ratio || 0,
+      qwen_model: es.qwen_model || null,
+      qwen_time_ms: es.qwen_time_ms || 0,
+      effort: cl.effort_level || null,
+      intent: cl.intent_type || null,
+      confidence: cl.confidence || null,
+      memory_delivered: result?.memory_context?.results?.length || 0,
+      downstream_model: downstreamModel || null,
+      server_version: es.server_version || null,
+      stage_timing: es.stage_timing || null,
+      timestamp: Date.now(),
+    };
+    // Write latest classification savings
+    const { writeFileSync, appendFileSync, readFileSync } = await import('fs');
+    writeFileSync('/tmp/gmtr-classification-savings.json', JSON.stringify(savingsEntry));
+    // Append to history for cumulative tracking
+    const historyFile = '/tmp/gmtr-op-history.jsonl';
+    if (savingsEntry.tokens_saved > 0) {
+      const historyEntry = JSON.stringify({
+        tool: 'classification',
+        model: savingsEntry.qwen_model,
+        time_ms: savingsEntry.qwen_time_ms,
+        tokens_saved: savingsEntry.tokens_saved,
+        cache_hit: false,
+        timestamp: Date.now(),
+      });
+      appendFileSync(historyFile, historyEntry + '\n');
+    }
+  } catch {
+    // Non-critical — statusline just won't show savings
+  }
+
+  persistLastClassification(prompt, session_id, result, downstreamModel);
+
+  // If no result — DO NOT silently pass through. Tell the user what's broken.
+  if (!result || !result.classification) {
+    if (lastFailure) {
+      const errorContext = formatFailureWarning(lastFailure);
+      console.log(
+        JSON.stringify({
+          hookSpecificOutput: {
+            hookEventName: 'UserPromptSubmit',
+            additionalContext: errorContext,
+          },
+        })
+      );
+    } else {
+      console.log(JSON.stringify({}));
+    }
+    return;
+  }
+
+  // Format and inject
+  const context = formatIntelligence(result);
+
+  console.log(
+    JSON.stringify({
+      hookSpecificOutput: {
+        hookEventName: 'UserPromptSubmit',
+        additionalContext: context,
+      },
+    })
+  );
+}
+
+main().catch(() => {
+  // Never crash, never block
+  console.log(JSON.stringify({}));
+});