pan-wizard 3.4.1 → 3.5.1

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": "3.4.1",
+  "version": "3.5.1",
   "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"

package/pan-wizard-core/bin/lib/commands.cjs

@@ -1453,5 +1453,6 @@ module.exports = {
   cmdLearningsExtract,
   cmdLearningsList,
   cmdLearningsPrune,
+  runCommitSafetyChecks,
   VALID_COMMIT_TYPES,
 };

package/pan-wizard-core/bin/lib/constants.cjs

@@ -124,7 +124,7 @@ const FOCUS_DIR = 'focus';
 const AUTO_RUN_FILE = 'auto-run.json';
 
 /** Focus auto-runner categories */
-const FOCUS_CATEGORIES = ['cleanup', 'tests', 'stability', 'features', 'docs', 'optimize', 'prompts'];
+const FOCUS_CATEGORIES = ['cleanup', 'tests', 'stability', 'features', 'docs', 'optimize', 'prompts', 'security', 'distill'];
 
 /** Category → priority index range (indices into PRIORITY_LEVELS) */
 const CATEGORY_PRIORITY_RANGE = {
@@ -135,6 +135,8 @@ const CATEGORY_PRIORITY_RANGE = {
   docs:      { min: 5, max: 6 },  // P5-P6
   optimize:  { min: 1, max: 4 },  // P1-P4
   prompts:   { min: 0, max: 6 },  // P0-P6 (all priorities — prompt order is authoritative)
+  security:  { min: 0, max: 2 },  // P0-P2 (critical/high/medium only — low/info skipped)
+  distill:   { min: 1, max: 5 },  // P1-P5 (AI bloat: structural quality, not safety-critical)
 };
 
 /** Category → default mode + budget */
@@ -146,6 +148,8 @@ const CATEGORY_DEFAULTS = {
   docs:      { mode: 'balanced', budget: 30 },
   optimize:  { mode: 'balanced', budget: 50 },
   prompts:   { mode: 'balanced', budget: 100 },
+  security:  { mode: 'bugfix',   budget: 40 },
+  distill:   { mode: 'balanced', budget: 50 },
 };
 
 /** Doc files to scan for staleness (focus sync) */