dual-brain 0.1.0

package/hooks/cost-logger.mjs

@@ -0,0 +1,286 @@
+#!/usr/bin/env node
+/**
+ * cost-logger.mjs — PostToolUse hook for the Dual-Brain orchestrator.
+ *
+ * Reads a Claude Code PostToolUse JSON payload from stdin, classifies the
+ * call by tier, then appends one line to usage.jsonl.
+ *
+ * Output contract: must print "{}" to stdout and exit 0 within ~100 ms.
+ */
+
+import { appendFileSync, mkdirSync, readFileSync, 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');
+
+function usageFile(date) {
+  const d = date || new Date().toISOString().slice(0, 10);
+  return join(__dirname, `usage-${d}.jsonl`);
+}
+
+mkdirSync(__dirname, { recursive: true });
+
+function loadActiveProfile() {
+  try {
+    const data = JSON.parse(readFileSync(PROFILE_FILE, 'utf8'));
+    return data.active || 'auto';
+  } catch { return 'auto'; }
+}
+
+const SESSION_ID = process.env.CLAUDE_SESSION_ID || process.ppid?.toString() || null;
+
+// ---------------------------------------------------------------------------
+// Tier classification
+// ---------------------------------------------------------------------------
+
+/**
+ * Tools that are pure read-only lookups → "search" tier.
+ * Everything else defaults to "execute"; "think" is only detected when an
+ * Agent sub-agent call carries a model hint in its parameters.
+ */
+const SEARCH_TOOLS = new Set([
+  "Read",
+  "Glob",
+  "Grep",
+  "LS",
+  "WebSearch",
+  "WebFetch",
+  "mcp__github__search_repositories",
+  "mcp__github__get_file_contents",
+  "mcp__github__list_commits",
+  "mcp__github__list_issues",
+  "mcp__github__list_pull_requests",
+  "mcp__github__search_code",
+]);
+
+const THINK_TOOLS = new Set([
+  "TodoWrite",   // planning artefact
+  "WebFetch",    // sometimes used for deep research; included in both sets so
+                 // the model param check below can upgrade it
+]);
+
+/** Map a Claude model string → canonical tier name */
+function modelToTier(model) {
+  if (!model) return null;
+  const m = String(model).toLowerCase();
+  if (m.includes("opus")) return "think";
+  if (m.includes("sonnet")) return "execute";
+  if (m.includes("haiku")) return "search";
+  if (m.includes("gpt-5.5") || m.includes("gpt4.5")) return "think";
+  if (m.includes("mini")) return "search";
+  if (m.includes("gpt-5.4") || m.includes("gpt-4.1")) return "execute";
+  return null;
+}
+
+/** Detect the provider from a model name */
+function detectProvider(model) {
+  if (!model || model === 'main-session') return 'claude';
+  const m = String(model).toLowerCase();
+  if (m.includes('gpt') || m.includes('o1') || m.includes('o3') || m.includes('o4')) return 'openai';
+  if (m.includes('opus') || m.includes('sonnet') || m.includes('haiku') || m.includes('claude')) return 'claude';
+  return 'claude'; // default to claude since we're in Claude Code
+}
+
+/** Extract canonical model name from an arbitrary model string */
+function canonicalModel(model) {
+  if (!model) return "main-session";
+  const m = String(model).toLowerCase();
+  if (m.includes("opus")) return "opus";
+  if (m.includes("sonnet")) return "sonnet";
+  if (m.includes("haiku")) return "haiku";
+  if (m.includes("gpt-5.5")) return "gpt-5.5";
+  if (m.includes("gpt-5.4")) return "gpt-5.4";
+  if (m.includes("gpt-4.1-mini") || m.includes("mini")) return "gpt-4.1-mini";
+  return model;
+}
+
+/**
+ * Classify a tool call into { tier, model }.
+ *
+ * @param {string} toolName
+ * @param {object} toolInput  — raw input parameters from the hook payload
+ * @param {string|null} agentModel — model hint from the outer agent context
+ */
+function classify(toolName, toolInput = {}, agentModel = null) {
+  // 1. If there's an explicit model hint in the input params (sub-agent call),
+  //    let it drive the tier.
+  const inputModel =
+    toolInput?.model ||
+    toolInput?.Model ||
+    toolInput?.modelId ||
+    null;
+
+  const effectiveModel = inputModel || agentModel;
+  const tierFromModel = modelToTier(effectiveModel);
+
+  if (toolName === "Agent" || toolName === "Task") {
+    return {
+      tier: tierFromModel || "think",  // sub-agents default to "think"
+      model: canonicalModel(effectiveModel),
+    };
+  }
+
+  if (THINK_TOOLS.has(toolName) && tierFromModel) {
+    return { tier: tierFromModel, model: canonicalModel(effectiveModel) };
+  }
+
+  if (SEARCH_TOOLS.has(toolName)) {
+    return { tier: "search", model: canonicalModel(effectiveModel) };
+  }
+
+  // Everything else: edit / bash / write / test → execute
+  return {
+    tier: tierFromModel || "execute",
+    model: canonicalModel(effectiveModel),
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Budget alerts
+// ---------------------------------------------------------------------------
+
+async function checkBudget() {
+  let config;
+  try {
+    config = JSON.parse(readFileSync(join(__dirname, '..', 'orchestrator.json'), 'utf8'));
+  } catch { return null; }
+
+  // Merge profile budget overrides on top of config defaults
+  let budgets = config.budgets;
+  if (!budgets) return null;
+  try {
+    const profileData = JSON.parse(readFileSync(PROFILE_FILE, 'utf8'));
+    if (profileData.custom_overrides?.budgets) {
+      budgets = { ...budgets, ...profileData.custom_overrides.budgets };
+    }
+  } catch {}
+
+  // Rate limit alerts
+  const cooldownFile = join(__dirname, '.budget-alerted');
+  const cooldownMin = budgets.alert_cooldown_minutes || 15;
+  try {
+    const lastAlert = readFileSync(cooldownFile, 'utf8').trim();
+    if (Date.now() - Date.parse(lastAlert) < cooldownMin * 60 * 1000) return null;
+  } catch {}
+
+  // Use summary checkpoint for fast budget check (O(1) instead of full scan)
+  let totalCost = 0;
+  try {
+    const { readSummary } = await import('./summary-checkpoint.mjs');
+    const summary = readSummary();
+    totalCost = summary.totals.cost_estimate;
+  } catch {
+    // Fallback: scan the log (only if summary unavailable)
+    const todayFile = usageFile();
+    let records = [];
+    try {
+      records = readFileSync(todayFile, 'utf8').split('\n').filter(Boolean).map(l => {
+        try { return JSON.parse(l); } catch { return null; }
+      }).filter(Boolean);
+    } catch { return null; }
+    const RATES = { search: 0.003, execute: 0.012, think: 0.055 };
+    totalCost = records.reduce((sum, r) => sum + (RATES[r.tier] || RATES.execute), 0);
+  }
+
+  let msg = null;
+  if (budgets.daily_limit_usd && totalCost >= budgets.daily_limit_usd) {
+    msg = `**[Budget Alert]** Daily cost estimate (~$${totalCost.toFixed(2)}) has reached the $${budgets.daily_limit_usd} limit. Consider pausing non-essential work.`;
+  } else if (budgets.daily_warn_usd && totalCost >= budgets.daily_warn_usd) {
+    msg = `**[Budget Alert]** Daily cost estimate (~$${totalCost.toFixed(2)}) has passed the $${budgets.daily_warn_usd} warning threshold.`;
+  }
+
+  if (msg) {
+    try { writeFileSync(cooldownFile, new Date().toISOString()); } catch {}
+    return msg;
+  }
+  return null;
+}
+
+// ---------------------------------------------------------------------------
+// Main — read stdin, classify, append, respond
+// ---------------------------------------------------------------------------
+
+async function main() {
+  // Read all stdin (non-blocking-safe with a short timeout)
+  let raw = "";
+  try {
+    for await (const chunk of process.stdin) {
+      raw += chunk;
+      if (raw.length > 64 * 1024) break; // safety cap
+    }
+  } catch {
+    // stdin closed or empty — not fatal
+  }
+
+  let payload = {};
+  try {
+    payload = JSON.parse(raw);
+  } catch {
+    // Malformed JSON — proceed with empty payload
+  }
+
+  const toolName = payload?.tool_name || payload?.toolName || "unknown";
+  const toolInput = payload?.tool_input || payload?.toolInput || {};
+  const agentModel = payload?.model || payload?.agent_model || null;
+
+  const { tier, model } = classify(toolName, toolInput, agentModel);
+
+  // Extract actual token counts from payload (location varies by hook version)
+  const usage = payload?.usage || toolInput?.usage || {};
+  const inputTokens = usage.input_tokens ?? payload?.input_tokens ?? null;
+  const outputTokens = usage.output_tokens ?? payload?.output_tokens ?? null;
+
+  const status = (payload?.error || payload?.tool_response?.error || payload?.is_error) ? 'error' : 'ok';
+
+  const entryObj = {
+    schema_version: 3,
+    timestamp: new Date().toISOString(),
+    tier,
+    tool: toolName,
+    model,
+    provider: detectProvider(model),
+    dispatcher: 'claude-code',
+    status,
+    session_id: SESSION_ID,
+    profile: loadActiveProfile(),
+    input_tokens: inputTokens,
+    output_tokens: outputTokens,
+  };
+
+  const entry = JSON.stringify(entryObj);
+
+  try {
+    appendFileSync(usageFile(), entry + "\n", { encoding: "utf8", flag: "a" });
+  } catch {}
+
+  // Update summary checkpoint (non-blocking, best-effort)
+  try {
+    const { updateSummary } = await import('./summary-checkpoint.mjs');
+    updateSummary(entryObj);
+  } catch {}
+
+  // Record failures for adaptive routing (failure-loop detection)
+  if (status === 'error' && toolName === 'Agent') {
+    try {
+      const { computePromptHash, recordFailure, pruneOldFailures } = await import('./failure-detector.mjs');
+      const promptHash = computePromptHash(toolInput);
+      recordFailure(promptHash, tier, payload?.error || 'agent_error');
+      // Best-effort cleanup of stale failure entries (>24h old)
+      try { pruneOldFailures(); } catch {}
+    } catch {}
+  }
+
+  const budgetMsg = await checkBudget();
+
+  // PostToolUse hooks must emit a JSON object to stdout
+  if (budgetMsg) {
+    process.stdout.write(JSON.stringify({ systemMessage: budgetMsg }) + "\n");
+  } else {
+    process.stdout.write("{}\n");
+  }
+  process.exit(0);
+}
+
+main();

package/hooks/cost-report.mjs

@@ -0,0 +1,351 @@
+#!/usr/bin/env node
+/**
+ * cost-report.mjs — Dual-Brain Cost Report CLI
+ *
+ * Usage:
+ *   node .claude/hooks/cost-report.mjs           # show today + all-time
+ *   node .claude/hooks/cost-report.mjs --all     # show all-time only
+ *   node .claude/hooks/cost-report.mjs --today   # show today only (default)
+ *
+ * Reads:
+ *   .claude/hooks/usage.jsonl       — tool call log written by cost-logger.mjs
+ *   .claude/orchestrator.json       — cost rates per model
+ */
+
+import { readFileSync, existsSync, readdirSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+import { spawnSync } from "child_process";
+
+// ---------------------------------------------------------------------------
+// Paths
+// ---------------------------------------------------------------------------
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const WORKSPACE  = join(__dirname, "..", ".."); // workspace root
+const CONFIG_FILE = join(__dirname, "..", "orchestrator.json");
+
+// ---------------------------------------------------------------------------
+// Load orchestrator config
+// ---------------------------------------------------------------------------
+function loadConfig() {
+  try {
+    return JSON.parse(readFileSync(CONFIG_FILE, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Build a flat map: { "haiku": { input_per_mtok, output_per_mtok, tier }, … }
+ * from orchestrator.json's subscriptions block.
+ */
+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;
+}
+
+// ---------------------------------------------------------------------------
+// Load & parse usage log
+// ---------------------------------------------------------------------------
+function loadUsage() {
+  const files = readdirSync(__dirname)
+    .filter(f => f.startsWith('usage-') && f.endsWith('.jsonl'))
+    .sort();
+
+  // Also check legacy usage.jsonl for backwards compat
+  if (existsSync(join(__dirname, 'usage.jsonl'))) {
+    files.unshift('usage.jsonl');
+  }
+
+  const records = [];
+  for (const f of files) {
+    try {
+      const lines = readFileSync(join(__dirname, f), 'utf8').split('\n').filter(Boolean);
+      for (const line of lines) {
+        try { records.push(JSON.parse(line)); } catch {}
+      }
+    } catch {}
+  }
+  return records;
+}
+
+// ---------------------------------------------------------------------------
+// Cost estimation
+// ---------------------------------------------------------------------------
+
+/**
+ * Very rough token estimate per tool call.
+ * Without actual token counts from the session files, we use a conservative
+ * heuristic based on typical Claude Code usage patterns.
+ */
+const TOKEN_HEURISTICS = {
+  // { input_tok, output_tok }
+  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;
+  // Use actual tokens if logged, otherwise fall back to heuristics
+  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) {
+    // Fallback: use tier-matched rate from whatever model we know about
+    // "main-session" and "unknown" map to think-tier (Opus) since that's the session model
+    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
+    );
+  }
+  return (
+    (inputTok  / 1_000_000) * rate.input_per_mtok +
+    (outputTok / 1_000_000) * rate.output_per_mtok
+  );
+}
+
+// ---------------------------------------------------------------------------
+// Git log fallback — estimate work volume when usage.jsonl is empty
+// ---------------------------------------------------------------------------
+function gitFallbackSummary() {
+  try {
+    const today = new Date().toISOString().slice(0, 10);
+    const proc = spawnSync("git", [
+      "-C", WORKSPACE,
+      "log", "--oneline",
+      `--since=${today} 00:00`,
+      `--until=${today} 23:59`,
+    ], {
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 10_000,
+    });
+    const log = proc.status === 0 ? (proc.stdout || "").trim() : "";
+    const commits = log ? log.split("\n").length : 0;
+    return commits;
+  } catch {
+    return 0;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Aggregation
+// ---------------------------------------------------------------------------
+
+function todayPrefix() {
+  return new Date().toISOString().slice(0, 10); // "YYYY-MM-DD"
+}
+
+/**
+ * Aggregate records into { [tier]: { model, calls, cost } }
+ * where model is the most-seen model for that tier.
+ */
+function aggregate(records, rateMap, datePrefix = null) {
+  const filtered = datePrefix
+    ? records.filter((r) => r.timestamp?.startsWith(datePrefix))
+    : records;
+
+  // tier → { calls: number, costSum: number, modelCounts: { model: count } }
+  const buckets = {};
+
+  for (const record of filtered) {
+    const tier = record.tier || "execute";
+    const model = record.model || "unknown";
+    if (!buckets[tier]) {
+      buckets[tier] = { calls: 0, costSum: 0, modelCounts: {} };
+    }
+    buckets[tier].calls += 1;
+    buckets[tier].costSum += estimateCost(tier, model, rateMap, record);
+    buckets[tier].modelCounts[model] = (buckets[tier].modelCounts[model] || 0) + 1;
+    if (record.input_tokens != null && record.output_tokens != null) buckets[tier].actualCount = (buckets[tier].actualCount || 0) + 1;
+  }
+
+  // Resolve dominant model per tier
+  const result = {};
+  for (const [tier, data] of Object.entries(buckets)) {
+    const dominantModel = Object.entries(data.modelCounts).sort((a, b) => b[1] - a[1])[0]?.[0] || "unknown";
+    result[tier] = {
+      model: dominantModel,
+      calls: data.calls,
+      cost: data.costSum,
+      actualCount: data.actualCount || 0,
+    };
+  }
+  return result;
+}
+
+// ---------------------------------------------------------------------------
+// Opus all-in cost (for savings calculation)
+// ---------------------------------------------------------------------------
+function allOpusCost(records, rateMap, datePrefix = null) {
+  const filtered = datePrefix
+    ? records.filter((r) => r.timestamp?.startsWith(datePrefix))
+    : records;
+
+  return filtered.reduce((sum, record) => {
+    return sum + estimateCost("think", "opus", rateMap, record);
+  }, 0);
+}
+
+// ---------------------------------------------------------------------------
+// Formatting helpers
+// ---------------------------------------------------------------------------
+
+const W = 50;
+
+const TIER_ORDER = ["search", "execute", "think"];
+
+const TIER_LABELS = {
+  search:  "Search ",
+  execute: "Execute",
+  think:   "Think  ",
+};
+
+function fmt$(n) {
+  return "$" + n.toFixed(2);
+}
+
+function pad(str, len, align = "left") {
+  str = String(str);
+  if (str.length >= len) return str.slice(0, len);
+  const spaces = " ".repeat(len - str.length);
+  return align === "right" ? spaces + str : str + spaces;
+}
+
+function renderTable(title, aggregated, allOpus, records = []) {
+  const totalCost  = Object.values(aggregated).reduce((s, v) => s + v.cost, 0);
+  const savings    = allOpus - totalCost;
+  const savingsPct = allOpus > 0 ? Math.round((savings / allOpus) * 100) : 0;
+
+  const line   = (s)      => `║ ${pad(s, W - 2)} ║`;
+  const border = (l, r, m) => l + "═".repeat(W) + r;
+  const sep    = ()        => "╠" + "═".repeat(W) + "╣";
+
+  const rows = TIER_ORDER
+    .filter((t) => aggregated[t])
+    .map((t) => {
+      const { model, calls, cost } = aggregated[t];
+      const tierLbl  = pad(TIER_LABELS[t] || t, 8);
+      const modelLbl = pad(model,               10);
+      const callsLbl = pad(String(calls), 5, "right");
+      const costLbl  = pad(fmt$(cost), 12, "right");
+      return line(`${tierLbl} │ ${modelLbl} │ ${callsLbl} │ ${costLbl}`);
+    });
+
+  const header = line(`Tier     │ Model      │ Calls │ Est. Cost  `);
+  const hline  = line(`─────────┼────────────┼───────┼────────────`);
+
+  const totalCalls = Object.values(aggregated).reduce((s, v) => s + v.calls, 0);
+  const actualCalls = Object.values(aggregated).reduce((s, v) => s + (v.actualCount || 0), 0);
+  const confidence = actualCalls === 0 ? 'low (heuristic only)' :
+    actualCalls === totalCalls ? 'high (actual tokens)' :
+    `medium (${Math.round(actualCalls/totalCalls*100)}% actual)`;
+
+  // Data quality stats
+  const totalRecords = Object.values(aggregated).reduce((s, v) => s + v.calls, 0);
+  const unknownModels = records.filter(r => !r.model || r.model === 'unknown').length;
+  const v2Records = records.filter(r => r.schema_version >= 2).length;
+  const errorRecords = records.filter(r => r.status === 'error').length;
+
+  const lines = [
+    border("╔", "╗"),
+    line(pad(title, W - 2)),
+    sep(),
+    header,
+    hline,
+    ...rows,
+    sep(),
+    line(`Total estimated: ${fmt$(totalCost)}`),
+    line(`Savings vs all-Opus: ~${fmt$(Math.max(0, savings))} (${savingsPct}%)`),
+    line(`Confidence: ${confidence}`),
+    border("╚", "╝"),
+  ];
+
+  if (unknownModels > 0 || errorRecords > 0) {
+    lines.splice(-1, 0,
+      line(`Unknown models: ${unknownModels}/${totalRecords} entries`),
+      line(`Errors: ${errorRecords} tool calls failed`),
+    );
+  }
+
+  return lines.join("\n");
+}
+
+function renderEmpty() {
+  const border = (l, r) => l + "═".repeat(W) + r;
+  const ln = (s) => `║ ${pad(s, W - 2)} ║`;
+  return [
+    border("╔", "╗"),
+    ln("Activity & Cost Estimate"),
+    border("╠", "╣"),
+    ln("No usage data yet."),
+    ln(""),
+    ln("Install cost-logger.mjs as a PostToolUse hook"),
+    ln("to start tracking usage."),
+    border("╚", "╝"),
+  ].join("\n");
+}
+
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+
+function main() {
+  const args    = process.argv.slice(2);
+  const showAll = args.includes("--all");
+
+  const config  = loadConfig();
+  const rateMap = buildRateMap(config);
+  const records = loadUsage();
+
+  if (records.length === 0) {
+    // Try git log fallback for a rough mention
+    const commits = gitFallbackSummary();
+    console.log(renderEmpty());
+    if (commits > 0) {
+      console.log(`\n  (Git log shows ${commits} commit(s) today — no tool-level data available.)`);
+    }
+    return;
+  }
+
+  const today = todayPrefix();
+
+  if (!showAll) {
+    // Today's report
+    const todayAgg  = aggregate(records, rateMap, today);
+    const todayOpus = allOpusCost(records, rateMap, today);
+    const todayRecords = records.filter(r => r.timestamp?.startsWith(today));
+    const hasTodayData = Object.keys(todayAgg).length > 0;
+
+    if (hasTodayData) {
+      console.log(renderTable("Activity & Cost Estimate — Today", todayAgg, todayOpus, todayRecords));
+    } else {
+      console.log("  No activity recorded for today yet.");
+    }
+
+    console.log(); // blank line separator
+  }
+
+  // All-time report
+  const allAgg  = aggregate(records, rateMap);
+  const allOpus = allOpusCost(records, rateMap);
+  console.log(renderTable("Activity & Cost Estimate — All Time", allAgg, allOpus, records));
+}
+
+main();