@sienklogic/plan-build-run 2.0.0

package/plugins/pbr/scripts/session-cleanup.js

@@ -0,0 +1,254 @@
+#!/usr/bin/env node
+
+/**
+ * SessionEnd cleanup hook.
+ *
+ * Removes stale planning artifacts that shouldn't persist across sessions:
+ *   - .planning/.auto-next (prevents confusion on next session start)
+ *   - .planning/.active-operation (stale operation lock)
+ *   - .planning/.active-skill (stale skill tracking)
+ *
+ * Additional cleanup:
+ *   - Removes stale .checkpoint-manifest.json files (>24h old)
+ *   - Rotates hooks.jsonl when >200KB (moves to hooks.jsonl.1)
+ *   - Warns about orphaned .PROGRESS-* files (executor crash artifacts)
+ *   - Writes session summary to logs/sessions.jsonl
+ *
+ * Logs session end with reason to hook-log.
+ * Non-blocking — best-effort cleanup, fails silently.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { logHook } = require('./hook-logger');
+const { tailLines } = require('./pbr-tools');
+
+function readStdin() {
+  try {
+    const input = fs.readFileSync(0, 'utf8').trim();
+    if (input) return JSON.parse(input);
+  } catch (_e) {
+    // empty or non-JSON stdin
+  }
+  return {};
+}
+
+function tryRemove(filePath) {
+  try {
+    if (fs.existsSync(filePath)) {
+      fs.unlinkSync(filePath);
+      return true;
+    }
+  } catch (_e) {
+    // best-effort — don't fail the hook
+  }
+  return false;
+}
+
+const STALE_CHECKPOINT_MS = 24 * 60 * 60 * 1000; // 24 hours
+const MAX_HOOKS_LOG_BYTES = 200 * 1024; // 200KB
+
+function cleanStaleCheckpoints(planningDir) {
+  const removed = [];
+  try {
+    const phasesDir = path.join(planningDir, 'phases');
+    if (!fs.existsSync(phasesDir)) return removed;
+
+    const dirs = fs.readdirSync(phasesDir);
+    for (const dir of dirs) {
+      const manifestPath = path.join(phasesDir, dir, '.checkpoint-manifest.json');
+      if (!fs.existsSync(manifestPath)) continue;
+
+      const stat = fs.statSync(manifestPath);
+      const ageMs = Date.now() - stat.mtimeMs;
+      if (ageMs > STALE_CHECKPOINT_MS) {
+        fs.unlinkSync(manifestPath);
+        removed.push(path.join('phases', dir, '.checkpoint-manifest.json'));
+      }
+    }
+  } catch (_e) {
+    // best-effort
+  }
+  return removed;
+}
+
+function rotateHooksLog(planningDir) {
+  try {
+    const logsDir = path.join(planningDir, 'logs');
+    const hooksLog = path.join(logsDir, 'hooks.jsonl');
+    if (!fs.existsSync(hooksLog)) return false;
+
+    const stat = fs.statSync(hooksLog);
+    if (stat.size <= MAX_HOOKS_LOG_BYTES) return false;
+
+    const rotatedPath = hooksLog + '.1';
+    // Overwrite any existing .1 file
+    fs.renameSync(hooksLog, rotatedPath);
+    return true;
+  } catch (_e) {
+    return false;
+  }
+}
+
+function findOrphanedProgressFiles(planningDir) {
+  const orphans = [];
+  try {
+    const phasesDir = path.join(planningDir, 'phases');
+    if (!fs.existsSync(phasesDir)) return orphans;
+
+    const dirs = fs.readdirSync(phasesDir);
+    for (const dir of dirs) {
+      const phaseDir = path.join(phasesDir, dir);
+      const files = fs.readdirSync(phaseDir);
+      for (const file of files) {
+        if (file.startsWith('.PROGRESS-')) {
+          orphans.push(path.join('phases', dir, file));
+        }
+      }
+    }
+  } catch (_e) {
+    // best-effort
+  }
+  return orphans;
+}
+
+const MAX_SESSION_ENTRIES = 100;
+
+function writeSessionHistory(planningDir, data) {
+  try {
+    const logsDir = path.join(planningDir, 'logs');
+    if (!fs.existsSync(logsDir)) {
+      fs.mkdirSync(logsDir, { recursive: true });
+    }
+
+    const sessionsFile = path.join(logsDir, 'sessions.jsonl');
+
+    // Mine existing logs for session stats
+    const hooksLog = path.join(logsDir, 'hooks.jsonl');
+    const eventsLog = path.join(logsDir, 'events.jsonl');
+
+    let agentsSpawned = 0;
+    let commitsCreated = 0;
+    const commandsRun = [];
+    let sessionStart = null;
+
+    // Count agents from hooks log (SubagentStart entries)
+    // Hooks log is capped at 200 entries; read last 200 to cover the full session
+    const hookLines = tailLines(hooksLog, 200);
+    for (const line of hookLines) {
+      try {
+        const entry = JSON.parse(line);
+        if (entry.event === 'SubagentStart' && entry.decision === 'spawned') {
+          agentsSpawned++;
+        }
+        // Track earliest timestamp as session start
+        if (entry.ts && (!sessionStart || entry.ts < sessionStart)) {
+          sessionStart = entry.ts;
+        }
+      } catch (_e) { /* skip malformed lines */ }
+    }
+
+    // Count commits and commands from events log
+    // Read last 200 entries — sufficient for a single session's events
+    const eventLines = tailLines(eventsLog, 200);
+    for (const line of eventLines) {
+      try {
+        const entry = JSON.parse(line);
+        if (entry.event === 'commit-validated' && entry.status === 'allow') {
+          commitsCreated++;
+        }
+        if (entry.cat === 'workflow' && entry.event) {
+          if (!commandsRun.includes(entry.event)) {
+            commandsRun.push(entry.event);
+          }
+        }
+        if (entry.ts && (!sessionStart || entry.ts < sessionStart)) {
+          sessionStart = entry.ts;
+        }
+      } catch (_e) { /* skip malformed lines */ }
+    }
+
+    const sessionEnd = new Date().toISOString();
+    let durationMinutes = null;
+    if (sessionStart) {
+      durationMinutes = Math.round((new Date(sessionEnd) - new Date(sessionStart)) / 60000);
+    }
+
+    const summary = {
+      start: sessionStart || sessionEnd,
+      end: sessionEnd,
+      duration_minutes: durationMinutes,
+      reason: data.reason || null,
+      agents_spawned: agentsSpawned,
+      commits_created: commitsCreated,
+      commands_run: commandsRun
+    };
+
+    // Append to sessions.jsonl, cap at MAX_SESSION_ENTRIES
+    let lines = [];
+    if (fs.existsSync(sessionsFile)) {
+      const content = fs.readFileSync(sessionsFile, 'utf8').trim();
+      if (content) {
+        lines = content.split('\n');
+      }
+    }
+    lines.push(JSON.stringify(summary));
+    if (lines.length > MAX_SESSION_ENTRIES) {
+      lines = lines.slice(lines.length - MAX_SESSION_ENTRIES);
+    }
+    fs.writeFileSync(sessionsFile, lines.join('\n') + '\n', 'utf8');
+  } catch (_e) {
+    // Best-effort — don't fail the hook
+  }
+}
+
+function main() {
+  const data = readStdin();
+  const cwd = process.cwd();
+  const planningDir = path.join(cwd, '.planning');
+
+  if (!fs.existsSync(planningDir)) {
+    process.exit(0);
+  }
+
+  const cleaned = [];
+
+  if (tryRemove(path.join(planningDir, '.auto-next'))) {
+    cleaned.push('.auto-next');
+  }
+  if (tryRemove(path.join(planningDir, '.active-operation'))) {
+    cleaned.push('.active-operation');
+  }
+  if (tryRemove(path.join(planningDir, '.active-skill'))) {
+    cleaned.push('.active-skill');
+  }
+  if (tryRemove(path.join(planningDir, '.active-plan'))) {
+    cleaned.push('.active-plan');
+  }
+
+  // Clean stale checkpoint manifests (>24h old)
+  const staleCheckpoints = cleanStaleCheckpoints(planningDir);
+  cleaned.push(...staleCheckpoints);
+
+  // Rotate hooks.jsonl if >200KB
+  const rotated = rotateHooksLog(planningDir);
+
+  // Detect orphaned .PROGRESS-* files (executor crash artifacts)
+  const orphans = findOrphanedProgressFiles(planningDir);
+
+  // Write session history log
+  writeSessionHistory(planningDir, data);
+
+  const decision = cleaned.length > 0 ? 'cleaned' : 'nothing';
+  logHook('session-cleanup', 'SessionEnd', decision, {
+    reason: data.reason || null,
+    removed: cleaned,
+    log_rotated: rotated,
+    orphaned_progress_files: orphans.length > 0 ? orphans : undefined
+  });
+
+  process.exit(0);
+}
+
+module.exports = { writeSessionHistory, tryRemove, cleanStaleCheckpoints, rotateHooksLog, findOrphanedProgressFiles };
+if (require.main === module) { main(); }

package/plugins/pbr/scripts/status-line.js

@@ -0,0 +1,285 @@
+#!/usr/bin/env node
+
+/**
+ * Status line: Updates Claude Code status bar with phase progress and
+ * context usage bar.
+ *
+ * Reads STATE.md for project position. Receives session JSON on stdin
+ * from Claude Code (context_window, model, cost, etc.).
+ *
+ * Output: plain text with ANSI color codes to stdout.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const cp = require('child_process');
+const { logHook } = require('./hook-logger');
+const { configLoad } = require('./pbr-tools');
+
+// ANSI color codes
+const c = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  dim: '\x1b[2m',
+  cyan: '\x1b[36m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  red: '\x1b[31m',
+  blue: '\x1b[34m',
+  magenta: '\x1b[35m',
+  white: '\x1b[37m',
+  boldCyan: '\x1b[1;36m',
+  boldGreen: '\x1b[1;32m',
+  boldYellow: '\x1b[1;33m',
+  boldRed: '\x1b[1;31m',
+};
+
+// Default status_line config — works out of the box with zero config
+const DEFAULTS = {
+  sections: ['phase', 'plan', 'status', 'git', 'context'],
+  brand_text: '\u25C6 Plan-Build-Run',
+  max_status_length: 50,
+  context_bar: {
+    width: 10,
+    thresholds: { green: 70, yellow: 90 },
+    chars: { filled: '\u2588', empty: '\u2591' }
+  }
+};
+
+/**
+ * Load status_line config from .planning/config.json, merged with defaults.
+ * Returns DEFAULTS if no config exists or no status_line section is present.
+ */
+function loadStatusLineConfig(planningDir) {
+  const config = configLoad(planningDir);
+  if (!config || !config.status_line) return DEFAULTS;
+
+  const sl = config.status_line;
+  return {
+    sections: Array.isArray(sl.sections) ? sl.sections : DEFAULTS.sections,
+    brand_text: typeof sl.brand_text === 'string' ? sl.brand_text : DEFAULTS.brand_text,
+    max_status_length: typeof sl.max_status_length === 'number' ? sl.max_status_length : DEFAULTS.max_status_length,
+    context_bar: {
+      width: (sl.context_bar && typeof sl.context_bar.width === 'number') ? sl.context_bar.width : DEFAULTS.context_bar.width,
+      thresholds: {
+        green: (sl.context_bar && sl.context_bar.thresholds && typeof sl.context_bar.thresholds.green === 'number') ? sl.context_bar.thresholds.green : DEFAULTS.context_bar.thresholds.green,
+        yellow: (sl.context_bar && sl.context_bar.thresholds && typeof sl.context_bar.thresholds.yellow === 'number') ? sl.context_bar.thresholds.yellow : DEFAULTS.context_bar.thresholds.yellow
+      },
+      chars: {
+        filled: (sl.context_bar && sl.context_bar.chars && typeof sl.context_bar.chars.filled === 'string') ? sl.context_bar.chars.filled : DEFAULTS.context_bar.chars.filled,
+        empty: (sl.context_bar && sl.context_bar.chars && typeof sl.context_bar.chars.empty === 'string') ? sl.context_bar.chars.empty : DEFAULTS.context_bar.chars.empty
+      }
+    }
+  };
+}
+
+function readStdin() {
+  try {
+    const input = fs.readFileSync(0, 'utf8').trim();
+    if (input) return JSON.parse(input);
+  } catch (_e) {
+    // stdin may be empty or not JSON — that's fine
+  }
+  return {};
+}
+
+function getContextPercent(stdinData) {
+  // Claude Code statusLine sends context_window.used_percentage (0-100)
+  if (stdinData.context_window && stdinData.context_window.used_percentage != null) {
+    return Math.round(stdinData.context_window.used_percentage);
+  }
+  // Legacy field name
+  if (stdinData.context_usage_fraction != null) {
+    return Math.round(stdinData.context_usage_fraction * 100);
+  }
+  return null;
+}
+
+/**
+ * Build a horizontal bar using Unicode block characters.
+ * Width is in character cells. Color shifts green -> yellow -> red.
+ *
+ * @param {number} percent - Usage percentage (0-100)
+ * @param {number} width - Bar width in characters
+ * @param {object} [opts] - Optional config overrides
+ * @param {object} [opts.thresholds] - { green: number, yellow: number }
+ * @param {object} [opts.chars] - { filled: string, empty: string }
+ */
+function buildContextBar(percent, width, opts) {
+  if (width < 1) return '';
+  const thresholds = (opts && opts.thresholds) || DEFAULTS.context_bar.thresholds;
+  const chars = (opts && opts.chars) || DEFAULTS.context_bar.chars;
+
+  const filled = Math.round((percent / 100) * width);
+  const empty = width - filled;
+
+  // Color based on usage threshold
+  let barColor;
+  if (percent >= thresholds.yellow) barColor = c.boldRed;
+  else if (percent >= thresholds.green) barColor = c.boldYellow;
+  else barColor = c.boldGreen;
+
+  const filledStr = chars.filled.repeat(filled);
+  const emptyStr = chars.empty.repeat(empty);
+
+  return `${barColor}${filledStr}${c.dim}${emptyStr}${c.reset}`;
+}
+
+/**
+ * Pick a color for the phase status keyword.
+ */
+function statusColor(statusText) {
+  const lower = statusText.toLowerCase();
+  if (lower.includes('complete') || lower.includes('verified')) return c.green;
+  if (lower.includes('progress') || lower.includes('building') || lower.includes('executing')) return c.yellow;
+  if (lower.includes('planned') || lower.includes('ready')) return c.cyan;
+  if (lower.includes('blocked') || lower.includes('failed')) return c.red;
+  return c.white;
+}
+
+/**
+ * Get current git branch and dirty status.
+ * Returns null if not in a git repo or git is unavailable.
+ */
+function getGitInfo() {
+  try {
+    const branch = cp.execSync('git branch --show-current', {
+      timeout: 500, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe']
+    }).trim();
+    if (!branch) return null;
+    const porcelain = cp.execSync('git status --porcelain', {
+      timeout: 500, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe']
+    }).trim();
+    return { branch, dirty: porcelain.length > 0 };
+  } catch (_e) {
+    return null;
+  }
+}
+
+/**
+ * Format milliseconds into human-readable duration (e.g. "12m", "1h23m").
+ */
+function formatDuration(ms) {
+  const totalSeconds = Math.floor(ms / 1000);
+  const hours = Math.floor(totalSeconds / 3600);
+  const minutes = Math.floor((totalSeconds % 3600) / 60);
+  if (hours > 0) return `${hours}h${minutes > 0 ? minutes + 'm' : ''}`;
+  return `${minutes}m`;
+}
+
+function main() {
+  const stdinData = readStdin();
+  const cwd = process.cwd();
+  const planningDir = path.join(cwd, '.planning');
+  const stateFile = path.join(planningDir, 'STATE.md');
+
+  if (!fs.existsSync(stateFile)) {
+    process.exit(0);
+  }
+
+  try {
+    const slConfig = loadStatusLineConfig(planningDir);
+    const content = fs.readFileSync(stateFile, 'utf8');
+    const ctxPercent = getContextPercent(stdinData);
+    const status = buildStatusLine(content, ctxPercent, slConfig, stdinData);
+
+    if (status) {
+      process.stdout.write(status);
+      logHook('status-line', 'StatusLine', 'updated', { ctxPercent });
+    }
+  } catch (_e) {
+    logHook('status-line', 'StatusLine', 'error', { error: _e.message });
+  }
+
+  process.exit(0);
+}
+
+function buildStatusLine(content, ctxPercent, cfg, stdinData) {
+  const config = cfg || DEFAULTS;
+  const sections = config.sections || DEFAULTS.sections;
+  const brandText = config.brand_text || DEFAULTS.brand_text;
+  const maxLen = config.max_status_length || DEFAULTS.max_status_length;
+  const barCfg = config.context_bar || DEFAULTS.context_bar;
+  const sd = stdinData || {};
+
+  const parts = [];
+
+  // Phase section (always includes brand text)
+  if (sections.includes('phase')) {
+    const phaseMatch = content.match(/Phase:\s*(\d+)\s*of\s*(\d+)\s*(?:\(([^)]+)\))?/);
+    if (phaseMatch) {
+      parts.push(`${c.boldCyan}${brandText}${c.reset} ${c.bold}Phase ${phaseMatch[1]}/${phaseMatch[2]}${c.reset}`);
+      if (phaseMatch[3]) {
+        parts.push(`${c.magenta}${phaseMatch[3]}${c.reset}`);
+      }
+    } else {
+      parts.push(`${c.boldCyan}${brandText}${c.reset}`);
+    }
+  }
+
+  // Plan section
+  if (sections.includes('plan')) {
+    const planMatch = content.match(/Plan:\s*(\d+)\s*of\s*(\d+)/);
+    if (planMatch) {
+      const done = parseInt(planMatch[1], 10);
+      const total = parseInt(planMatch[2], 10);
+      const planColor = done === total ? c.green : c.white;
+      parts.push(`${planColor}Plan ${done}/${total}${c.reset}`);
+    }
+  }
+
+  // Status section
+  if (sections.includes('status')) {
+    const statusMatch = content.match(/Status:\s*(.+)/);
+    if (statusMatch) {
+      const text = statusMatch[1].trim();
+      const short = text.length > maxLen ? text.slice(0, maxLen - 3) + '...' : text;
+      parts.push(`${statusColor(text)}${short}${c.reset}`);
+    }
+  }
+
+  // Git section — branch name + dirty indicator
+  if (sections.includes('git')) {
+    const gitInfo = getGitInfo();
+    if (gitInfo) {
+      const dirtyMark = gitInfo.dirty ? `${c.yellow}*${c.reset}` : '';
+      parts.push(`${c.cyan}${gitInfo.branch}${c.reset}${dirtyMark}`);
+    }
+  }
+
+  // Model section — current model display name from stdin
+  if (sections.includes('model') && sd.model && sd.model.display_name) {
+    parts.push(`${c.dim}${sd.model.display_name}${c.reset}`);
+  }
+
+  // Cost section — session cost from stdin
+  if (sections.includes('cost') && sd.cost && sd.cost.total_cost_usd != null) {
+    const cost = sd.cost.total_cost_usd;
+    const costStr = `$${cost.toFixed(2)}`;
+    let costColor = c.dim;
+    if (cost > 5) costColor = c.red;
+    else if (cost > 1) costColor = c.yellow;
+    parts.push(`${costColor}${costStr}${c.reset}`);
+  }
+
+  // Duration section — session wall-clock time from stdin
+  if (sections.includes('duration') && sd.cost && sd.cost.total_duration_ms != null) {
+    parts.push(`${c.dim}${formatDuration(sd.cost.total_duration_ms)}${c.reset}`);
+  }
+
+  // Context bar section
+  if (sections.includes('context') && ctxPercent != null) {
+    const bar = buildContextBar(ctxPercent, barCfg.width || DEFAULTS.context_bar.width, {
+      thresholds: barCfg.thresholds || DEFAULTS.context_bar.thresholds,
+      chars: barCfg.chars || DEFAULTS.context_bar.chars
+    });
+    parts.push(`${bar} ${c.dim}${ctxPercent}%${c.reset}`);
+  }
+
+  if (parts.length === 0) return null;
+
+  return parts.join(` ${c.dim}\u2502${c.reset} `);
+}
+
+if (require.main === module) { main(); }
+module.exports = { buildStatusLine, buildContextBar, getContextPercent, getGitInfo, formatDuration, loadStatusLineConfig, DEFAULTS };

package/plugins/pbr/scripts/suggest-compact.js

@@ -0,0 +1,119 @@
+#!/usr/bin/env node
+
+/**
+ * PostToolUse hook on Write|Edit: Tracks tool call count per session
+ * and suggests /compact when approaching context limits.
+ *
+ * Counter stored in .planning/.compact-counter (JSON).
+ * Threshold configurable via config.json hooks.compactThreshold (default: 50).
+ * After first suggestion, re-suggests every 25 calls.
+ * Counter resets on SessionStart (via progress-tracker.js).
+ *
+ * Exit codes:
+ *   0 = always (advisory only)
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { logHook } = require('./hook-logger');
+const { configLoad } = require('./pbr-tools');
+
+const DEFAULT_THRESHOLD = 50;
+const REMINDER_INTERVAL = 25;
+
+function main() {
+  process.stdin.setEncoding('utf8');
+  process.stdin.resume();
+  process.stdin.on('end', () => {
+    try {
+      const cwd = process.cwd();
+      const planningDir = path.join(cwd, '.planning');
+      if (!fs.existsSync(planningDir)) {
+        process.exit(0);
+      }
+
+      const result = checkCompaction(planningDir, cwd);
+      if (result) {
+        process.stdout.write(JSON.stringify(result));
+      }
+      process.exit(0);
+    } catch (_e) {
+      process.exit(0);
+    }
+  });
+}
+
+/**
+ * Increment tool call counter and return a suggestion if threshold is reached.
+ * @param {string} planningDir - Path to .planning/ directory
+ * @param {string} cwd - Current working directory (for config loading)
+ * @returns {Object|null} Hook output with additionalContext, or null
+ */
+function checkCompaction(planningDir, cwd) {
+  const counterPath = path.join(planningDir, '.compact-counter');
+  const counter = loadCounter(counterPath);
+  const threshold = getThreshold(cwd);
+
+  counter.count += 1;
+  saveCounter(counterPath, counter);
+
+  if (counter.count < threshold) return null;
+
+  const isFirstSuggestion = !counter.lastSuggested;
+  const callsSinceSuggestion = counter.count - (counter.lastSuggested || 0);
+
+  if (isFirstSuggestion || callsSinceSuggestion >= REMINDER_INTERVAL) {
+    counter.lastSuggested = counter.count;
+    saveCounter(counterPath, counter);
+
+    logHook('suggest-compact', 'PostToolUse', 'suggest', {
+      count: counter.count,
+      threshold
+    });
+
+    return {
+      additionalContext: `[Context Budget] ${counter.count} tool calls this session (threshold: ${threshold}). Consider running /compact to free context space before quality degrades.`
+    };
+  }
+
+  return null;
+}
+
+function loadCounter(counterPath) {
+  try {
+    const content = fs.readFileSync(counterPath, 'utf8');
+    const data = JSON.parse(content);
+    return { count: data.count || 0, lastSuggested: data.lastSuggested || 0 };
+  } catch (_e) {
+    return { count: 0, lastSuggested: 0 };
+  }
+}
+
+function saveCounter(counterPath, counter) {
+  try {
+    fs.writeFileSync(counterPath, JSON.stringify(counter), 'utf8');
+  } catch (_e) {
+    // Best-effort
+  }
+}
+
+function getThreshold(cwd) {
+  const planningDir = path.join(cwd, '.planning');
+  const config = configLoad(planningDir);
+  if (!config) return DEFAULT_THRESHOLD;
+  return config.hooks?.compactThreshold || DEFAULT_THRESHOLD;
+}
+
+function resetCounter(planningDir) {
+  const counterPath = path.join(planningDir, '.compact-counter');
+  try {
+    if (fs.existsSync(counterPath)) {
+      fs.unlinkSync(counterPath);
+    }
+  } catch (_e) {
+    // Best-effort
+  }
+}
+
+module.exports = { checkCompaction, loadCounter, saveCounter, getThreshold, resetCounter, DEFAULT_THRESHOLD, REMINDER_INTERVAL };
+if (require.main === module) { main(); }

package/plugins/pbr/scripts/task-completed.js

@@ -0,0 +1,45 @@
+#!/usr/bin/env node
+
+/**
+ * TaskCompleted hook: Logs agent task completion with output summary.
+ *
+ * Fires when a Task() sub-agent finishes (distinct from SubagentStop).
+ * Logs the completion event and agent type for workflow tracking.
+ *
+ * Non-blocking — exits 0 always.
+ */
+
+const fs = require('fs');
+const { logHook } = require('./hook-logger');
+const { logEvent } = require('./event-logger');
+
+function readStdin() {
+  try {
+    const input = fs.readFileSync(0, 'utf8').trim();
+    if (input) return JSON.parse(input);
+  } catch (_e) {
+    // empty or non-JSON stdin
+  }
+  return {};
+}
+
+function main() {
+  const data = readStdin();
+
+  logHook('task-completed', 'TaskCompleted', 'completed', {
+    agent_type: data.agent_type || data.subagent_type || null,
+    agent_id: data.agent_id || null,
+    duration_ms: data.duration_ms || null
+  });
+
+  logEvent('agent', 'task-completed', {
+    agent_type: data.agent_type || data.subagent_type || null,
+    agent_id: data.agent_id || null,
+    duration_ms: data.duration_ms || null
+  });
+
+  process.exit(0);
+}
+
+if (require.main === module) { main(); }
+module.exports = { main };