pan-wizard 2.9.1 → 3.5.0

package/hooks/dist/pan-statusline.js

@@ -1,108 +1,154 @@
-#!/usr/bin/env node
-// Claude Code Statusline - PAN Edition
-// Shows: model | current task | directory | context usage
-
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
-
-// Read JSON from stdin
-let input = '';
-process.stdin.setEncoding('utf8');
-process.stdin.on('data', chunk => input += chunk);
-process.stdin.on('end', () => {
-  try {
-    const data = JSON.parse(input);
-    const model = data.model?.display_name || 'Claude';
-    const dir = data.workspace?.current_dir || process.cwd();
-    const session = data.session_id || '';
-    const remaining = data.context_window?.remaining_percentage;
-
-    // Context window display (shows USED percentage scaled to 80% limit)
-    // Claude Code enforces an 80% context limit, so we scale to show 100% at that point
-    let ctx = '';
-    if (remaining != null) {
-      const rem = Math.round(remaining);
-      const rawUsed = Math.max(0, Math.min(100, 100 - rem));
-      // Scale: 80% real usage = 100% displayed
-      const used = Math.min(100, Math.round((rawUsed / 80) * 100));
-
-      // Write context metrics to bridge file for the context-monitor PostToolUse hook.
-      // The monitor reads this file to inject agent-facing warnings when context is low.
-      if (session) {
-        try {
-          const bridgePath = path.join(os.tmpdir(), `claude-ctx-${session}.json`);
-          const bridgeData = JSON.stringify({
-            session_id: session,
-            remaining_percentage: remaining,
-            used_pct: used,
-            timestamp: Math.floor(Date.now() / 1000)
-          });
-          fs.writeFileSync(bridgePath, bridgeData);
-        } catch (e) {
-          // Silent fail -- bridge is best-effort, don't break statusline
-        }
-      }
-
-      // Build progress bar (10 segments)
-      const filled = Math.floor(used / 10);
-      const bar = '█'.repeat(filled) + '░'.repeat(10 - filled);
-
-      // Color based on scaled usage (thresholds adjusted for new scale)
-      if (used < 63) {        // ~50% real
-        ctx = ` \x1b[32m${bar} ${used}%\x1b[0m`;
-      } else if (used < 81) { // ~65% real
-        ctx = ` \x1b[33m${bar} ${used}%\x1b[0m`;
-      } else if (used < 95) { // ~76% real
-        ctx = ` \x1b[38;5;208m${bar} ${used}%\x1b[0m`;
-      } else {
-        ctx = ` \x1b[5;31m💀 ${bar} ${used}%\x1b[0m`;
-      }
-    }
-
-    // Current task from todos
-    let task = '';
-    const homeDir = os.homedir();
-    const todosDir = path.join(homeDir, '.claude', 'todos');
-    if (session && fs.existsSync(todosDir)) {
-      try {
-        const files = fs.readdirSync(todosDir)
-          .filter(f => f.startsWith(session) && f.includes('-agent-') && f.endsWith('.json'))
-          .map(f => ({ name: f, mtime: fs.statSync(path.join(todosDir, f)).mtime }))
-          .sort((a, b) => b.mtime - a.mtime);
-
-        if (files.length > 0) {
-          try {
-            const todos = JSON.parse(fs.readFileSync(path.join(todosDir, files[0].name), 'utf8'));
-            const inProgress = todos.find(t => t.status === 'in_progress');
-            if (inProgress) task = inProgress.activeForm || '';
-          } catch (e) {}
-        }
-      } catch (e) {
-        // Silently fail on file system errors - don't break statusline
-      }
-    }
-
-    // PAN update available?
-    let panUpdate = '';
-    const cacheFile = path.join(homeDir, '.claude', 'cache', 'pan-update-check.json');
-    if (fs.existsSync(cacheFile)) {
-      try {
-        const cache = JSON.parse(fs.readFileSync(cacheFile, 'utf8'));
-        if (cache.update_available) {
-          panUpdate = '\x1b[33m⬆ /pan:update\x1b[0m │ ';
-        }
-      } catch (e) {}
-    }
-
-    // Output
-    const dirname = path.basename(dir);
-    if (task) {
-      process.stdout.write(`${panUpdate}\x1b[2m${model}\x1b[0m │ \x1b[1m${task}\x1b[0m │ \x1b[2m${dirname}\x1b[0m${ctx}`);
-    } else {
-      process.stdout.write(`${panUpdate}\x1b[2m${model}\x1b[0m │ \x1b[2m${dirname}\x1b[0m${ctx}`);
-    }
-  } catch (e) {
-    // Silent fail - don't break statusline on parse errors
-  }
-});
+#!/usr/bin/env node
+// Claude Code Statusline - PAN Edition
+// Shows: model | current task | directory | context | cache | thinking
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+/**
+ * Build the statusline output string from the JSON payload Claude Code pipes
+ * to stdin. Pure function — no stdin, no stdout, no process exit. Safe to
+ * call from tests.
+ *
+ * @param {Object} data - Parsed stdin JSON from Claude Code.
+ * @param {Object} [deps] - Optional dep injection for testing.
+ *   {fs, path, homeDir, tmpDir} — defaults to real modules + OS paths.
+ * @returns {string} The statusline content.
+ */
+function buildStatuslineOutput(data, deps) {
+  const d = deps || {};
+  const fsMod = d.fs || fs;
+  const pathMod = d.path || path;
+  const homeDir = d.homeDir || os.homedir();
+  const tmpDir = d.tmpDir || os.tmpdir();
+
+  if (!data || typeof data !== 'object') return '';
+
+  const model = data.model?.display_name || 'Claude';
+  const dir = data.workspace?.current_dir || process.cwd();
+  const session = data.session_id || '';
+  const remaining = data.context_window?.remaining_percentage;
+
+  // Context window bar — shows USED percentage scaled so 80% real = 100% shown.
+  let ctx = '';
+  if (remaining != null) {
+    const rem = Math.round(remaining);
+    const rawUsed = Math.max(0, Math.min(100, 100 - rem));
+    const used = Math.min(100, Math.round((rawUsed / 80) * 100));
+
+    if (session && d.skipBridge !== true) {
+      try {
+        const bridgePath = pathMod.join(tmpDir, `claude-ctx-${session}.json`);
+        fsMod.writeFileSync(bridgePath, JSON.stringify({
+          session_id: session,
+          remaining_percentage: remaining,
+          used_pct: used,
+          timestamp: Math.floor(Date.now() / 1000),
+        }));
+      } catch { /* bridge is best-effort */ }
+    }
+
+    const filled = Math.floor(used / 10);
+    const bar = '█'.repeat(filled) + '░'.repeat(10 - filled);
+
+    if (used < 63) {
+      ctx = ` \x1b[32m${bar} ${used}%\x1b[0m`;
+    } else if (used < 81) {
+      ctx = ` \x1b[33m${bar} ${used}%\x1b[0m`;
+    } else if (used < 95) {
+      ctx = ` \x1b[38;5;208m${bar} ${used}%\x1b[0m`;
+    } else {
+      ctx = ` \x1b[5;31m💀 ${bar} ${used}%\x1b[0m`;
+    }
+  }
+
+  // E-8: Opus 4.7 indicators. Read from stdin data first (if present),
+  // else merge from optional bridge file `claude-pan-<session>.json` that
+  // an agent or external process can write.
+  let panExtras = null;
+  if (session) {
+    try {
+      const extrasPath = pathMod.join(tmpDir, `claude-pan-${session}.json`);
+      const extrasRaw = fsMod.readFileSync(extrasPath, 'utf8');
+      panExtras = JSON.parse(extrasRaw);
+    } catch { /* no extras is fine */ }
+  }
+
+  const thinkingActive = (data.thinking && data.thinking.active === true)
+    || (panExtras && panExtras.thinking_active === true);
+  const cacheHitRate = (data.cache && typeof data.cache.hit_rate_pct === 'number')
+    ? data.cache.hit_rate_pct
+    : (panExtras && typeof panExtras.cache_hit_rate_pct === 'number'
+      ? panExtras.cache_hit_rate_pct
+      : null);
+
+  let thinkingBadge = '';
+  if (thinkingActive) thinkingBadge = ' \x1b[35m🧠\x1b[0m';
+
+  let cacheBadge = '';
+  if (cacheHitRate != null) {
+    const pct = Math.max(0, Math.min(100, Math.round(cacheHitRate)));
+    // Color: green ≥70%, yellow 30-70%, dim <30% (warmup).
+    const color = pct >= 70 ? '\x1b[32m' : pct >= 30 ? '\x1b[33m' : '\x1b[2m';
+    cacheBadge = ` ${color}⚡${pct}%\x1b[0m`;
+  }
+
+  // Current task from todos
+  let task = '';
+  const todosDir = pathMod.join(homeDir, '.claude', 'todos');
+  let todosExists = false;
+  try { todosExists = fsMod.statSync(todosDir).isDirectory(); } catch { /* missing */ }
+  if (session && todosExists) {
+    try {
+      const files = fsMod.readdirSync(todosDir)
+        .filter(f => f.startsWith(session) && f.includes('-agent-') && f.endsWith('.json'))
+        .map(f => {
+          try { return { name: f, mtime: fsMod.statSync(pathMod.join(todosDir, f)).mtime }; }
+          catch { return null; }
+        })
+        .filter(Boolean)
+        .sort((a, b) => b.mtime - a.mtime);
+
+      if (files.length > 0) {
+        try {
+          const todos = JSON.parse(fsMod.readFileSync(pathMod.join(todosDir, files[0].name), 'utf8'));
+          const inProgress = todos.find(t => t.status === 'in_progress');
+          if (inProgress) task = inProgress.activeForm || '';
+        } catch { /* malformed todos file — skip */ }
+      }
+    } catch { /* fs errors — silent */ }
+  }
+
+  // PAN update available?
+  let panUpdate = '';
+  const cacheFile = pathMod.join(homeDir, '.claude', 'cache', 'pan-update-check.json');
+  try {
+    const cache = JSON.parse(fsMod.readFileSync(cacheFile, 'utf8'));
+    if (cache.update_available) panUpdate = '\x1b[33m⬆ /pan:update\x1b[0m │ ';
+  } catch { /* no update cache — silent */ }
+
+  const dirname = pathMod.basename(dir);
+  const head = `${panUpdate}\x1b[2m${model}\x1b[0m`;
+  const taskSegment = task ? ` │ \x1b[1m${task}\x1b[0m` : '';
+  const dirSegment = ` │ \x1b[2m${dirname}\x1b[0m`;
+  return `${head}${taskSegment}${dirSegment}${ctx}${cacheBadge}${thinkingBadge}`;
+}
+
+// ─── Stdin driver ───────────────────────────────────────────────────────────
+
+if (require.main === module) {
+  let input = '';
+  process.stdin.setEncoding('utf8');
+  process.stdin.on('data', chunk => input += chunk);
+  process.stdin.on('end', () => {
+    try {
+      const data = JSON.parse(input);
+      process.stdout.write(buildStatuslineOutput(data));
+    } catch {
+      // Silent fail — don't break statusline on parse errors.
+    }
+  });
+}
+
+module.exports = { buildStatuslineOutput };

package/hooks/dist/pan-trace-logger.js

@@ -0,0 +1,197 @@
+#!/usr/bin/env node
+// pan-trace-logger — SubagentStop hook (v3.5+).
+//
+// Fires alongside pan-cost-logger on every SubagentStop event. If a trace
+// session is active (.planning/optimization/current-session exists), this
+// hook appends a completion event to the trace. This is the automatic
+// instrumentation layer of the circular optimization loop — no extra user
+// action required.
+//
+// Events logged per subagent:
+//   - completion: agent finished, tokens used, exit status
+//   - redundancy: detected when the same agent type ran twice in this session
+//     with similar token counts (rough heuristic for repeated work)
+//
+// Errors are swallowed — this hook must never block the main agent loop.
+
+const fs = require('fs');
+const path = require('path');
+
+const PLANNING_DIR = '.planning';
+const OPTIMIZE_DIR = 'optimization';
+const TRACES_DIR = 'traces';
+const CURRENT_SESSION_FILE = 'current-session';
+const TRACE_EVENT_FILE = 'trace.jsonl';
+
+function getOptimizeDir(cwd) {
+  return path.join(cwd, PLANNING_DIR, OPTIMIZE_DIR);
+}
+
+function getTracesDir(cwd) {
+  return path.join(getOptimizeDir(cwd), TRACES_DIR);
+}
+
+function getCurrentSessionId(cwd) {
+  try {
+    return fs.readFileSync(path.join(getOptimizeDir(cwd), CURRENT_SESSION_FILE), 'utf-8').trim() || null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Ensure a trace session exists. If none is active, create a day-scoped
+ * auto-session so tracing works across the whole flow without manual init.
+ *
+ * @param {string} cwd
+ * @returns {string} The active session ID
+ */
+function ensureSessionId(cwd) {
+  const existing = getCurrentSessionId(cwd);
+  if (existing) return existing;
+
+  // Create a day-scoped auto session
+  const now = new Date();
+  const stamp = now.toISOString().replace(/[-:T]/g, '').slice(0, 8); // YYYYMMDD
+  const sessionId = `sess_auto_${stamp}`;
+  try {
+    const sessionDir = path.join(getTracesDir(cwd), sessionId);
+    fs.mkdirSync(sessionDir, { recursive: true });
+    const meta = {
+      session_id: sessionId,
+      started_at: now.toISOString(),
+      description: 'auto-session (day-scoped)',
+      auto: true,
+      event_count: 0,
+    };
+    fs.writeFileSync(path.join(sessionDir, 'session.json'), JSON.stringify(meta, null, 2) + '\n');
+    const optimizeDir = getOptimizeDir(cwd);
+    fs.mkdirSync(optimizeDir, { recursive: true });
+    fs.writeFileSync(path.join(optimizeDir, CURRENT_SESSION_FILE), sessionId + '\n');
+    return sessionId;
+  } catch {
+    return sessionId; // Return the ID even if write fails — best effort
+  }
+}
+
+function extractNumber(obj, key) {
+  if (!obj || typeof obj !== 'object') return 0;
+  const v = obj[key];
+  return typeof v === 'number' ? v : 0;
+}
+
+/**
+ * Build trace event(s) from a SubagentStop payload.
+ * Pure function — no side effects.
+ *
+ * @param {Object} data - SubagentStop event payload
+ * @returns {Object[]} Array of trace event records
+ */
+function buildTraceEvents(data, sessionId) {
+  if (!data || typeof data !== 'object') return [];
+  if (data.hook_event_name && data.hook_event_name !== 'SubagentStop') return [];
+
+  const ts = new Date().toISOString();
+  const agent = data.agent_type || data.subagent_type || 'unknown';
+  const inputTokens = extractNumber(data.usage, 'input_tokens');
+  const outputTokens = extractNumber(data.usage, 'output_tokens');
+  const cacheRead = extractNumber(data.usage, 'cache_read_input_tokens');
+  const totalTokens = inputTokens + outputTokens;
+
+  const events = [];
+
+  // Core completion event
+  events.push({
+    ts,
+    session: sessionId,
+    agent,
+    phase: data.phase || null,
+    type: 'decision',
+    category: 'agent_completion',
+    description: `${agent} completed`,
+    context: {
+      model: data.model || null,
+      input_tokens: inputTokens,
+      output_tokens: outputTokens,
+      cache_read_tokens: cacheRead,
+      total_tokens: totalTokens,
+      exit_code: data.exit_code || 0,
+    },
+    impact: 'trivial',
+    correction: null,
+    tokens_wasted: null,
+  });
+
+  // Heuristic: if output tokens > 3000 and no cache hits, flag as potential redundancy
+  // (expensive agent run that wasn't cached — may be repeated research)
+  if (outputTokens > 3000 && cacheRead === 0) {
+    events.push({
+      ts,
+      session: sessionId,
+      agent,
+      phase: data.phase || null,
+      type: 'redundancy',
+      category: 'uncached_heavy_run',
+      description: `${agent} produced ${outputTokens} output tokens with zero cache hits — possible repeated research`,
+      context: { output_tokens: outputTokens, cache_read_tokens: 0 },
+      impact: 'minor',
+      correction: null,
+      tokens_wasted: outputTokens,
+    });
+  }
+
+  return events;
+}
+
+/**
+ * Append trace events to the active session.
+ * Returns true if written, false if no session or write failed.
+ *
+ * @param {string} cwd
+ * @param {Object[]} events
+ * @param {string} sessionId
+ */
+function appendTraceEvents(cwd, events, sessionId) {
+  if (!events.length) return false;
+  try {
+    const sessionDir = path.join(getTracesDir(cwd), sessionId);
+    fs.mkdirSync(sessionDir, { recursive: true });
+    const lines = events.map(e => JSON.stringify(e)).join('\n') + '\n';
+    fs.appendFileSync(path.join(sessionDir, TRACE_EVENT_FILE), lines, 'utf-8');
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// ─── Stdin driver ────────────────────────────────────────────────────────────
+
+if (require.main === module) {
+  let input = '';
+  process.stdin.setEncoding('utf8');
+  process.stdin.on('data', chunk => (input += chunk));
+  process.stdin.on('end', () => {
+    try {
+      const data = JSON.parse(input);
+      const cwd = data.cwd || data.workspace?.current_dir || process.cwd();
+      // Always ensure a session exists — creates a day-scoped auto-session if needed
+      const sessionId = ensureSessionId(cwd);
+      const events = buildTraceEvents(data, sessionId);
+      appendTraceEvents(cwd, events, sessionId);
+    } catch {
+      // Silent fail
+    }
+  });
+}
+
+module.exports = {
+  buildTraceEvents,
+  appendTraceEvents,
+  getCurrentSessionId,
+  ensureSessionId,
+  PLANNING_DIR,
+  OPTIMIZE_DIR,
+  TRACES_DIR,
+  CURRENT_SESSION_FILE,
+  TRACE_EVENT_FILE,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pan-wizard",
-  "version": "2.9.1",
+  "version": "3.5.0",
   "description": "A lightweight workflow automation and context engineering system for Claude Code, OpenCode, Gemini CLI, Codex, and Copilot CLI.",
   "bin": {
     "pan-wizard": "bin/install.js"