hail-hydra-cc 2.3.2 → 2.4.1

package/files/hooks/hydra-statusline.js

@@ -1,128 +1,131 @@
-#!/usr/bin/env node
-
-// Hydra StatusLine — persistent status bar at bottom of Claude Code
-// Receives session JSON via stdin, outputs one formatted line to stdout.
-//
-// Display format:
-//   🐉 │ Opus │ Ctx: 37% ████░░░░░░ │ $0.42 │ my-project │ ⚡ Update available
-//
-// Context bar is color-coded:
-//   Green (0-49%) → Yellow (50-79%) → Red (80%+)
-
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
-
-const cacheFile = path.join(os.homedir(), '.claude', 'cache', 'hydra-update-check.json');
-
-let input = '';
-process.stdin.on('data', (chunk) => (input += chunk));
-process.stdin.on('end', () => {
-  try {
-    const data = JSON.parse(input);
-
-    // === Model ===
-    const model = data.model?.display_name || 'Unknown';
-
-    // === Context Usage ===
-    // Use precomputed used_percentage from Claude Code (most reliable)
-    const ctxPct = Math.round(data.context_window?.used_percentage || 0);
-
-    // Build visual context bar (10 chars wide)
-    const filled = Math.round(ctxPct / 10);
-    const empty = 10 - filled;
-    const bar = '\u2588'.repeat(filled) + '\u2591'.repeat(empty);
-
-    // Color-code: Green <50%, Yellow 50-79%, Red 80%+
-    let ctxColor;
-    if (ctxPct < 50) {
-      ctxColor = '\x1b[32m'; // Green
-    } else if (ctxPct < 80) {
-      ctxColor = '\x1b[33m'; // Yellow
-    } else {
-      ctxColor = '\x1b[31m'; // Red
-    }
-    const reset = '\x1b[0m';
-    const dim = '\x1b[2m';
-
-    const ctxDisplay = `${ctxColor}Ctx: ${ctxPct}% ${bar}${reset}`;
-
-    // === Session Cost ===
-    const cost = (data.cost?.total_cost_usd || 0).toFixed(2);
-
-    // === Savings vs all-Opus baseline (cached, silent on failure) ===
-    let savingsStr = '';
-    try {
-      const tokenMath = require('./hydra-token-math');
-      const summary = tokenMath.computeSummaryCached();
-      if (summary.available && summary.savedUSD >= 0.01) {
-        savingsStr = ` \x1b[32m↓$${summary.savedUSD.toFixed(2)}\x1b[0m`;
-      }
-    } catch (e) { /* silent fallback */ }
-
-    // === Working Directory ===
-    const dirName = path.basename(data.workspace?.current_dir || data.cwd || '');
-
-    // === Update Check (read from cache) ===
-    let updateNotice = '';
-    try {
-      const cache = JSON.parse(fs.readFileSync(cacheFile, 'utf8'));
-      if (cache.update_available) {
-        updateNotice = ` \x1b[33m\u26A1 v${cache.latest} available${reset}`;
-      }
-    } catch (e) {
-      // No cache — skip update notice
-    }
-
-    // === Compose Status Line ===
-    const parts = [
-      '\x1b[32m\uD83D\uDC32\x1b[0m',         // Green dragon emoji (🐉)
-      `${dim}${model}${reset}`,                 // Dim model name
-      ctxDisplay,                               // Color-coded context bar
-      `${dim}$${cost}${reset}${savingsStr}`,   // Dim cost + green ↓savings
-      `${dim}${dirName}${reset}`,              // Dim directory
-    ];
-
-    // Append update notice if available
-    if (updateNotice) {
-      parts.push(updateNotice);
-    }
-
-    // Compaction warning — only show at 70%+ context usage
-    if (ctxPct >= 80) {
-      parts.push(`\x1b[31m\u26A0 Compacting soon!\x1b[0m`);
-    } else if (ctxPct >= 70) {
-      parts.push(`\x1b[31m\u26A0 Auto-compact at 85%\x1b[0m`);
-    }
-
-    // === Sentinel Pending Warning ===
-    // Check if code changes were made but sentinel hasn't run yet
-    let sentinelWarning = '';
-    try {
-      const sentinelDir = path.join(os.tmpdir(), 'hydra-sentinel');
-      const sessionId = data.session_id || 'unknown';
-      const sentinelFlag = path.join(sentinelDir, `${sessionId}-pending.json`);
-      const pendingData = JSON.parse(fs.readFileSync(sentinelFlag, 'utf8'));
-
-      // Only show if flag is recent (within last 10 minutes)
-      // and has files pending
-      const age = Date.now() - (pendingData.updated_at || 0);
-      if (pendingData.files?.length > 0 && age < 600000) {
-        const count = pendingData.files.length;
-        sentinelWarning = ` \x1b[31m\u26A0 Sentinel pending (${count} files)\x1b[0m`;
-      }
-    } catch (e) {
-      // No flag file — sentinel is clean or hasn't been needed
-    }
-
-    if (sentinelWarning) {
-      parts.push(sentinelWarning);
-    }
-
-    process.stdout.write(parts.join(' \u2502 '));
-
-  } catch (e) {
-    // Fallback if JSON parse fails
-    process.stdout.write('\uD83D\uDC32 Hydra');
-  }
-});
+#!/usr/bin/env node
+
+// Hydra StatusLine — persistent status bar at bottom of Claude Code
+// Receives session JSON via stdin, outputs one formatted line to stdout.
+//
+// Display format:
+//   🐉 │ Opus │ Ctx: 37% ████░░░░░░ │ $0.42 │ my-project │ ⚡ Update available
+//
+// Context bar is color-coded:
+//   Green (0-49%) → Yellow (50-79%) → Red (80%+)
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const cacheFile = path.join(os.homedir(), '.claude', 'cache', 'hydra-update-check.json');
+
+let input = '';
+process.stdin.on('data', (chunk) => (input += chunk));
+process.stdin.on('end', () => {
+  try {
+    const data = JSON.parse(input);
+
+    // === Model ===
+    const model = data.model?.display_name || 'Unknown';
+
+    // === Context Usage ===
+    // Use precomputed used_percentage from Claude Code (most reliable)
+    const ctxPct = Math.round(data.context_window?.used_percentage || 0);
+
+    // Build visual context bar (10 chars wide)
+    const filled = Math.round(ctxPct / 10);
+    const empty = 10 - filled;
+    const bar = '\u2588'.repeat(filled) + '\u2591'.repeat(empty);
+
+    // Color-code: Green <50%, Yellow 50-79%, Red 80%+
+    let ctxColor;
+    if (ctxPct < 50) {
+      ctxColor = '\x1b[32m'; // Green
+    } else if (ctxPct < 80) {
+      ctxColor = '\x1b[33m'; // Yellow
+    } else {
+      ctxColor = '\x1b[31m'; // Red
+    }
+    const reset = '\x1b[0m';
+    const dim = '\x1b[2m';
+
+    const ctxDisplay = `${ctxColor}Ctx: ${ctxPct}% ${bar}${reset}`;
+
+    // === Session Cost ===
+    const cost = (data.cost?.total_cost_usd || 0).toFixed(2);
+
+    // === Savings vs all-Opus baseline (cached, silent on failure) ===
+    let savingsStr = '';
+    try {
+      const tokenMath = require('./hydra-token-math');
+      const summary = tokenMath.computeSummaryCached();
+      if (summary.available && summary.savedUSD >= 0.01) {
+        savingsStr = ` \x1b[32m↓$${summary.savedUSD.toFixed(2)}\x1b[0m`;
+      }
+    } catch (e) { /* silent fallback */ }
+
+    // === Working Directory ===
+    const dirName = path.basename(data.workspace?.current_dir || data.cwd || '');
+
+    // === Update Check (read from cache) ===
+    let updateNotice = '';
+    try {
+      const cache = JSON.parse(fs.readFileSync(cacheFile, 'utf8'));
+      if (cache.update_available) {
+        updateNotice = ` \x1b[33m\u26A1 v${cache.latest} available${reset}`;
+      }
+    } catch (e) {
+      // No cache — skip update notice
+    }
+
+    // === Compose Status Line ===
+    const parts = [
+      '\x1b[32m\uD83D\uDC32\x1b[0m',         // Green dragon emoji (🐉)
+      `${dim}${model}${reset}`,                 // Dim model name
+      ctxDisplay,                               // Color-coded context bar
+      `${dim}$${cost}${reset}${savingsStr}`,   // Dim cost + green ↓savings
+      `${dim}${dirName}${reset}`,              // Dim directory
+    ];
+
+    // Append update notice if available
+    if (updateNotice) {
+      parts.push(updateNotice);
+    }
+
+    // Compaction warning — only show at 70%+ context usage
+    if (ctxPct >= 80) {
+      parts.push(`\x1b[31m\u26A0 Compacting soon!\x1b[0m`);
+    } else if (ctxPct >= 70) {
+      parts.push(`\x1b[31m\u26A0 Auto-compact at 85%\x1b[0m`);
+    }
+
+    // === Sentinel Indicator: 3 states (pending / clean / quiet) ===
+    try {
+      const sessionId = data.session_id || 'unknown';
+      const sentinelDir = path.join(os.tmpdir(), 'hydra-sentinel');
+      const pendingFile = path.join(sentinelDir, `${sessionId}-pending.json`);
+      const scanMarker  = path.join(sentinelDir, `${sessionId}-last-scan`);
+
+      const pendingExists = fs.existsSync(pendingFile);
+      const markerExists  = fs.existsSync(scanMarker);
+
+      if (pendingExists) {
+        const pendingData = JSON.parse(fs.readFileSync(pendingFile, 'utf8'));
+        const count = pendingData.files?.length || 0;
+        const age = Date.now() - (pendingData.updated_at || 0);
+        if (count > 0 && age < 600000) {
+          parts.push(`\x1b[33m\u26A0 Sentinel pending (${count} file${count === 1 ? '' : 's'})\x1b[0m`);
+        }
+      } else if (markerExists) {
+        const markerMs = parseInt(fs.readFileSync(scanMarker, 'utf8').trim(), 10) * 1000;
+        if (Date.now() - markerMs < 60000) {
+          parts.push(`\x1b[32m\u2705 Sentinel clean\x1b[0m`);
+        }
+      }
+    } catch (e) {
+      // No flag — silent quiet state
+    }
+
+    process.stdout.write(parts.join(' \u2502 '));
+
+  } catch (e) {
+    // Fallback if JSON parse fails
+    process.stdout.write('\uD83D\uDC32 Hydra');
+  }
+});

package/files/references/model-capabilities.md

@@ -1,164 +1,164 @@
-# Model Capabilities Reference
-
-Understanding what each model does well (and where it struggles) is key to effective routing.
-This reference helps calibrate delegation decisions.
-
-## Claude Haiku 4.5
-
-### Strengths
-- Extremely fast response times (~10× faster than Opus)
-- Very low cost per token (~5× cheaper than Opus 4.6 — $1/$5 vs $5/$25 per MTok)
-- Excellent at following clear, well-defined instructions
-- Strong at text extraction, search, and pattern matching
-- Good at generating code from templates and clear patterns
-- Reliable for mechanical tasks with unambiguous specifications
-- Great at summarization and information retrieval
-
-### Limitations
-- Weaker at multi-step reasoning chains
-- Can miss subtle bugs or edge cases in code review
-- Less reliable with complex architectural decisions
-- May produce simpler solutions when a nuanced approach is needed
-- Can struggle with ambiguous or underspecified requirements
-- Less creative in problem-solving approaches
-
-### Ideal Task Profile
-Short context, clear instructions, well-defined output, no judgment calls needed.
-
-### Auto-Accept Thresholds
-Haiku outputs qualify for auto-accept when they are raw, factual, and unambiguous:
-- **hydra-scout**: File paths, grep results, directory listings, code snippets with location markers
-- **hydra-runner**: All-pass results, clean build/lint output, git status output
-- **hydra-scribe**: Internal docstrings, inline comments, changelog entries
-- **Requires verify**: Any analysis, interpretation, or user-facing documentation
-
-### hydra-scout (Haiku 4.5) — Updated in v2.1.0
-- **Strengths**: Codebase exploration, file search, reading, AND codebase
-  map building/maintenance
-- **New capability**: Builds and incrementally updates the codebase dependency
-  map using grep-based import extraction. No external parsers required.
-- **Memory focus**: Codebase structure, key file locations, module boundaries,
-  map build history, files that failed to parse
-
-### hydra-sentinel-scan (Haiku 4.5) — Updated in v2.1.0
-- **Strengths**: Pattern matching, grep-level analysis, import tracing,
-  fast structural checks, AND map-based instant blast-radius lookups
-- **New capability**: Reads codebase map for instant dependency lookups
-  instead of grepping. Falls back to grep if map doesn't exist.
-- **Map-aware checks**: Risk-based severity, test coverage warnings,
-  env var index lookups, blast radius reporting
-- **Limitations**: Cannot understand semantic meaning of data shapes,
-  may produce false positives on complex contract changes
-- **Memory focus**: Codebase dependency graph, coupling patterns,
-  false positive history
-
----
-
-## Claude Sonnet 4.6
-
-### Strengths
-- Strong code generation across most languages and frameworks
-- Good reasoning about code structure and patterns
-- Reliable bug fixing when errors are identifiable
-- Effective code review for common issues
-- Good at test writing with understanding of business logic
-- Handles refactoring with awareness of dependencies
-- Balances speed and capability well
-
-### Limitations
-- May not catch the most subtle architectural issues
-- Less reliable than Opus for novel algorithm design
-- Can sometimes miss non-obvious security implications
-- May not fully optimize complex performance bottlenecks
-- Less effective at synthesizing large amounts of disparate information
-
-### Ideal Task Profile
-Standard software engineering tasks: implementation, testing, debugging, review. Tasks where
-the approach is established even if the specific implementation requires thought.
-
-### Auto-Accept Thresholds
-Sonnet outputs always require orchestrator review — code changes and analysis are never auto-accepted:
-- **hydra-coder**: ALWAYS verify — scan for correctness, edge cases, project pattern alignment
-- **hydra-analyst**: ALWAYS verify — validate reasoning, check suggested fix against actual code
-
-### hydra-sentinel (Sonnet 4.6)
-- **Strengths**: Semantic understanding of data flow, contract validation
-  across component boundaries, accurate false positive filtering,
-  specific fix suggestions
-- **Limitations**: Slower and more expensive — only triggered when needed
-- **Memory focus**: API patterns, architectural boundaries, historical
-  breakage patterns, component communication flows
-
----
-
-## Claude Opus 4.6
-
-### Strengths
-- Deepest reasoning and analysis capability
-- Best at novel problem-solving and architecture design
-- Most reliable for subtle bug detection
-- Strongest at synthesizing complex, multi-source information
-- Best judgment on ambiguous tradeoffs
-- Most creative in approach selection
-- Highest accuracy on edge cases
-
-### Limitations
-- Slowest response time
-- Highest cost per token
-- Overkill for routine tasks (same quality as Sonnet on standard work)
-
-### Ideal Task Profile
-Hard problems: architecture design, subtle debugging, complex tradeoffs, novel implementations,
-security analysis, anything where getting it wrong is costly.
-
-### Auto-Accept Thresholds
-N/A — Opus is the orchestrator, not a delegated head. Opus output goes directly to the user.
-
----
-
-## Cost and Speed Comparison (February 2026 Pricing)
-
-| Model | Input Cost | Output Cost | Relative Speed | Input Cost vs Opus 4.6 | Output Cost vs Opus 4.6 |
-|-------|-----------|-------------|----------------|----------------------|------------------------|
-| Haiku 4.5 | $1 / MTok | $5 / MTok | ~10× faster | 5× cheaper | 5× cheaper |
-| Sonnet 4.6 | $3 / MTok | $15 / MTok | ~3× faster | ~1.7× cheaper | ~1.7× cheaper |
-| Opus 4.6 | $5 / MTok | $25 / MTok | 1× (baseline) | 1× (baseline) | 1× (baseline) |
-
-Source: https://platform.claude.com/docs/en/about-claude/pricing
-
-### Blended Cost with Hydra (typical 50/30/20 task split)
-
-| Metric | All Opus 4.6 | With Hydra | Savings |
-|--------|-------------|------------|---------|
-| Input cost / MTok | $5.00 | $2.40 | 52% |
-| Output cost / MTok | $25.00 | $12.00 | 52% |
-| Blended effective cost | $30.00 / MTok | $14.40 / MTok | ~50% |
-
-Note: Savings calculated against Opus 4.6 pricing ($5/$25 per MTok) as of February 2026.
-Savings would be significantly higher when compared to Opus 4.1/4.0 pricing ($15/$75 per MTok).
-
-These are approximate ratios. The key insight: for 60-70% of coding tasks, Haiku 4.5 or
-Sonnet 4.6 produces output identical in quality to what Opus 4.6 would produce, but
-dramatically faster and cheaper. The skill is in identifying the 30-40% where Opus 4.6
-is genuinely needed.
-
----
-
-## Acceptance Rate Expectations
-
-Drawing from speculative decoding theory, track these metrics mentally:
-
-| Draft Model | Expected Acceptance Rate | Notes |
-|-------------|------------------------|-------|
-| Haiku → Opus verification | ~85-90% | For well-classified Tier 1 tasks |
-| Sonnet → Opus verification | ~90-95% | For well-classified Tier 2 tasks |
-| sentinel-scan → sentinel escalation | ~20% | ~80%+ of scans return clean — only ~20% escalate to deep analysis |
-| sentinel → Opus verification | ~95% | Sonnet's deep analysis is highly accurate; Opus rarely overrides |
-
-If your acceptance rate drops below 80%, you're likely misclassifying tasks — shift borderline
-tasks to a higher tier. If it's consistently above 95%, you might be too conservative.
-
-The analogy to speculative decoding is direct: just as the paper found acceptance rates of
-~0.7-0.9 for draft tokens depending on domain, our task-level acceptance rates should be
-similar or better, since we have more context for classification than a draft model has for
-next-token prediction.
+# Model Capabilities Reference
+
+Understanding what each model does well (and where it struggles) is key to effective routing.
+This reference helps calibrate delegation decisions.
+
+## Claude Haiku 4.5
+
+### Strengths
+- Extremely fast response times (~10× faster than Opus)
+- Very low cost per token (~5× cheaper than Opus 4.6 — $1/$5 vs $5/$25 per MTok)
+- Excellent at following clear, well-defined instructions
+- Strong at text extraction, search, and pattern matching
+- Good at generating code from templates and clear patterns
+- Reliable for mechanical tasks with unambiguous specifications
+- Great at summarization and information retrieval
+
+### Limitations
+- Weaker at multi-step reasoning chains
+- Can miss subtle bugs or edge cases in code review
+- Less reliable with complex architectural decisions
+- May produce simpler solutions when a nuanced approach is needed
+- Can struggle with ambiguous or underspecified requirements
+- Less creative in problem-solving approaches
+
+### Ideal Task Profile
+Short context, clear instructions, well-defined output, no judgment calls needed.
+
+### Auto-Accept Thresholds
+Haiku outputs qualify for auto-accept when they are raw, factual, and unambiguous:
+- **hydra-scout**: File paths, grep results, directory listings, code snippets with location markers
+- **hydra-runner**: All-pass results, clean build/lint output, git status output
+- **hydra-scribe**: Internal docstrings, inline comments, changelog entries
+- **Requires verify**: Any analysis, interpretation, or user-facing documentation
+
+### hydra-scout (Haiku 4.5) — Updated in v2.1.0
+- **Strengths**: Codebase exploration, file search, reading, AND codebase
+  map building/maintenance
+- **New capability**: Builds and incrementally updates the codebase dependency
+  map using grep-based import extraction. No external parsers required.
+- **Memory focus**: Codebase structure, key file locations, module boundaries,
+  map build history, files that failed to parse
+
+### hydra-sentinel-scan (Haiku 4.5) — Updated in v2.1.0
+- **Strengths**: Pattern matching, grep-level analysis, import tracing,
+  fast structural checks, AND map-based instant blast-radius lookups
+- **New capability**: Reads codebase map for instant dependency lookups
+  instead of grepping. Falls back to grep if map doesn't exist.
+- **Map-aware checks**: Risk-based severity, test coverage warnings,
+  env var index lookups, blast radius reporting
+- **Limitations**: Cannot understand semantic meaning of data shapes,
+  may produce false positives on complex contract changes
+- **Memory focus**: Codebase dependency graph, coupling patterns,
+  false positive history
+
+---
+
+## Claude Sonnet 4.6
+
+### Strengths
+- Strong code generation across most languages and frameworks
+- Good reasoning about code structure and patterns
+- Reliable bug fixing when errors are identifiable
+- Effective code review for common issues
+- Good at test writing with understanding of business logic
+- Handles refactoring with awareness of dependencies
+- Balances speed and capability well
+
+### Limitations
+- May not catch the most subtle architectural issues
+- Less reliable than Opus for novel algorithm design
+- Can sometimes miss non-obvious security implications
+- May not fully optimize complex performance bottlenecks
+- Less effective at synthesizing large amounts of disparate information
+
+### Ideal Task Profile
+Standard software engineering tasks: implementation, testing, debugging, review. Tasks where
+the approach is established even if the specific implementation requires thought.
+
+### Auto-Accept Thresholds
+Sonnet outputs always require orchestrator review — code changes and analysis are never auto-accepted:
+- **hydra-coder**: ALWAYS verify — scan for correctness, edge cases, project pattern alignment
+- **hydra-analyst**: ALWAYS verify — validate reasoning, check suggested fix against actual code
+
+### hydra-sentinel (Sonnet 4.6)
+- **Strengths**: Semantic understanding of data flow, contract validation
+  across component boundaries, accurate false positive filtering,
+  specific fix suggestions
+- **Limitations**: Slower and more expensive — only triggered when needed
+- **Memory focus**: API patterns, architectural boundaries, historical
+  breakage patterns, component communication flows
+
+---
+
+## Claude Opus 4.6
+
+### Strengths
+- Deepest reasoning and analysis capability
+- Best at novel problem-solving and architecture design
+- Most reliable for subtle bug detection
+- Strongest at synthesizing complex, multi-source information
+- Best judgment on ambiguous tradeoffs
+- Most creative in approach selection
+- Highest accuracy on edge cases
+
+### Limitations
+- Slowest response time
+- Highest cost per token
+- Overkill for routine tasks (same quality as Sonnet on standard work)
+
+### Ideal Task Profile
+Hard problems: architecture design, subtle debugging, complex tradeoffs, novel implementations,
+security analysis, anything where getting it wrong is costly.
+
+### Auto-Accept Thresholds
+N/A — Opus is the orchestrator, not a delegated head. Opus output goes directly to the user.
+
+---
+
+## Cost and Speed Comparison (February 2026 Pricing)
+
+| Model | Input Cost | Output Cost | Relative Speed | Input Cost vs Opus 4.6 | Output Cost vs Opus 4.6 |
+|-------|-----------|-------------|----------------|----------------------|------------------------|
+| Haiku 4.5 | $1 / MTok | $5 / MTok | ~10× faster | 5× cheaper | 5× cheaper |
+| Sonnet 4.6 | $3 / MTok | $15 / MTok | ~3× faster | ~1.7× cheaper | ~1.7× cheaper |
+| Opus 4.6 | $5 / MTok | $25 / MTok | 1× (baseline) | 1× (baseline) | 1× (baseline) |
+
+Source: https://platform.claude.com/docs/en/about-claude/pricing
+
+### Blended Cost with Hydra (typical 50/30/20 task split)
+
+| Metric | All Opus 4.6 | With Hydra | Savings |
+|--------|-------------|------------|---------|
+| Input cost / MTok | $5.00 | $2.40 | 52% |
+| Output cost / MTok | $25.00 | $12.00 | 52% |
+| Blended effective cost | $30.00 / MTok | $14.40 / MTok | ~50% |
+
+Note: Savings calculated against Opus 4.6 pricing ($5/$25 per MTok) as of February 2026.
+Savings would be significantly higher when compared to Opus 4.1/4.0 pricing ($15/$75 per MTok).
+
+These are approximate ratios. The key insight: for 60-70% of coding tasks, Haiku 4.5 or
+Sonnet 4.6 produces output identical in quality to what Opus 4.6 would produce, but
+dramatically faster and cheaper. The skill is in identifying the 30-40% where Opus 4.6
+is genuinely needed.
+
+---
+
+## Acceptance Rate Expectations
+
+Drawing from speculative decoding theory, track these metrics mentally:
+
+| Draft Model | Expected Acceptance Rate | Notes |
+|-------------|------------------------|-------|
+| Haiku → Opus verification | ~85-90% | For well-classified Tier 1 tasks |
+| Sonnet → Opus verification | ~90-95% | For well-classified Tier 2 tasks |
+| sentinel-scan → sentinel escalation | ~20% | ~80%+ of scans return clean — only ~20% escalate to deep analysis |
+| sentinel → Opus verification | ~95% | Sonnet's deep analysis is highly accurate; Opus rarely overrides |
+
+If your acceptance rate drops below 80%, you're likely misclassifying tasks — shift borderline
+tasks to a higher tier. If it's consistently above 95%, you might be too conservative.
+
+The analogy to speculative decoding is direct: just as the paper found acceptance rates of
+~0.7-0.9 for draft tokens depending on domain, our task-level acceptance rates should be
+similar or better, since we have more context for classification than a draft model has for
+next-token prediction.