thumbgate 1.3.0 → 1.4.1

package/scripts/content-engine/reddit-thread-finder.js

@@ -0,0 +1,154 @@
+#!/usr/bin/env node
+/**
+ * Reddit Thread Finder for ThumbGate Engagement
+ *
+ * Add to package.json:
+ *   "content:reddit": "node scripts/content-engine/reddit-thread-finder.js"
+ *   "content:reddit:dry": "node scripts/content-engine/reddit-thread-finder.js --dry-run"
+ *   "content:reddit:limit": "node scripts/content-engine/reddit-thread-finder.js --limit 20"
+ */
+
+const https = require('https');
+const fs = require('fs');
+const path = require('path');
+
+const SUBREDDITS = [
+  'ChatGPTCoding', 'ClaudeAI', 'cursor', 'devops',
+  'SoftwareEngineering', 'ExperiencedDevs', 'MachineLearning', 'LocalLLaMA'
+];
+
+const KEYWORDS = [
+  'agent broke', 'agent deleted', 'force push', 'prevent AI from',
+  'guardrails', 'agent governance', 'coding agent mistakes'
+];
+
+const USER_AGENT = 'script:thumbgate-content:v1.0';
+const DELAY = 2000; // ms between requests
+const DEFAULT_LIMIT = 10;
+
+let dryRun = false;
+let outputLimit = DEFAULT_LIMIT;
+
+process.argv.slice(2).forEach(arg => {
+  if (arg === '--dry-run') dryRun = true;
+  if (arg.startsWith('--limit')) outputLimit = parseInt(arg.split('=')[1] || arg.split(' ')[1], 10);
+});
+
+function fetchReddit(url) {
+  return new Promise((resolve, reject) => {
+    const req = https.get(url, { headers: { 'User-Agent': USER_AGENT } }, res => {
+      let data = '';
+      res.on('data', chunk => data += chunk);
+      res.on('end', () => {
+        try {
+          resolve(JSON.parse(data));
+        } catch (e) {
+          reject(e);
+        }
+      });
+    });
+    req.on('error', reject);
+  });
+}
+
+async function searchSubreddit(sub, keyword) {
+  const url = `https://www.reddit.com/r/${sub}/search.json?q=${encodeURIComponent(keyword)}&sort=new&t=week&limit=5`;
+  try {
+    const data = await fetchReddit(url);
+    return (data.data?.children || []).map(post => ({
+      id: post.data.id,
+      title: post.data.title,
+      url: `https://reddit.com${post.data.permalink}`,
+      subreddit: post.data.subreddit,
+      score: post.data.score,
+      numComments: post.data.num_comments,
+      created: post.data.created_utc,
+      selftext: post.data.selftext
+    }));
+  } catch (err) {
+    console.error(`Error searching ${sub} for "${keyword}": ${err.message}`);
+    return [];
+  }
+}
+
+function scoreThread(thread) {
+  const now = Math.floor(Date.now() / 1000);
+  const ageHours = (now - thread.created) / 3600;
+  const recencyScore = Math.max(0, 1 - ageHours / 168); // 0-1 over a week
+  const upvoteScore = Math.log(Math.max(1, thread.score)) / Math.log(100);
+  const commentScore = Math.log(Math.max(1, thread.numComments)) / Math.log(100);
+
+  return (recencyScore * 0.5) + (upvoteScore * 0.3) + (commentScore * 0.2);
+}
+
+function generateReply(thread) {
+  const context = thread.selftext.substring(0, 200);
+  return `
+**ThumbGate can help prevent this.** Our pre-action gates catch agent mistakes before they happen:
+- Stop force pushes on protected branches
+- Prevent deletions of critical files
+- Verify AI actions before execution
+- Capture lessons from failures to block similar mistakes
+
+Learn more: https://thumbgate-production.up.railway.app/dashboard
+`;
+}
+
+async function main() {
+  console.log(`[${new Date().toISOString()}] Starting Reddit thread finder...`);
+
+  const threads = {};
+  let requestCount = 0;
+
+  for (const sub of SUBREDDITS) {
+    for (const keyword of KEYWORDS) {
+      if (requestCount > 0) await new Promise(r => setTimeout(r, DELAY));
+
+      console.log(`  Searching r/${sub} for "${keyword}"...`);
+      const results = await searchSubreddit(sub, keyword);
+
+      results.forEach(thread => {
+        if (!threads[thread.id]) {
+          threads[thread.id] = thread;
+        }
+      });
+      requestCount++;
+    }
+  }
+
+  const sorted = Object.values(threads)
+    .sort((a, b) => scoreThread(b) - scoreThread(a))
+    .slice(0, outputLimit);
+
+  const date = new Date().toISOString().split('T')[0];
+  const outputDir = path.join(__dirname, 'output');
+
+  if (!fs.existsSync(outputDir)) {
+    fs.mkdirSync(outputDir, { recursive: true });
+  }
+
+  let markdown = `# Reddit Threads - ${date}\n\nFound ${sorted.length} high-relevance threads.\n\n`;
+
+  sorted.forEach((thread, idx) => {
+    const score = scoreThread(thread);
+    markdown += `## ${idx + 1}. ${thread.title}\n`;
+    markdown += `**r/${thread.subreddit}** | [Link](${thread.url}) | Score: ${thread.score} | Comments: ${thread.numComments}\n`;
+    markdown += `**Relevance Score:** ${score.toFixed(2)}\n\n`;
+
+    if (!dryRun) {
+      markdown += `**Suggested Reply:**\n${generateReply(thread)}\n\n`;
+    }
+    markdown += '---\n\n';
+  });
+
+  const outputFile = path.join(outputDir, `reddit-threads-${date}.md`);
+  fs.writeFileSync(outputFile, markdown);
+
+  console.log(`\n✅ Generated ${sorted.length} threads to ${outputFile}`);
+  if (dryRun) console.log('   (--dry-run: no reply suggestions included)');
+}
+
+main().catch(err => {
+  console.error('❌ Fatal error:', err.message);
+  process.exit(1);
+});

package/scripts/context-engine.js

@@ -20,6 +20,7 @@ const fs = require('fs');
 const path = require('path');
 const crypto = require('crypto');
 const { constructContextPack } = require('./contextfs');
+const { ensureDir } = require('./fs-utils');
 
 // ---------------------------------------------------------------------------
 // Default paths
@@ -75,11 +76,6 @@ const TOOL_CONSOLIDATION = {
 // Utility: ensure directory exists
 // ---------------------------------------------------------------------------
 
-function ensureDir(dirPath) {
-  if (!fs.existsSync(dirPath)) {
-    fs.mkdirSync(dirPath, { recursive: true });
-  }
-}
 
 // ---------------------------------------------------------------------------
 // Knowledge Bundle Builder
@@ -649,10 +645,29 @@ function compactContext(entries, anchors, opts) {
     return true;
   });
 
+  // Stage 6: Global token budget — drop entries (oldest first) until total chars fit
+  let finalStage = 5;
+  const totalMaxChars = typeof options.totalMaxChars === 'number' ? options.totalMaxChars : null;
+  if (totalMaxChars !== null) {
+    let budget = totalMaxChars;
+    const budgeted = [];
+    // Iterate newest-first so most recent entries are preserved
+    for (let i = working.length - 1; i >= 0; i--) {
+      const entrySize = JSON.stringify(working[i]).length;
+      if (budget - entrySize < 0) break;
+      budget -= entrySize;
+      budgeted.unshift(working[i]);
+    }
+    if (budgeted.length < working.length) {
+      working = budgeted;
+      finalStage = 6;
+    }
+  }
+
   const removedCount = initial - working.length;
   return {
     entries: [...anchorEntries, ...working],
-    stage: 5,
+    stage: finalStage,
     removedCount,
     compacted: removedCount > 0,
   };

package/scripts/contextfs.js

@@ -12,6 +12,7 @@ const fs = require('fs');
 const path = require('path');
 const crypto = require('crypto');
 const { resolveFeedbackDir } = require('./feedback-paths');
+const { ensureDir, readJsonl } = require('./fs-utils');
 const {
   retrieveHierarchicalDocuments,
   shouldUseHierarchicalRetrieval,
@@ -99,11 +100,6 @@ const PACK_TEMPLATES = {
   },
 };
 
-function ensureDir(dirPath) {
-  if (!fs.existsSync(dirPath)) {
-    fs.mkdirSync(dirPath, { recursive: true });
-  }
-}
 
 function ensureContextFs() {
   Object.values(NAMESPACES).forEach((subPath) => {
@@ -140,22 +136,6 @@ function appendJsonl(filePath, payload) {
   fs.appendFileSync(filePath, `${JSON.stringify(payload)}\n`);
 }
 
-function readJsonl(filePath) {
-  if (!fs.existsSync(filePath)) return [];
-  const raw = fs.readFileSync(filePath, 'utf-8').trim();
-  if (!raw) return [];
-  return raw
-    .split('\n')
-    .map((line) => {
-      try {
-        return JSON.parse(line);
-      } catch {
-        return null;
-      }
-    })
-    .filter(Boolean);
-}
-
 function listJsonFiles(dirPath) {
   if (!fs.existsSync(dirPath)) return [];
   const files = fs.readdirSync(dirPath, { withFileTypes: true });

package/scripts/dashboard.js

@@ -21,6 +21,7 @@ const { getSettingsStatus } = require('./settings-hierarchy');
 const { summarizeWorkflowRuns } = require('./workflow-runs');
 const { searchLessons } = require('./lesson-search');
 const { getInterventionPolicySummary } = require('./intervention-policy');
+const { computeDecisionMetrics } = require('./decision-journal');
 
 const PROJECT_ROOT = path.join(__dirname, '..');
 const DEFAULT_GATES_PATH = path.join(PROJECT_ROOT, 'config', 'gates', 'default.json');
@@ -787,6 +788,7 @@ function generateDashboard(feedbackDir, options = {}) {
   const readiness = generateAgentReadinessReport({ projectRoot: PROJECT_ROOT });
   const harness = computeHarnessOverview(feedbackDir, entries);
   const interventionPolicy = getInterventionPolicySummary(feedbackDir);
+  const decisions = computeDecisionMetrics(feedbackDir);
   const settingsStatus = getSettingsStatus({ projectRoot: PROJECT_ROOT });
   settingsStatus.routingPreview = {
     dashboardTool: routeProfile({
@@ -820,6 +822,13 @@ function generateDashboard(feedbackDir, options = {}) {
     lessonEffectiveness: { rate: totalNeg > 0 ? Math.round((autoGates / totalNeg) * 10000) / 100 : 0, totalNegative: totalNeg, autoGatesCreated: autoGates },
     errorTrend: { direction: lastWeekNeg > 0 ? (negRecent.length < lastWeekNeg ? 'improving' : negRecent.length > lastWeekNeg ? 'worsening' : 'stable') : (negRecent.length > 0 ? 'new-errors' : 'clean'), thisWeek: negRecent.length, lastWeek: lastWeekNeg },
     weeklyActivity: { positive: posRecent.length, negative: negRecent.length, total: recentEntries.length },
+    decisionLoop: {
+      fastPathRate: decisions.fastPathRate,
+      overrideRate: decisions.overrideRate,
+      rollbackRate: decisions.rollbackRate,
+      medianLatencyMs: decisions.medianLatencyMs,
+      resolvedCount: decisions.resolvedCount,
+    },
   };
 
   const team = generateOrgDashboard({
@@ -857,6 +866,7 @@ function generateDashboard(feedbackDir, options = {}) {
     instrumentation,
     readiness,
     interventionPolicy,
+    decisions,
     settingsStatus,
     team,
     templateLibrary,
@@ -886,6 +896,7 @@ function printDashboard(data) {
     instrumentation,
     readiness,
     interventionPolicy,
+    decisions,
     settingsStatus,
     team,
     templateLibrary,
@@ -945,6 +956,14 @@ function printDashboard(data) {
     console.log(`  Top Deny Signal  : ${interventionPolicy.topTokens.deny[0].token}`);
   }
 
+  console.log('');
+  console.log('🧭 Decision Loop');
+  console.log(`  Evaluations      : ${decisions.evaluationCount}`);
+  console.log(`  Fast Path        : ${Math.round((decisions.fastPathRate || 0) * 100)}%`);
+  console.log(`  Override Rate    : ${Math.round((decisions.overrideRate || 0) * 100)}%`);
+  console.log(`  Rollback Rate    : ${Math.round((decisions.rollbackRate || 0) * 100)}%`);
+  console.log(`  Median Latency   : ${Math.round((decisions.medianLatencyMs || 0) / 1000)}s`);
+
   console.log('');
   console.log('🎯 North Star');
   console.log(`  Weekly Proof Runs: ${analytics.northStar.weeklyActiveProofBackedWorkflowRuns}`);
@@ -1120,6 +1139,7 @@ module.exports = {
   generateDashboard,
   printDashboard,
   computeApprovalStats,
+  computeDecisionMetrics,
   computeGateStats,
   computePreventionImpact,
   computeSessionTrend,

package/scripts/decision-journal.js

@@ -0,0 +1,341 @@
+#!/usr/bin/env node
+'use strict';
+
+const crypto = require('crypto');
+const fs = require('fs');
+const path = require('path');
+const { resolveFeedbackDir } = require('./feedback-paths');
+const { sanitizeToolInput } = require('./audit-trail');
+const { ensureDir } = require('./fs-utils');
+
+const DECISION_LOG_FILENAME = 'decision-journal.jsonl';
+const DEFAULT_DAY_COUNT = 14;
+const RESOLVED_OUTCOMES = new Set(['accepted', 'completed', 'overridden', 'rolled_back', 'blocked', 'aborted']);
+const DECISION_OUTCOMES = new Set([...RESOLVED_OUTCOMES, 'warned']);
+
+function getDecisionLogPath(feedbackDir) {
+  return path.join(resolveFeedbackDir({ feedbackDir }), DECISION_LOG_FILENAME);
+}
+
+
+function buildActionId(prefix = 'decision') {
+  return `${prefix}_${Date.now()}_${crypto.randomBytes(3).toString('hex')}`;
+}
+
+function readDecisionLog(logPath) {
+  const targetPath = logPath || getDecisionLogPath();
+  if (!fs.existsSync(targetPath)) return [];
+  const raw = fs.readFileSync(targetPath, 'utf8').trim();
+  if (!raw) return [];
+  return raw
+    .split('\n')
+    .map((line) => {
+      try {
+        return JSON.parse(line);
+      } catch {
+        return null;
+      }
+    })
+    .filter(Boolean);
+}
+
+function appendDecisionRecord(record, feedbackDir) {
+  const logPath = getDecisionLogPath(feedbackDir);
+  ensureDir(path.dirname(logPath));
+  fs.appendFileSync(logPath, `${JSON.stringify(record)}\n`, 'utf8');
+  return record;
+}
+
+function toLocalDayKey(value) {
+  const ts = value instanceof Date ? value : new Date(value);
+  if (Number.isNaN(ts.getTime())) return null;
+  const year = ts.getFullYear();
+  const month = String(ts.getMonth() + 1).padStart(2, '0');
+  const day = String(ts.getDate()).padStart(2, '0');
+  return `${year}-${month}-${day}`;
+}
+
+function normalizeOutcome(value) {
+  const normalized = String(value || '').trim().toLowerCase().replace(/[\s-]+/g, '_');
+  if (DECISION_OUTCOMES.has(normalized)) return normalized;
+  return 'completed';
+}
+
+function inferActualDecision(outcome, fallback) {
+  if (fallback) return String(fallback);
+  if (outcome === 'blocked') return 'deny';
+  if (outcome === 'warned') return 'warn';
+  return 'allow';
+}
+
+function median(values) {
+  const sorted = values
+    .map((value) => Number(value))
+    .filter((value) => Number.isFinite(value))
+    .sort((left, right) => left - right);
+  if (sorted.length === 0) return 0;
+  const middle = Math.floor(sorted.length / 2);
+  if (sorted.length % 2 === 1) return sorted[middle];
+  return Math.round((sorted[middle - 1] + sorted[middle]) / 2);
+}
+
+function summarizeBlastRadius(report = {}) {
+  const blastRadius = report.blastRadius || {};
+  return {
+    severity: blastRadius.severity || 'low',
+    fileCount: Number(blastRadius.fileCount || 0),
+    surfaceCount: Number(blastRadius.surfaceCount || 0),
+    releaseSensitiveCount: Array.isArray(blastRadius.releaseSensitiveFiles) ? blastRadius.releaseSensitiveFiles.length : 0,
+    protectedWithoutApprovalCount: Array.isArray(blastRadius.unapprovedProtectedFiles) ? blastRadius.unapprovedProtectedFiles.length : 0,
+    summary: blastRadius.summary || '',
+  };
+}
+
+function normalizeRecommendation(report = {}) {
+  const control = report.decisionControl || {};
+  return {
+    decision: report.decision || 'allow',
+    riskScore: Number(report.riskScore || 0),
+    riskBand: report.band || 'low',
+    executionMode: control.executionMode || (report.decision === 'deny' ? 'blocked' : report.decision === 'warn' ? 'checkpoint_required' : 'auto_execute'),
+    decisionOwner: control.decisionOwner || (report.decision === 'allow' ? 'agent' : 'shared'),
+    reversibility: control.reversibility || 'reviewable',
+    requiresHumanApproval: control.requiresHumanApproval === true,
+    summary: report.summary || '',
+    recommendedAction: control.recommendedAction || (report.decision === 'deny' ? 'halt' : report.decision === 'warn' ? 'review' : 'proceed'),
+  };
+}
+
+function recordDecisionEvaluation(report, params = {}, options = {}) {
+  const actionId = params.actionId || buildActionId();
+  const changedFiles = Array.isArray(params.changedFiles)
+    ? params.changedFiles.slice()
+    : Array.isArray(report && report.blastRadius && report.blastRadius.affectedFiles)
+      ? report.blastRadius.affectedFiles.slice()
+      : [];
+  const record = {
+    recordType: 'evaluation',
+    actionId,
+    timestamp: params.timestamp || new Date().toISOString(),
+    source: params.source || 'workflow-sentinel',
+    toolName: params.toolName || report.toolName || 'unknown',
+    toolInput: sanitizeToolInput(params.toolInput || {}),
+    changedFiles,
+    recommendation: normalizeRecommendation(report),
+    blastRadius: summarizeBlastRadius(report),
+    learnedPolicy: report.learnedPolicy && report.learnedPolicy.enabled
+      ? {
+        label: report.learnedPolicy.prediction && report.learnedPolicy.prediction.label || null,
+        confidence: Number((report.learnedPolicy.prediction && report.learnedPolicy.prediction.confidence) || 0),
+      }
+      : null,
+    topRemediations: Array.isArray(report.remediations)
+      ? report.remediations.slice(0, 3).map((entry) => ({ id: entry.id, title: entry.title }))
+      : [],
+    evidence: Array.isArray(report.evidence) ? report.evidence.slice(0, 4) : [],
+  };
+  return appendDecisionRecord(record, options.feedbackDir);
+}
+
+function recordDecisionOutcome(params = {}, options = {}) {
+  const actionId = params.actionId || buildActionId('decision_outcome');
+  const entries = readDecisionLog(getDecisionLogPath(options.feedbackDir));
+  const evaluation = [...entries]
+    .reverse()
+    .find((entry) => entry && entry.recordType === 'evaluation' && entry.actionId === actionId) || null;
+  const outcome = normalizeOutcome(params.outcome);
+  const timestamp = params.timestamp || new Date().toISOString();
+  const latencyMs = Number.isFinite(params.latencyMs)
+    ? Number(params.latencyMs)
+    : evaluation && evaluation.timestamp
+      ? Math.max(0, new Date(timestamp).getTime() - new Date(evaluation.timestamp).getTime())
+      : null;
+  const record = {
+    recordType: 'outcome',
+    actionId,
+    timestamp,
+    source: params.source || 'api',
+    actor: params.actor || 'human',
+    outcome,
+    actualDecision: inferActualDecision(outcome, params.actualDecision),
+    notes: params.notes || '',
+    metadata: params.metadata && typeof params.metadata === 'object' ? params.metadata : {},
+    latencyMs: Number.isFinite(latencyMs) ? latencyMs : null,
+    recommendation: evaluation ? evaluation.recommendation : (params.recommendation || null),
+    toolName: evaluation ? evaluation.toolName : (params.toolName || 'unknown'),
+    changedFiles: evaluation ? evaluation.changedFiles : (Array.isArray(params.changedFiles) ? params.changedFiles.slice() : []),
+  };
+  return appendDecisionRecord(record, options.feedbackDir);
+}
+
+function collapseDecisionTimeline(records) {
+  const actions = new Map();
+  for (const record of records) {
+    if (!record || !record.actionId) continue;
+    if (!actions.has(record.actionId)) {
+      actions.set(record.actionId, { actionId: record.actionId, evaluation: null, outcomes: [] });
+    }
+    const bucket = actions.get(record.actionId);
+    if (record.recordType === 'evaluation') {
+      bucket.evaluation = record;
+    } else if (record.recordType === 'outcome') {
+      bucket.outcomes.push(record);
+    }
+  }
+  for (const bucket of actions.values()) {
+    bucket.outcomes.sort((left, right) => new Date(left.timestamp).getTime() - new Date(right.timestamp).getTime());
+  }
+  return [...actions.values()].sort((left, right) => {
+    const leftTs = left.evaluation ? new Date(left.evaluation.timestamp).getTime() : 0;
+    const rightTs = right.evaluation ? new Date(right.evaluation.timestamp).getTime() : 0;
+    return leftTs - rightTs;
+  });
+}
+
+function initializeDaySeries(dayCount) {
+  const today = new Date();
+  today.setHours(0, 0, 0, 0);
+  const days = [];
+  for (let offset = dayCount - 1; offset >= 0; offset -= 1) {
+    const day = new Date(today);
+    day.setDate(today.getDate() - offset);
+    days.push({
+      dayKey: toLocalDayKey(day),
+      evaluations: 0,
+      fastPath: 0,
+      checkpoint: 0,
+      blockedRecommendations: 0,
+      overrides: 0,
+      rollbacks: 0,
+      completions: 0,
+      blockedOutcomes: 0,
+      latencies: [],
+    });
+  }
+  return days;
+}
+
+function safeRate(numerator, denominator) {
+  if (!denominator) return 0;
+  return Number((numerator / denominator).toFixed(4));
+}
+
+function computeDecisionMetrics(feedbackDir, options = {}) {
+  const dayCount = Number.isInteger(options.dayCount) ? options.dayCount : DEFAULT_DAY_COUNT;
+  const records = readDecisionLog(getDecisionLogPath(feedbackDir));
+  const actions = collapseDecisionTimeline(records).filter((entry) => entry.evaluation);
+  const series = initializeDaySeries(dayCount);
+  const dayMap = new Map(series.map((day) => [day.dayKey, day]));
+  const outcomeCounts = {
+    accepted: 0,
+    completed: 0,
+    overridden: 0,
+    rolled_back: 0,
+    blocked: 0,
+    aborted: 0,
+    warned: 0,
+  };
+
+  let fastPathCount = 0;
+  let checkpointCount = 0;
+  let blockedRecommendationCount = 0;
+  let overrideCount = 0;
+  let rollbackCount = 0;
+  let resolvedCount = 0;
+  const latencyValues = [];
+
+  for (const action of actions) {
+    const evaluation = action.evaluation;
+    const recommendation = evaluation.recommendation || {};
+    const evalDay = dayMap.get(toLocalDayKey(evaluation.timestamp));
+    if (evalDay) {
+      evalDay.evaluations += 1;
+      if (recommendation.executionMode === 'auto_execute') evalDay.fastPath += 1;
+      if (recommendation.executionMode === 'checkpoint_required') evalDay.checkpoint += 1;
+      if (recommendation.executionMode === 'blocked') evalDay.blockedRecommendations += 1;
+    }
+
+    if (recommendation.executionMode === 'auto_execute') fastPathCount += 1;
+    if (recommendation.executionMode === 'checkpoint_required') checkpointCount += 1;
+    if (recommendation.executionMode === 'blocked') blockedRecommendationCount += 1;
+
+    const hasOverride = action.outcomes.some((outcome) => outcome.outcome === 'overridden');
+    const hasRollback = action.outcomes.some((outcome) => outcome.outcome === 'rolled_back');
+    if (hasOverride) overrideCount += 1;
+    if (hasRollback) rollbackCount += 1;
+
+    const latestOutcome = action.outcomes.length > 0 ? action.outcomes[action.outcomes.length - 1] : null;
+    if (latestOutcome) {
+      outcomeCounts[latestOutcome.outcome] = (outcomeCounts[latestOutcome.outcome] || 0) + 1;
+      const outcomeDay = dayMap.get(toLocalDayKey(latestOutcome.timestamp));
+      if (outcomeDay) {
+        if (latestOutcome.outcome === 'overridden') outcomeDay.overrides += 1;
+        if (latestOutcome.outcome === 'rolled_back') outcomeDay.rollbacks += 1;
+        if (latestOutcome.outcome === 'completed' || latestOutcome.outcome === 'accepted') outcomeDay.completions += 1;
+        if (latestOutcome.outcome === 'blocked') outcomeDay.blockedOutcomes += 1;
+      }
+      if (RESOLVED_OUTCOMES.has(latestOutcome.outcome)) {
+        resolvedCount += 1;
+      }
+      if (Number.isFinite(latestOutcome.latencyMs)) {
+        latencyValues.push(latestOutcome.latencyMs);
+        if (outcomeDay) outcomeDay.latencies.push(latestOutcome.latencyMs);
+      }
+    }
+  }
+
+  const days = series.map((day) => ({
+    dayKey: day.dayKey,
+    evaluations: day.evaluations,
+    fastPath: day.fastPath,
+    checkpoint: day.checkpoint,
+    blockedRecommendations: day.blockedRecommendations,
+    overrides: day.overrides,
+    rollbacks: day.rollbacks,
+    completions: day.completions,
+    blockedOutcomes: day.blockedOutcomes,
+    medianLatencyMs: median(day.latencies),
+  }));
+
+  return {
+    evaluationCount: actions.length,
+    resolvedCount,
+    fastPathCount,
+    checkpointCount,
+    blockedRecommendationCount,
+    overrideCount,
+    rollbackCount,
+    outcomeCounts,
+    fastPathRate: safeRate(fastPathCount, actions.length),
+    checkpointRate: safeRate(checkpointCount, actions.length),
+    overrideRate: safeRate(overrideCount, resolvedCount || actions.length),
+    rollbackRate: safeRate(rollbackCount, resolvedCount || actions.length),
+    followRate: safeRate(Math.max(0, resolvedCount - overrideCount), resolvedCount || actions.length),
+    medianLatencyMs: median(latencyValues),
+    averageLatencyMs: latencyValues.length > 0
+      ? Math.round(latencyValues.reduce((sum, value) => sum + value, 0) / latencyValues.length)
+      : 0,
+    dayCount,
+    days,
+    activeDays: days.filter((day) => {
+      return day.evaluations > 0 || day.overrides > 0 || day.rollbacks > 0 || day.completions > 0 || day.blockedOutcomes > 0;
+    }).length,
+  };
+}
+
+module.exports = {
+  DECISION_LOG_FILENAME,
+  RESOLVED_OUTCOMES,
+  buildActionId,
+  collapseDecisionTimeline,
+  computeDecisionMetrics,
+  getDecisionLogPath,
+  normalizeOutcome,
+  readDecisionLog,
+  recordDecisionEvaluation,
+  recordDecisionOutcome,
+};
+
+if (require.main === module) {
+  console.log(JSON.stringify(computeDecisionMetrics(process.argv[2]), null, 2));
+}

package/scripts/delegation-runtime.js

@@ -4,6 +4,7 @@
 const crypto = require('crypto');
 const fs = require('fs');
 const path = require('path');
+const { ensureDir } = require('./fs-utils');
 const {
   loadSubagentProfiles,
   getAllowedTools,
@@ -32,11 +33,6 @@ function getVerificationLoopModule() {
   return require('./verification-loop');
 }
 
-function ensureDir(dirPath) {
-  if (!fs.existsSync(dirPath)) {
-    fs.mkdirSync(dirPath, { recursive: true });
-  }
-}
 
 function readJSONL(filePath) {
   if (!fs.existsSync(filePath)) return [];