dual-brain 3.1.0 → 3.3.0

package/hooks/profiles.mjs

@@ -0,0 +1,203 @@
+#!/usr/bin/env node
+/**
+ * profiles.mjs — Profile system for the Dual-Brain Orchestrator.
+ *
+ * Profiles configure routing posture, budget limits, and quality gate behavior.
+ * Active profile persists to .claude/dual-brain.profile.json.
+ *
+ * Exported API:
+ *   PROFILES                    → built-in profile definitions
+ *   getActiveProfile()          → current profile name + merged settings
+ *   setActiveProfile(name)      → switch profile, returns success/error
+ *   getProfileOverrides(key)    → profile-driven overrides for a specific system
+ */
+
+import { existsSync, readFileSync, renameSync, writeFileSync } from 'fs';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const PROFILE_FILE = join(__dirname, '..', 'dual-brain.profile.json');
+const CONFIG_FILE = join(__dirname, '..', 'orchestrator.json');
+
+const PROFILES = {
+  balanced: {
+    description: 'Standard routing — best model for each tier, normal budgets',
+    routing: {
+      prefer_provider: 'auto',
+      think_threshold: 'normal',
+      gpt_dispatch_bias: 0,
+    },
+    budgets: {
+      session_warn_usd: 5.00,
+      session_limit_usd: 10.00,
+      daily_warn_usd: 20.00,
+      daily_limit_usd: 50.00,
+    },
+    quality_gate: {
+      sensitivity_floor: 'medium',
+      dual_brain_minimum: 'high',
+    },
+    tier_overrides: null,
+  },
+
+  'cost-saver': {
+    description: 'Minimize spend — prefer cheaper models, skip GPT for low risk',
+    routing: {
+      prefer_provider: 'cheapest',
+      think_threshold: 'strict',
+      gpt_dispatch_bias: -20,
+    },
+    budgets: {
+      session_warn_usd: 2.00,
+      session_limit_usd: 5.00,
+      daily_warn_usd: 8.00,
+      daily_limit_usd: 20.00,
+    },
+    quality_gate: {
+      sensitivity_floor: 'high',
+      dual_brain_minimum: 'critical',
+    },
+    tier_overrides: {
+      promote_execute_to_think: false,
+      demote_think_to_execute: true,
+    },
+  },
+
+  'quality-first': {
+    description: 'Maximum quality — dual-brain for medium+, stricter reviews',
+    routing: {
+      prefer_provider: 'most-capable',
+      think_threshold: 'relaxed',
+      gpt_dispatch_bias: 10,
+    },
+    budgets: {
+      session_warn_usd: 15.00,
+      session_limit_usd: 30.00,
+      daily_warn_usd: 50.00,
+      daily_limit_usd: 100.00,
+    },
+    quality_gate: {
+      sensitivity_floor: 'low',
+      dual_brain_minimum: 'medium',
+    },
+    tier_overrides: {
+      promote_execute_to_think: true,
+      demote_think_to_execute: false,
+    },
+  },
+};
+
+function loadProfileFile() {
+  try {
+    return JSON.parse(readFileSync(PROFILE_FILE, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function loadConfig() {
+  try {
+    return JSON.parse(readFileSync(CONFIG_FILE, 'utf8'));
+  } catch {
+    return {};
+  }
+}
+
+function getActiveProfile() {
+  const saved = loadProfileFile();
+  const name = saved?.active || 'balanced';
+  const profile = PROFILES[name] || PROFILES.balanced;
+  const customOverrides = saved?.custom_overrides || {};
+
+  return {
+    name: PROFILES[name] ? name : 'balanced',
+    ...profile,
+    budgets: { ...profile.budgets, ...customOverrides.budgets },
+    routing: { ...profile.routing, ...customOverrides.routing },
+    switched_at: saved?.switched_at || null,
+  };
+}
+
+function setActiveProfile(name, customOverrides = null) {
+  if (!PROFILES[name]) {
+    return { ok: false, error: `Unknown profile: ${name}. Available: ${Object.keys(PROFILES).join(', ')}` };
+  }
+
+  const data = {
+    active: name,
+    switched_at: new Date().toISOString(),
+  };
+  if (customOverrides) data.custom_overrides = customOverrides;
+
+  try {
+    const tmp = PROFILE_FILE + '.tmp.' + process.pid;
+    writeFileSync(tmp, JSON.stringify(data, null, 2) + '\n');
+    renameSync(tmp, PROFILE_FILE);
+    return { ok: true, profile: PROFILES[name] };
+  } catch (err) {
+    return { ok: false, error: `Failed to write profile: ${err.message}` };
+  }
+}
+
+function setBudgetOverrides(sessionLimit, dailyLimit) {
+  const saved = loadProfileFile() || { active: 'balanced' };
+  saved.custom_overrides = saved.custom_overrides || {};
+  saved.custom_overrides.budgets = {};
+
+  if (sessionLimit != null) {
+    saved.custom_overrides.budgets.session_warn_usd = sessionLimit * 0.6;
+    saved.custom_overrides.budgets.session_limit_usd = sessionLimit;
+  }
+  if (dailyLimit != null) {
+    saved.custom_overrides.budgets.daily_warn_usd = dailyLimit * 0.6;
+    saved.custom_overrides.budgets.daily_limit_usd = dailyLimit;
+  }
+
+  saved.switched_at = saved.switched_at || new Date().toISOString();
+
+  try {
+    const tmp = PROFILE_FILE + '.tmp.' + process.pid;
+    writeFileSync(tmp, JSON.stringify(saved, null, 2) + '\n');
+    renameSync(tmp, PROFILE_FILE);
+    return { ok: true };
+  } catch (err) {
+    return { ok: false, error: err.message };
+  }
+}
+
+function getProfileOverrides(system) {
+  const profile = getActiveProfile();
+
+  switch (system) {
+    case 'enforce-tier':
+      return {
+        think_threshold: profile.routing.think_threshold,
+        tier_overrides: profile.tier_overrides,
+        gpt_dispatch_bias: profile.routing.gpt_dispatch_bias,
+      };
+
+    case 'budget-balancer':
+      return {
+        budgets: profile.budgets,
+        prefer_provider: profile.routing.prefer_provider,
+      };
+
+    case 'quality-gate':
+      return {
+        sensitivity_floor: profile.quality_gate.sensitivity_floor,
+        dual_brain_minimum: profile.quality_gate.dual_brain_minimum,
+      };
+
+    default:
+      return {};
+  }
+}
+
+export {
+  PROFILES,
+  getActiveProfile,
+  setActiveProfile,
+  setBudgetOverrides,
+  getProfileOverrides,
+};

package/hooks/quality-gate.mjs

@@ -23,9 +23,31 @@ import { fileURLToPath } from 'url';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const ORCHESTRATOR_CONFIG = resolve(__dirname, '..', 'orchestrator.json');
+const PROFILE_FILE = resolve(__dirname, '..', 'dual-brain.profile.json');
 const REVIEWS_DIR = resolve(__dirname, '..', 'reviews');
 const DUAL_BRAIN = resolve(__dirname, 'dual-brain-review.mjs');
 
+const RISK_LEVELS = ['low', 'medium', 'high', 'critical'];
+
+function loadProfileGateSettings() {
+  try {
+    const data = JSON.parse(readFileSync(PROFILE_FILE, 'utf8'));
+    const name = data.active || 'balanced';
+    const defaults = {
+      balanced:        { sensitivity_floor: 'medium', dual_brain_minimum: 'high' },
+      'cost-saver':    { sensitivity_floor: 'high',   dual_brain_minimum: 'critical' },
+      'quality-first': { sensitivity_floor: 'low',    dual_brain_minimum: 'medium' },
+    };
+    return defaults[name] || defaults.balanced;
+  } catch {
+    return { sensitivity_floor: 'medium', dual_brain_minimum: 'high' };
+  }
+}
+
+function riskMeetsFloor(risk, floor) {
+  return RISK_LEVELS.indexOf(risk) >= RISK_LEVELS.indexOf(floor);
+}
+
 function exit(obj) {
   process.stdout.write(JSON.stringify(obj) + '\n');
   process.exit(0);
@@ -162,14 +184,16 @@ function main() {
   // 5a. Score sensitivity BEFORE running any external review
   const sensitivity = scoreSensitivity(qualifyingFiles, config);
 
-  // 5b. Low risk — skip GPT review entirely
-  if (sensitivity.gate === 'self-check') {
+  // 5b. Apply profile-driven sensitivity floor
+  const profileGate = loadProfileGateSettings();
+  if (!riskMeetsFloor(sensitivity.risk, profileGate.sensitivity_floor)) {
     exit({
       gate: 'pass',
-      risk: 'low',
+      risk: sensitivity.risk,
       sensitivity_score: sensitivity.score,
       sensitivity_reasons: sensitivity.reasons,
-      reason: 'low sensitivity — self-check only',
+      reason: `${sensitivity.risk} risk — below profile floor (${profileGate.sensitivity_floor})`,
+      profile_floor: profileGate.sensitivity_floor,
       files: qualifyingFiles,
     });
   }
@@ -232,14 +256,18 @@ function main() {
     reviewResult.error === true ||
     !reviewResult.review;
 
+  // Profile can lower the dual-brain threshold
+  const needsDualBrain = riskMeetsFloor(sensitivity.risk, profileGate.dual_brain_minimum);
+
   let gateStatus;
-  if (sensitivity.gate === 'dual-brain-required') {
-    // Critical: always flag for dual-brain + user attention regardless of review outcome
+  if (sensitivity.gate === 'dual-brain-required' || (needsDualBrain && sensitivity.risk === 'critical')) {
     gateStatus = 'needs_dual_think';
   } else if (reviewUnavailable) {
     gateStatus = 'needs_human_review';
   } else if (reviewResult.issues_found) {
     gateStatus = 'issues_found';
+  } else if (needsDualBrain) {
+    gateStatus = 'reviewed';
   } else {
     gateStatus = sensitivity.gate === 'dual-brain-recommended' ? 'reviewed' : 'pass';
   }

package/hooks/summary-checkpoint.mjs

@@ -0,0 +1,231 @@
+#!/usr/bin/env node
+/**
+ * summary-checkpoint.mjs — Fast derived state for the hot path.
+ *
+ * Maintains a summary file (usage-summary-YYYY-MM-DD.json) that hooks
+ * can read in O(1) instead of scanning the full JSONL log.
+ *
+ * The summary is rebuilt from JSONL truth if missing or corrupt.
+ *
+ * Exported API:
+ *   readSummary(date?)           → current summary object
+ *   updateSummary(newEntry)      → incrementally update summary with one entry
+ *   rebuildSummary(date?)        → full rebuild from JSONL
+ *   getRecentPromptHashes()      → last 10min of prompt hashes (for dupe detection)
+ *   getPressureBuckets()         → provider/tier call counts for rolling window
+ *   getTokenAverages()           → moving averages of actual tokens by tier
+ */
+
+import { existsSync, readFileSync, renameSync, writeFileSync } from 'fs';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+function summaryPath(date) {
+  const d = date || new Date().toISOString().slice(0, 10);
+  return join(__dirname, `usage-summary-${d}.json`);
+}
+
+function usagePath(date) {
+  const d = date || new Date().toISOString().slice(0, 10);
+  return join(__dirname, `usage-${d}.jsonl`);
+}
+
+function emptySummary() {
+  return {
+    version: 1,
+    date: new Date().toISOString().slice(0, 10),
+    updated_at: new Date().toISOString(),
+    last_offset: 0,
+
+    totals: {
+      calls: 0,
+      cost_estimate: 0,
+      by_tier: {},
+      by_provider: {},
+      by_model: {},
+    },
+
+    pressure: {
+      claude: { think: [], execute: [], search: [] },
+      openai: { think: [], execute: [], search: [] },
+    },
+
+    recent_hashes: [],
+
+    token_averages: {},
+
+    codex_latencies: [],
+  };
+}
+
+const COST_PER_CALL = { search: 0.003, execute: 0.012, think: 0.055 };
+
+function atomicWrite(path, data) {
+  const tmp = path + '.tmp.' + process.pid;
+  writeFileSync(tmp, JSON.stringify(data, null, 2) + '\n');
+  renameSync(tmp, path);
+}
+
+function readSummary(date) {
+  const path = summaryPath(date);
+  try {
+    const data = JSON.parse(readFileSync(path, 'utf8'));
+    if (data.version === 1) return data;
+  } catch {}
+  return rebuildSummary(date);
+}
+
+function rebuildSummary(date) {
+  const d = date || new Date().toISOString().slice(0, 10);
+  const logPath = usagePath(d);
+  const summary = emptySummary();
+  summary.date = d;
+
+  if (!existsSync(logPath)) {
+    atomicWrite(summaryPath(d), summary);
+    return summary;
+  }
+
+  let raw;
+  try { raw = readFileSync(logPath, 'utf8'); } catch { return summary; }
+
+  const lines = raw.split('\n').filter(Boolean);
+  for (const line of lines) {
+    try {
+      const entry = JSON.parse(line);
+      applyEntry(summary, entry);
+    } catch {}
+  }
+
+  summary.last_offset = Buffer.byteLength(raw, 'utf8');
+  summary.updated_at = new Date().toISOString();
+  atomicWrite(summaryPath(d), summary);
+  return summary;
+}
+
+function applyEntry(summary, entry) {
+  const tier = entry.tier || 'execute';
+  const provider = entry.provider || 'claude';
+  const model = entry.model || 'unknown';
+  const cost = COST_PER_CALL[tier] || COST_PER_CALL.execute;
+
+  summary.totals.calls++;
+  summary.totals.cost_estimate += cost;
+
+  summary.totals.by_tier[tier] = (summary.totals.by_tier[tier] || 0) + 1;
+  summary.totals.by_provider[provider] = (summary.totals.by_provider[provider] || 0) + 1;
+  summary.totals.by_model[model] = (summary.totals.by_model[model] || 0) + 1;
+
+  // Pressure: store timestamps for rolling window lookups
+  const ts = entry.timestamp || new Date().toISOString();
+  if (summary.pressure[provider]?.[tier]) {
+    summary.pressure[provider][tier].push(ts);
+    // Keep only last 5 hours of timestamps to bound size
+    const cutoff = Date.now() - 5 * 60 * 60 * 1000;
+    summary.pressure[provider][tier] = summary.pressure[provider][tier].filter(
+      t => Date.parse(t) >= cutoff
+    );
+  }
+
+  // Recent prompt hashes (for duplicate detection)
+  if (entry.type === 'tier_recommendation' && entry.prompt_hash) {
+    summary.recent_hashes.push({ hash: entry.prompt_hash, ts });
+    const tenMinAgo = Date.now() - 10 * 60 * 1000;
+    summary.recent_hashes = summary.recent_hashes.filter(
+      h => Date.parse(h.ts) >= tenMinAgo
+    );
+  }
+
+  // Token moving averages
+  if (entry.input_tokens != null && entry.output_tokens != null) {
+    const key = `${provider}:${tier}`;
+    if (!summary.token_averages[key]) {
+      summary.token_averages[key] = { count: 0, avg_input: 0, avg_output: 0 };
+    }
+    const avg = summary.token_averages[key];
+    avg.count++;
+    avg.avg_input += (entry.input_tokens - avg.avg_input) / avg.count;
+    avg.avg_output += (entry.output_tokens - avg.avg_output) / avg.count;
+  }
+
+  // Codex latencies
+  if (entry.codex_startup_ms != null) {
+    summary.codex_latencies.push({
+      startup_ms: entry.codex_startup_ms,
+      total_ms: entry.codex_total_ms || null,
+      model: model,
+      ts,
+    });
+    // Keep last 50
+    if (summary.codex_latencies.length > 50) {
+      summary.codex_latencies = summary.codex_latencies.slice(-50);
+    }
+  }
+}
+
+function updateSummary(newEntry, date) {
+  const summary = readSummary(date);
+  applyEntry(summary, newEntry);
+  summary.updated_at = new Date().toISOString();
+  atomicWrite(summaryPath(date), summary);
+  return summary;
+}
+
+function getRecentPromptHashes(date) {
+  const summary = readSummary(date);
+  const tenMinAgo = Date.now() - 10 * 60 * 1000;
+  return summary.recent_hashes.filter(h => Date.parse(h.ts) >= tenMinAgo);
+}
+
+function getPressureBuckets(date) {
+  const summary = readSummary(date);
+  const cutoff = Date.now() - 5 * 60 * 60 * 1000;
+  const result = {};
+
+  for (const provider of ['claude', 'openai']) {
+    result[provider] = {};
+    for (const tier of ['think', 'execute', 'search']) {
+      const timestamps = summary.pressure[provider]?.[tier] || [];
+      result[provider][tier] = timestamps.filter(t => Date.parse(t) >= cutoff).length;
+    }
+  }
+  return result;
+}
+
+function getTokenAverages(date) {
+  const summary = readSummary(date);
+  return summary.token_averages;
+}
+
+function getAdaptiveCodexThreshold(date) {
+  const summary = readSummary(date);
+  const latencies = summary.codex_latencies || [];
+  if (latencies.length < 5) return { threshold_ms: 180_000, confidence: 'low', samples: latencies.length };
+
+  const startups = latencies.map(l => l.startup_ms).filter(Boolean).sort((a, b) => a - b);
+  if (startups.length < 3) return { threshold_ms: 180_000, confidence: 'low', samples: startups.length };
+
+  const p75idx = Math.floor(startups.length * 0.75);
+  const p75 = startups[p75idx];
+  const threshold = Math.max(90_000, p75 * 4);
+
+  return {
+    threshold_ms: Math.round(threshold),
+    p75_startup_ms: Math.round(p75),
+    confidence: startups.length >= 20 ? 'high' : 'medium',
+    samples: startups.length,
+  };
+}
+
+export {
+  readSummary,
+  updateSummary,
+  rebuildSummary,
+  getRecentPromptHashes,
+  getPressureBuckets,
+  getTokenAverages,
+  getAdaptiveCodexThreshold,
+  atomicWrite,
+};