dual-brain 4.2.0 → 4.5.0

package/hooks/confirmation-policy.mjs

@@ -0,0 +1,167 @@
+#!/usr/bin/env node
+/**
+ * confirmation-policy.mjs — Centralized confirmation policy for Ship Captain.
+ *
+ * Single source of truth for "should we prompt the user?"
+ * Controls automation level based on risk level and user flags.
+ *
+ * Exports: getConfirmationPolicy, resolveMode, aggregateRisk, formatConfirmation
+ */
+
+// Risk level ordering for comparison
+const RISK_ORDER = ['low', 'medium', 'high', 'critical'];
+
+// Steps that are mutations (vs. validation steps)
+const MUTATION_STEPS = new Set(['edit', 'pr', 'push']);
+// Steps that are validation (auto-run in careful mode too)
+const VALIDATION_STEPS = new Set(['test', 'gate']);
+// Heal step: a fix attempt — auto-runs unless in careful mode (where user confirms)
+const HEAL_STEPS = new Set(['heal']);
+
+/**
+ * getConfirmationPolicy({ risk, mode, step })
+ *
+ * @param {object} options
+ * @param {'low'|'medium'|'high'|'critical'} options.risk
+ * @param {'default'|'yolo'|'careful'|'plan-only'} options.mode
+ * @param {'plan'|'edit'|'test'|'gate'|'heal'|'pr'|'push'} options.step
+ * @returns {{ shouldConfirm: boolean, shouldBlock: boolean, reason: string }}
+ */
+export function getConfirmationPolicy({ risk, mode, step }) {
+  const safeMode = mode || 'default';
+  const safeRisk = risk || 'low';
+  const safeStep = step || 'plan';
+
+  // PLAN-ONLY mode: block all mutations, allow plan display; skip heal (no mutations)
+  if (safeMode === 'plan-only') {
+    if (safeStep === 'plan') {
+      return { shouldConfirm: false, shouldBlock: false, reason: 'Plan-only mode — showing plan' };
+    }
+    if (HEAL_STEPS.has(safeStep)) {
+      return {
+        shouldConfirm: false,
+        shouldBlock: true,
+        reason: 'Plan-only mode — skipping heal (no mutations)',
+      };
+    }
+    return {
+      shouldConfirm: false,
+      shouldBlock: true,
+      reason: 'Plan-only mode — no mutations',
+    };
+  }
+
+  // YOLO mode: no confirmations for any step at any risk level; auto-heal
+  if (safeMode === 'yolo') {
+    if (safeRisk === 'critical') {
+      return {
+        shouldConfirm: false,
+        shouldBlock: false,
+        reason: '⚠ YOLO mode on critical risk surface',
+      };
+    }
+    return { shouldConfirm: false, shouldBlock: false, reason: 'YOLO mode — proceeding automatically' };
+  }
+
+  // CAREFUL mode: confirm every mutation/plan step; validation steps auto-run;
+  //               heal step requires confirmation before each attempt
+  if (safeMode === 'careful') {
+    if (VALIDATION_STEPS.has(safeStep)) {
+      return { shouldConfirm: false, shouldBlock: false, reason: 'Validation step — auto-run' };
+    }
+    if (HEAL_STEPS.has(safeStep)) {
+      return {
+        shouldConfirm: true,
+        shouldBlock: false,
+        reason: 'Careful mode — confirming heal attempt',
+      };
+    }
+    return {
+      shouldConfirm: true,
+      shouldBlock: false,
+      reason: `Careful mode — confirming ${safeStep} step`,
+    };
+  }
+
+  // DEFAULT mode: risk-based policy
+  // Heal step: auto-heal for all risk levels — it's just a fix attempt, no worse than the original change
+  if (safeMode === 'default') {
+    if (HEAL_STEPS.has(safeStep)) {
+      return {
+        shouldConfirm: false,
+        shouldBlock: false,
+        reason: 'Heal step — auto-proceeding (fix attempt only)',
+      };
+    }
+    if (safeRisk === 'critical') {
+      return {
+        shouldConfirm: false,
+        shouldBlock: true,
+        reason: 'Critical risk requires --yolo flag',
+      };
+    }
+    if (safeRisk === 'high') {
+      if (safeStep === 'edit' || safeStep === 'pr') {
+        return {
+          shouldConfirm: true,
+          shouldBlock: false,
+          reason: `High-risk step requires confirmation before ${safeStep}`,
+        };
+      }
+      return { shouldConfirm: false, shouldBlock: false, reason: 'High risk — auto-proceeding for non-critical step' };
+    }
+    // low or medium: no confirmations
+    return { shouldConfirm: false, shouldBlock: false, reason: 'Low/medium risk — proceeding automatically' };
+  }
+
+  // Fallback: treat unknown modes as default/no-confirm
+  return { shouldConfirm: false, shouldBlock: false, reason: 'Unknown mode — proceeding automatically' };
+}
+
+/**
+ * resolveMode(argv) — Parse CLI flags into a mode string.
+ *
+ * @param {string[]} argv  Process argv array (e.g. process.argv)
+ * @returns {'default'|'yolo'|'careful'|'plan-only'}
+ */
+export function resolveMode(argv) {
+  const args = argv || [];
+  if (args.includes('--yolo')) return 'yolo';
+  if (args.includes('--careful')) return 'careful';
+  if (args.includes('--plan-only') || args.includes('--dry-run')) return 'plan-only';
+  return 'default';
+}
+
+/**
+ * aggregateRisk(risks) — Return the highest risk level from an array.
+ *
+ * @param {string[]} risks  Array of risk strings
+ * @returns {'low'|'medium'|'high'|'critical'}
+ */
+export function aggregateRisk(risks) {
+  if (!Array.isArray(risks) || risks.length === 0) return 'low';
+  let maxIndex = 0;
+  for (const r of risks) {
+    const idx = RISK_ORDER.indexOf(r);
+    if (idx > maxIndex) maxIndex = idx;
+  }
+  return RISK_ORDER[maxIndex];
+}
+
+/**
+ * formatConfirmation(step, risk, reason) — Format a human-readable confirmation prompt.
+ *
+ * @param {string} step
+ * @param {string} risk
+ * @param {string} reason
+ * @returns {string}
+ */
+export function formatConfirmation(step, risk, reason) {
+  if (risk === 'critical') {
+    return `\u{1F534} Critical risk detected: ${reason}. This requires explicit approval. Continue? [Y/n]`;
+  }
+  if (risk === 'high') {
+    return `⚠ High-risk step: ${reason}. Continue? [Y/n]`;
+  }
+  return `\u{2139} ${reason} (step: ${step}). Continue? [Y/n]`;
+}

package/hooks/cost-logger.mjs

@@ -11,6 +11,7 @@
 import { appendFileSync, mkdirSync, readFileSync, writeFileSync } from "fs";
 import { dirname, join } from "path";
 import { fileURLToPath } from "url";
+import { logHookError } from './error-channel.mjs';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const PROFILE_FILE = join(__dirname, '..', 'dual-brain.profile.json');
@@ -166,11 +167,11 @@ async function checkBudget() {
   } catch {}
 
   // Use summary checkpoint for fast budget check (O(1) instead of full scan)
-  let totalCost = 0;
+  let activityScore = 0;
   try {
     const { readSummary } = await import('./summary-checkpoint.mjs');
     const summary = readSummary();
-    totalCost = summary.totals.cost_estimate;
+    activityScore = summary.totals.activity_score || 0;
   } catch {
     // Fallback: scan the log (only if summary unavailable)
     const todayFile = usageFile();
@@ -180,15 +181,26 @@ async function checkBudget() {
         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);
+    const TIER_WEIGHTS = { search: 3, execute: 10, think: 25 };
+    const rawActivity = records.reduce((sum, r) => {
+      if (r.input_tokens != null && r.output_tokens != null) {
+        return sum + (r.input_tokens * 1) + (r.output_tokens * 3);
+      }
+      return sum + (TIER_WEIGHTS[r.tier] || TIER_WEIGHTS.execute);
+    }, 0);
+    activityScore = Math.min(100, Math.round((rawActivity / 5_000_000) * 100));
   }
 
+  // Budget thresholds use activity score (0-100) instead of dollar amounts.
+  // Falls back to legacy daily_limit_usd / daily_warn_usd field names for compat.
+  const activityLimit = budgets.daily_activity_limit || (budgets.daily_limit_usd ? 85 : null);
+  const activityWarn = budgets.daily_activity_warn || (budgets.daily_warn_usd ? 65 : null);
+
   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 (activityLimit && activityScore >= activityLimit) {
+    msg = `**[Activity Alert]** Session activity score (${activityScore}/100) has reached the limit. Consider pausing non-essential work.`;
+  } else if (activityWarn && activityScore >= activityWarn) {
+    msg = `**[Activity Alert]** Session activity score (${activityScore}/100) has passed the warning threshold.`;
   }
 
   if (msg) {
@@ -222,6 +234,14 @@ async function main() {
   }
 
   const toolName = payload?.tool_name || payload?.toolName || "unknown";
+
+  // Early exit for high-frequency read-only tools — not worth logging
+  const READ_ONLY_TOOLS = new Set(["Read", "Grep", "Glob", "LS", "ListDir"]);
+  if (READ_ONLY_TOOLS.has(toolName)) {
+    process.stdout.write("{}\n");
+    process.exit(0);
+  }
+
   const toolInput = payload?.tool_input || payload?.toolInput || {};
   const agentModel = payload?.model || payload?.agent_model || null;
 
@@ -253,13 +273,13 @@ async function main() {
 
   try {
     appendFileSync(usageFile(), entry + "\n", { encoding: "utf8", flag: "a" });
-  } catch {}
+  } catch (e) { logHookError('cost-logger', 'usage log write', e); }
 
   // Update summary checkpoint (non-blocking, best-effort)
   try {
     const { updateSummary } = await import('./summary-checkpoint.mjs');
     updateSummary(entryObj);
-  } catch {}
+  } catch (e) { logHookError('cost-logger', 'summary checkpoint update', e); }
 
   // Record failures for adaptive routing (failure-loop detection)
   if (status === 'error' && toolName === 'Agent') {
@@ -269,7 +289,7 @@ async function main() {
       recordFailure(promptHash, tier, payload?.error || 'agent_error');
       // Best-effort cleanup of stale failure entries (>24h old)
       try { pruneOldFailures(); } catch {}
-    } catch {}
+    } catch (e) { logHookError('cost-logger', 'failure recording', e); }
   }
 
   // Record outcomes (success + failure) to decision ledger for routing feedback
@@ -291,7 +311,7 @@ async function main() {
         actual_input_tokens: inputTokens,
         actual_output_tokens: outputTokens,
       });
-    } catch {}
+    } catch (e) { logHookError('cost-logger', 'decision ledger recording', e); }
   }
 
   const budgetMsg = await checkBudget();

package/hooks/cost-report.mjs

@@ -9,7 +9,8 @@
  *
  * Reads:
  *   .claude/hooks/usage.jsonl       — tool call log written by cost-logger.mjs
- *   .claude/orchestrator.json       — cost rates per model
+ *
+ * Reports token-weighted activity scores (0-100), not dollar estimates.
  */
 
 import { readFileSync, existsSync, readdirSync } from "fs";
@@ -22,37 +23,8 @@ import { execSync } from "child_process";
 // ---------------------------------------------------------------------------
 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;
-}
+// Config and rate maps removed — cost-report no longer estimates dollar costs.
+// Activity scores are computed from token counts directly.
 
 // ---------------------------------------------------------------------------
 // Load & parse usage log
@@ -83,41 +55,20 @@ function loadUsage() {
 // 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 },
-};
+// Tier-based fallback weights when actual token counts are unavailable (legacy entries).
+// These are unitless activity weights, NOT dollar costs.
+const TIER_ACTIVITY_WEIGHTS = { search: 3, execute: 10, think: 25 };
+
+// Activity formula: (input_tokens * 1) + (output_tokens * 3)
+// SESSION_ACTIVITY_CEILING is the raw token-weighted value that maps to score 100.
+const SESSION_ACTIVITY_CEILING = 5_000_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
+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) {
-    // 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
-    );
+  if (hasActual) {
+    return { raw: (record.input_tokens * 1) + (record.output_tokens * 3), basis: 'actual' };
   }
-  return (
-    (inputTok  / 1_000_000) * rate.input_per_mtok +
-    (outputTok / 1_000_000) * rate.output_per_mtok
-  );
+  return { raw: TIER_ACTIVITY_WEIGHTS[tier] || TIER_ACTIVITY_WEIGHTS.execute, basis: 'estimated' };
 }
 
 // ---------------------------------------------------------------------------
@@ -146,29 +97,35 @@ function todayPrefix() {
 }
 
 /**
- * Aggregate records into { [tier]: { model, calls, cost } }
+ * Aggregate records into { [tier]: { model, calls, activityRaw, actualCount } }
  * where model is the most-seen model for that tier.
  */
-function aggregate(records, rateMap, datePrefix = null) {
+function aggregate(records, datePrefix = null) {
   const filtered = datePrefix
     ? records.filter((r) => r.timestamp?.startsWith(datePrefix))
     : records;
 
-  // tier → { calls: number, costSum: number, modelCounts: { model: count } }
+  // tier → { calls, activityRaw, actualCount, modelCounts }
   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: 0, activityRaw: 0, actualCount: 0, modelCounts: {} };
     }
     buckets[tier].calls += 1;
-    buckets[tier].costSum += estimateCost(tier, model, rateMap, record);
+    const { raw } = computeActivity(tier, record);
+    buckets[tier].activityRaw += raw;
     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;
+    if (record.input_tokens != null && record.output_tokens != null) {
+      buckets[tier].actualCount += 1;
+    }
   }
 
+  // Compute total raw for percentage breakdown
+  const totalRaw = Object.values(buckets).reduce((s, b) => s + b.activityRaw, 0);
+
   // Resolve dominant model per tier
   const result = {};
   for (const [tier, data] of Object.entries(buckets)) {
@@ -176,24 +133,23 @@ function aggregate(records, rateMap, datePrefix = null) {
     result[tier] = {
       model: dominantModel,
       calls: data.calls,
-      cost: data.costSum,
-      actualCount: data.actualCount || 0,
+      activityRaw: data.activityRaw,
+      activityPct: totalRaw > 0 ? Math.round((data.activityRaw / totalRaw) * 100) : 0,
+      actualCount: data.actualCount,
     };
   }
   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);
+/**
+ * Classify overall activity level from score.
+ */
+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';
 }
 
 // ---------------------------------------------------------------------------
@@ -210,10 +166,6 @@ const TIER_LABELS = {
   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);
@@ -221,39 +173,37 @@ function pad(str, len, align = "left") {
   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;
+function renderTable(title, aggregated, records = []) {
+  const totalRaw   = Object.values(aggregated).reduce((s, v) => s + v.activityRaw, 0);
+  const totalScore = Math.min(100, Math.round((totalRaw / SESSION_ACTIVITY_CEILING) * 100));
+  const label      = activityLabel(totalScore);
 
   const line   = (s)      => `║ ${pad(s, W - 2)} ║`;
-  const border = (l, r, m) => l + "═".repeat(W) + r;
+  const border = (l, r) => 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 { model, calls, activityPct } = 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 pctLbl   = pad(`${activityPct}%`, 10, "right");
+      return line(`${tierLbl} │ ${modelLbl} │ ${callsLbl} │ ${pctLbl}`);
     });
 
-  const header = line(`Tier     │ Model      │ Calls │ Est. Cost  `);
+  const header = line(`Tier     │ Model      │ Calls │ Activity % `);
   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)`;
+  const basis = actualCalls === 0 ? 'estimated (no token data)' :
+    actualCalls === totalCalls ? 'actual token counts' :
+    `mixed (${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 = [
@@ -264,15 +214,15 @@ function renderTable(title, aggregated, allOpus, records = []) {
     hline,
     ...rows,
     sep(),
-    line(`Total estimated: ${fmt$(totalCost)}`),
-    line(`Savings vs all-Opus: ~${fmt$(Math.max(0, savings))} (${savingsPct}%)`),
-    line(`Confidence: ${confidence}`),
+    line(`Session activity: ${totalScore}/100 (${label})`),
+    line(`Basis: ${basis}`),
+    line(`Activity score based on token usage, not billing`),
     border("╚", "╝"),
   ];
 
   if (unknownModels > 0 || errorRecords > 0) {
     lines.splice(-1, 0,
-      line(`Unknown models: ${unknownModels}/${totalRecords} entries`),
+      line(`Unknown models: ${unknownModels}/${totalCalls} entries`),
       line(`Errors: ${errorRecords} tool calls failed`),
     );
   }
@@ -285,7 +235,7 @@ function renderEmpty() {
   const ln = (s) => `║ ${pad(s, W - 2)} ║`;
   return [
     border("╔", "╗"),
-    ln("Activity & Cost Estimate"),
+    ln("Session Activity Report"),
     border("╠", "╣"),
     ln("No usage data yet."),
     ln(""),
@@ -303,8 +253,6 @@ 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) {
@@ -321,13 +269,12 @@ function main() {
 
   if (!showAll) {
     // Today's report
-    const todayAgg  = aggregate(records, rateMap, today);
-    const todayOpus = allOpusCost(records, rateMap, today);
+    const todayAgg  = aggregate(records, 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));
+      console.log(renderTable("Session Activity — Today", todayAgg, todayRecords));
     } else {
       console.log("  No activity recorded for today yet.");
     }
@@ -336,9 +283,8 @@ function main() {
   }
 
   // All-time report
-  const allAgg  = aggregate(records, rateMap);
-  const allOpus = allOpusCost(records, rateMap);
-  console.log(renderTable("Activity & Cost Estimate — All Time", allAgg, allOpus, records));
+  const allAgg  = aggregate(records);
+  console.log(renderTable("Session Activity — All Time", allAgg, records));
 }
 
 main();

package/hooks/decision-ledger.mjs

@@ -23,6 +23,7 @@ import { appendFileSync, existsSync, readFileSync } from 'fs';
 import { dirname, join } from 'path';
 import { fileURLToPath } from 'url';
 import { randomBytes } from 'crypto';
+import { logHookError } from './error-channel.mjs';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const LEDGER_FILE = join(__dirname, 'decision-ledger.jsonl');
@@ -62,7 +63,7 @@ function recordDecision(decision = {}) {
 
   try {
     appendFileSync(LEDGER_FILE, entry + '\n');
-  } catch {}
+  } catch (e) { logHookError('decision-ledger', 'recordDecision append', e); }
 
   return id;
 }
@@ -97,7 +98,7 @@ function recordOutcome(decisionId, outcome = {}) {
 
   try {
     appendFileSync(LEDGER_FILE, entry + '\n');
-  } catch {}
+  } catch (e) { logHookError('decision-ledger', 'recordOutcome append', e); }
 }
 
 function loadLedger() {