dual-brain 4.2.0 → 4.5.0

package/hooks/risk-classifier.mjs

@@ -2,9 +2,22 @@
 /**
  * risk-classifier.mjs — File-path risk classification for adaptive routing.
  *
- * Export: classifyRisk(paths) → { level, reason }
+ * Exports:
+ *   classifyRisk(paths)              → { level, reason }           (static, backward-compat)
+ *   classifyRiskEnhanced(filePath)   → { risk, basis, details }    (empirical, v4.3.0+)
+ *   getGitChurn(filePath, days?)     → { commits, isHot } | null
+ *   getFileRiskHistory(filePath)     → { total, failures, success_rate, risk_adjustment }
+ *   extractPaths(text)               → string[]
  */
 
+import { execSync } from 'child_process';
+import { existsSync, readFileSync } from 'fs';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const LEDGER_FILE = join(__dirname, 'decision-ledger.jsonl');
+
 const PATTERNS = [
   { level: 'critical', regex: /\b(auth|credential|secret|\.env|key[s]?|token[s]?|password|encrypt|certificate|cert[s]?|\.pem|\.key)\b/i, label: 'security-sensitive' },
   { level: 'high', regex: /\b(billing|payment|migration|deploy|ci[-/]cd|\.github\/workflows|security|permission|policy|schema\.prisma|schema\.sql|api[-_]?contract|openapi|swagger)\b/i, label: 'high-impact infrastructure' },
@@ -13,6 +26,7 @@ const PATTERNS = [
 ];
 
 const LEVEL_ORDER = { critical: 3, high: 2, medium: 1, low: 0 };
+const LEVEL_UP = { low: 'medium', medium: 'high', high: 'critical', critical: 'critical' };
 
 function classifyRisk(paths) {
   if (!paths || paths.length === 0) return { level: 'low', reason: 'no file paths detected' };
@@ -31,6 +45,125 @@ function classifyRisk(paths) {
   return highest;
 }
 
+/**
+ * Count how many commits touched a file in the last N days using git log.
+ * Returns { commits, isHot: commits > 10 }, or null if git is unavailable.
+ */
+function getGitChurn(filePath, days = 30) {
+  try {
+    const output = execSync(
+      `git log --oneline --since="${days} days ago" -- "${filePath}"`,
+      { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'], timeout: 5000 }
+    );
+    const commits = output.split('\n').filter(Boolean).length;
+    return { commits, isHot: commits > 10 };
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Read decision-ledger.jsonl and compute success rate for entries that
+ * touched this file path or its parent directory.
+ *
+ * Returns { total, failures, success_rate, risk_adjustment } where
+ * risk_adjustment is 'escalate' if success_rate < 60% with 3+ entries,
+ * 'normal' otherwise.
+ */
+function getFileRiskHistory(filePath) {
+  const empty = { total: 0, failures: 0, success_rate: 100, risk_adjustment: 'normal' };
+  if (!existsSync(LEDGER_FILE)) return empty;
+
+  let raw;
+  try { raw = readFileSync(LEDGER_FILE, 'utf8'); } catch { return empty; }
+
+  // Normalize the file path and compute its parent directory prefix
+  const normalizedPath = filePath.replace(/\\/g, '/');
+  const parentDir = normalizedPath.includes('/') ? normalizedPath.slice(0, normalizedPath.lastIndexOf('/')) : '';
+
+  let total = 0;
+  let failures = 0;
+
+  for (const line of raw.split('\n').filter(Boolean)) {
+    try {
+      const entry = JSON.parse(line);
+      if (entry.type !== 'outcome') continue;
+
+      const files = entry.files_changed || entry.files_read || [];
+      if (!Array.isArray(files)) continue;
+
+      const matches = files.some(f => {
+        const nf = String(f).replace(/\\/g, '/');
+        return nf === normalizedPath ||
+          nf.includes(normalizedPath) ||
+          (parentDir && nf.includes(parentDir));
+      });
+
+      if (!matches) continue;
+
+      total++;
+      if (entry.success === false) failures++;
+    } catch {}
+  }
+
+  if (total === 0) return empty;
+
+  const success_rate = Math.round(((total - failures) / total) * 100);
+  const risk_adjustment = (success_rate < 60 && total >= 3) ? 'escalate' : 'normal';
+
+  return { total, failures, success_rate, risk_adjustment };
+}
+
+/**
+ * Enhanced risk classifier that combines static patterns with empirical data.
+ *
+ * Returns { risk, basis, details } where:
+ *   risk    — 'low' | 'medium' | 'high' | 'critical'
+ *   basis   — 'static' | 'churn' | 'history' | 'churn+history'
+ *   details — { static_risk, churn_commits, history_success_rate }
+ */
+function classifyRiskEnhanced(filePath) {
+  // Step 1: static pattern classification
+  const staticResult = classifyRisk([filePath]);
+  let risk = staticResult.level;
+  const details = {
+    static_risk: risk,
+    churn_commits: null,
+    history_success_rate: null,
+  };
+
+  let bumpedByChurn = false;
+  let bumpedByHistory = false;
+
+  // Step 2: git churn check
+  const churn = getGitChurn(filePath);
+  if (churn !== null) {
+    details.churn_commits = churn.commits;
+    if (churn.isHot && risk !== 'critical') {
+      risk = LEVEL_UP[risk];
+      bumpedByChurn = true;
+    }
+  }
+
+  // Step 3: file risk history check
+  const history = getFileRiskHistory(filePath);
+  details.history_success_rate = history.success_rate;
+  if (history.risk_adjustment === 'escalate' && risk !== 'critical') {
+    risk = LEVEL_UP[risk];
+    bumpedByHistory = true;
+  }
+
+  // Cap at critical
+  if (LEVEL_ORDER[risk] > LEVEL_ORDER['critical']) risk = 'critical';
+
+  let basis = 'static';
+  if (bumpedByChurn && bumpedByHistory) basis = 'churn+history';
+  else if (bumpedByChurn) basis = 'churn';
+  else if (bumpedByHistory) basis = 'history';
+
+  return { risk, basis, details };
+}
+
 function extractPaths(text) {
   if (!text) return [];
   const matches = text.match(/(?:^|\s|["'`])([./~]?(?:[\w@.-]+\/)+[\w@.*-]+(?:\.\w+)?)/g);
@@ -38,4 +171,4 @@ function extractPaths(text) {
   return matches.map(m => m.trim().replace(/^["'`]/, ''));
 }
 
-export { classifyRisk, extractPaths };
+export { classifyRisk, classifyRiskEnhanced, getGitChurn, getFileRiskHistory, extractPaths };

package/hooks/session-report.mjs

@@ -61,56 +61,34 @@ function boxTitle(s) {
 // ---------------------------------------------------------------------------
 function padR(s, n) { s = String(s); return s.length >= n ? s.slice(0, n) : s + ' '.repeat(n - s.length); }
 function padL(s, n) { s = String(s); return s.length >= n ? s.slice(0, n) : ' '.repeat(n - s.length) + s; }
-function fmt$(n) { return '$' + n.toFixed(2); }
 
 // ---------------------------------------------------------------------------
-// Load orchestrator config
+// Load orchestrator config (used by drift section)
 // ---------------------------------------------------------------------------
 function loadConfig() {
   try { return JSON.parse(readFileSync(CONFIG_FILE, 'utf8')); } catch { return null; }
 }
 
-function buildRateMap(config) {
-  const rates = {};
-  if (!config?.subscriptions) return rates;
-  for (const provider of Object.values(config.subscriptions)) {
-    for (const [modelKey, data] of Object.entries(provider.models || {})) {
-      rates[modelKey] = {
-        tier: data.tier,
-        input_per_mtok:  data.input_per_mtok,
-        output_per_mtok: data.output_per_mtok,
-      };
-    }
-  }
-  return rates;
-}
-
 // ---------------------------------------------------------------------------
-// Token heuristics (mirrors cost-report.mjs)
+// Activity scoring (mirrors summary-checkpoint.mjs formula)
 // ---------------------------------------------------------------------------
-const TOKEN_HEURISTICS = {
-  search:  { input: 2_000,  output:   500 },
-  execute: { input: 4_000,  output: 1_500 },
-  think:   { input: 8_000,  output: 3_000 },
-};
-
-function estimateCost(tier, model, rateMap, record = {}) {
-  const heuristic = TOKEN_HEURISTICS[tier] || TOKEN_HEURISTICS.execute;
+const TIER_ACTIVITY_WEIGHTS = { search: 3, execute: 10, think: 25 };
+const SESSION_ACTIVITY_CEILING = 5_000_000;
+
+function computeActivity(tier, record = {}) {
   const hasActual = record.input_tokens != null && record.output_tokens != null;
-  const inputTok  = hasActual ? record.input_tokens  : heuristic.input;
-  const outputTok = hasActual ? record.output_tokens : heuristic.output;
-  const rate = rateMap[model] || rateMap['main-session'];
-  if (!rate) {
-    const fallbackTier = (model === 'main-session' || model === 'unknown') ? 'think' : tier;
-    const tierRate =
-      Object.values(rateMap).find(r => r.tier === fallbackTier) ||
-      Object.values(rateMap).find(r => r.tier === tier);
-    if (!tierRate) return 0;
-    return (inputTok / 1_000_000) * tierRate.input_per_mtok +
-           (outputTok / 1_000_000) * tierRate.output_per_mtok;
+  if (hasActual) {
+    return (record.input_tokens * 1) + (record.output_tokens * 3);
   }
-  return (inputTok / 1_000_000) * rate.input_per_mtok +
-         (outputTok / 1_000_000) * rate.output_per_mtok;
+  return TIER_ACTIVITY_WEIGHTS[tier] || TIER_ACTIVITY_WEIGHTS.execute;
+}
+
+function activityLabel(score) {
+  if (score <= 10) return 'minimal';
+  if (score <= 30) return 'light';
+  if (score <= 60) return 'moderate';
+  if (score <= 85) return 'heavy';
+  return 'intense';
 }
 
 // ---------------------------------------------------------------------------
@@ -153,52 +131,54 @@ function loadTodayRecords() {
 const TIER_ORDER  = ['search', 'execute', 'think'];
 const TIER_LABELS = { search: 'Search ', execute: 'Execute', think: 'Think  ' };
 
-function buildActivitySection(records, rateMap) {
+function buildActivitySection(records) {
   // Aggregate by tier — only non-recommendation records
   const activity = records.filter(r => r.type !== 'tier_recommendation');
 
   const buckets = {};
   for (const r of activity) {
     const tier  = r.tier  || 'execute';
-    const model = r.model || 'unknown';
-    if (!buckets[tier]) buckets[tier] = { calls: 0, cost: 0, actualCount: 0 };
+    if (!buckets[tier]) buckets[tier] = { calls: 0, activityRaw: 0, actualCount: 0 };
     buckets[tier].calls += 1;
-    buckets[tier].cost  += estimateCost(tier, model, rateMap, r);
+    buckets[tier].activityRaw += computeActivity(tier, r);
     if (r.input_tokens != null && r.output_tokens != null) buckets[tier].actualCount += 1;
   }
 
+  const totalRaw = Object.values(buckets).reduce((s, b) => s + b.activityRaw, 0);
+  const totalScore = Math.min(100, Math.round((totalRaw / SESSION_ACTIVITY_CEILING) * 100));
+
   const lines = [];
   lines.push(boxLine('Activity Summary'));
   lines.push(boxLine('─'.repeat(INNER)));
 
-  // Column widths: Tier(8) │ Calls(6) │ Est. Cost(10)
-  const header = padR('Tier', 8) + ' │ ' + padL('Calls', 5) + ' │ ' + padL('Est. Cost', 10);
+  // Column widths: Tier(8) │ Calls(6) │ Activity %(10)
+  const header = padR('Tier', 8) + ' │ ' + padL('Calls', 5) + ' │ ' + padL('Activity %', 10);
   const divRow = '─'.repeat(8) + '─┼─' + '─'.repeat(5) + '─┼─' + '─'.repeat(10);
   lines.push(boxLine(header));
   lines.push(boxLine(divRow));
 
   let totalCalls = 0;
-  let totalCost  = 0;
 
   for (const tier of TIER_ORDER) {
     const b = buckets[tier];
     if (!b) continue;
     const label = padR(TIER_LABELS[tier] || tier, 8);
     const calls = padL(String(b.calls), 5);
-    const cost  = padL(fmt$(b.cost), 10);
-    lines.push(boxLine(`${label} │ ${calls} │ ${cost}`));
+    const pct   = totalRaw > 0 ? Math.round((b.activityRaw / totalRaw) * 100) : 0;
+    const pctStr = padL(`${pct}%`, 10);
+    lines.push(boxLine(`${label} │ ${calls} │ ${pctStr}`));
     totalCalls += b.calls;
-    totalCost  += b.cost;
   }
 
   lines.push(boxLine(divRow));
-  lines.push(boxLine(padR('Total', 8) + ' │ ' + padL(String(totalCalls), 5) + ' │ ' + padL(fmt$(totalCost), 10)));
+  lines.push(boxLine(padR('Total', 8) + ' │ ' + padL(String(totalCalls), 5) + ' │ ' + padL(`${totalScore}/100`, 10)));
+  lines.push(boxLine(`Activity: ${totalScore}/100 (${activityLabel(totalScore)})`));
 
   if (totalCalls === 0) {
     lines.push(boxLine('  (no usage data recorded today)'));
   }
 
-  return { lines, totalCalls, totalCost, buckets };
+  return { lines, totalCalls, totalScore, buckets };
 }
 
 // ---------------------------------------------------------------------------
@@ -267,7 +247,7 @@ function buildProviderBalanceSection(records) {
 // ---------------------------------------------------------------------------
 // Section 2: Routing Compliance
 // ---------------------------------------------------------------------------
-function buildComplianceSection(records, rateMap) {
+function buildComplianceSection(records) {
   const recs = records.filter(r => r.type === 'tier_recommendation');
 
   const total     = recs.length;
@@ -276,24 +256,15 @@ function buildComplianceSection(records, rateMap) {
   const followPct = total > 0 ? Math.round((followed / total) * 100) : 0;
   const ignorePct = total > 0 ? 100 - followPct : 0;
 
-  // Overspend: for each ignored rec, diff between actual-tier cost and recommended-tier cost
-  let overspend = 0;
+  // Activity waste: diff between actual-tier weight and recommended-tier weight
+  let wastedActivity = 0;
   for (const r of recs) {
     if (r.followed === true) continue;
     if (!r.recommended_tier || !r.actual_tier) continue;
-    const recommended = TOKEN_HEURISTICS[r.recommended_tier] || TOKEN_HEURISTICS.execute;
-    const actual      = TOKEN_HEURISTICS[r.actual_tier]      || TOKEN_HEURISTICS.execute;
-
-    const recRate = Object.values(rateMap).find(x => x.tier === r.recommended_tier);
-    const actRate = Object.values(rateMap).find(x => x.tier === r.actual_tier);
-    if (!recRate || !actRate) continue;
-
-    const recCost = (recommended.input / 1_000_000) * recRate.input_per_mtok +
-                    (recommended.output / 1_000_000) * recRate.output_per_mtok;
-    const actCost = (actual.input / 1_000_000) * actRate.input_per_mtok +
-                    (actual.output / 1_000_000) * actRate.output_per_mtok;
-    const delta = actCost - recCost;
-    if (delta > 0) overspend += delta;
+    const recWeight = TIER_ACTIVITY_WEIGHTS[r.recommended_tier] || TIER_ACTIVITY_WEIGHTS.execute;
+    const actWeight = TIER_ACTIVITY_WEIGHTS[r.actual_tier] || TIER_ACTIVITY_WEIGHTS.execute;
+    const delta = actWeight - recWeight;
+    if (delta > 0) wastedActivity += delta;
   }
 
   const lines = [];
@@ -302,7 +273,7 @@ function buildComplianceSection(records, rateMap) {
   lines.push(boxLine(`Recommendations: ${total}`));
   lines.push(boxLine(`Followed:        ${followed} (${followPct}%)`));
   lines.push(boxLine(`Ignored:          ${ignored} (${ignorePct}%)`));
-  lines.push(boxLine(`Estimated overspend: ~${fmt$(overspend)}`));
+  lines.push(boxLine(`Wasted activity:  ${wastedActivity} units (from misrouted calls)`));
 
   return { lines };
 }
@@ -463,7 +434,6 @@ function buildDriftSection(config) {
 // ---------------------------------------------------------------------------
 function main() {
   const config  = loadConfig();
-  const rateMap = buildRateMap(config);
   const records = loadTodayRecords();
 
   const output = [];
@@ -473,7 +443,7 @@ function main() {
   output.push(boxDiv());
 
   // --- Section 1: Activity Summary ---
-  const { lines: actLines } = buildActivitySection(records, rateMap);
+  const { lines: actLines } = buildActivitySection(records);
   output.push(...actLines);
   output.push(boxBlank());
 
@@ -483,7 +453,7 @@ function main() {
   output.push(boxBlank());
 
   // --- Section 2: Routing Compliance ---
-  const { lines: compLines } = buildComplianceSection(records, rateMap);
+  const { lines: compLines } = buildComplianceSection(records);
   output.push(...compLines);
   output.push(boxBlank());