@sienklogic/plan-build-run 2.0.0 → 2.0.1

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

@@ -1,119 +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(); }
+#!/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

@@ -1,45 +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 };
+#!/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 };

package/plugins/pbr/scripts/track-context-budget.js

@@ -1,119 +1,149 @@
-#!/usr/bin/env node
-
-/**
- * PostToolUse hook on Read: Tracks cumulative file reads per skill invocation.
- *
- * Maintains a session-scoped counter in .planning/.context-tracker.
- * Warns when reads exceed thresholds (15 reads or 30k chars).
- * Resets when .active-skill changes (new skill invocation).
- *
- * Exit codes:
- *   0 = always (PostToolUse hook, advisory only)
- */
-
-const fs = require('fs');
-const path = require('path');
-const { logHook } = require('./hook-logger');
-
-const READ_THRESHOLD = 20;
-const CHAR_THRESHOLD = 30000;
-
-function main() {
-  let input = '';
-
-  process.stdin.setEncoding('utf8');
-  process.stdin.on('data', (chunk) => { input += chunk; });
-  process.stdin.on('end', () => {
-    try {
-      const cwd = process.cwd();
-      const planningDir = path.join(cwd, '.planning');
-      if (!fs.existsSync(planningDir)) {
-        process.exit(0);
-      }
-
-      const data = JSON.parse(input);
-      const filePath = data.tool_input?.file_path || '';
-      if (!filePath) {
-        process.exit(0);
-      }
-
-      // Estimate chars read (use limit if provided, otherwise assume ~2000 lines × 40 chars avg)
-      const limit = data.tool_input?.limit;
-      const estimatedChars = limit ? limit * 40 : 80000;
-      // Use actual output length if available
-      const actualChars = data.tool_output ? String(data.tool_output).length : estimatedChars;
-
-      const trackerPath = path.join(planningDir, '.context-tracker');
-      const skillPath = path.join(planningDir, '.active-skill');
-
-      // Check if active skill changed (reset tracker)
-      const currentSkill = readFileSafe(skillPath);
-      let tracker = loadTracker(trackerPath);
-
-      if (tracker.skill !== currentSkill) {
-        tracker = { skill: currentSkill, reads: 0, total_chars: 0, files: [] };
-      }
-
-      // Update tracker
-      tracker.reads += 1;
-      tracker.total_chars += actualChars;
-      if (!tracker.files.includes(filePath)) {
-        tracker.files.push(filePath);
-      }
-
-      // Save tracker
-      try {
-        fs.writeFileSync(trackerPath, JSON.stringify(tracker), 'utf8');
-      } catch (_e) {
-        // Best-effort
-      }
-
-      // Check thresholds
-      if (tracker.reads >= READ_THRESHOLD || tracker.total_chars >= CHAR_THRESHOLD) {
-        const warnings = [];
-        if (tracker.reads >= READ_THRESHOLD) {
-          warnings.push(`${tracker.reads} file reads (threshold: ${READ_THRESHOLD})`);
-        }
-        if (tracker.total_chars >= CHAR_THRESHOLD) {
-          const kChars = Math.round(tracker.total_chars / 1000);
-          warnings.push(`~${kChars}k chars read (threshold: ${CHAR_THRESHOLD / 1000}k)`);
-        }
-
-        logHook('track-context-budget', 'PostToolUse', 'warn', {
-          reads: tracker.reads,
-          total_chars: tracker.total_chars,
-          unique_files: tracker.files.length,
-        });
-
-        const output = {
-          additionalContext: `[Context Budget Warning] ${warnings.join(', ')}. ${tracker.files.length} unique files read. Consider delegating remaining reads to a Task() subagent to protect orchestrator context.`
-        };
-        process.stdout.write(JSON.stringify(output));
-      }
-
-      process.exit(0);
-    } catch (_e) {
-      // Never block on tracking errors
-      process.exit(0);
-    }
-  });
-}
-
-function readFileSafe(filePath) {
-  try {
-    return fs.readFileSync(filePath, 'utf8').trim();
-  } catch (_e) {
-    return '';
-  }
-}
-
-function loadTracker(trackerPath) {
-  try {
-    const content = fs.readFileSync(trackerPath, 'utf8');
-    return JSON.parse(content);
-  } catch (_e) {
-    return { skill: '', reads: 0, total_chars: 0, files: [] };
-  }
-}
-
-main();
+#!/usr/bin/env node
+
+/**
+ * PostToolUse hook on Read: Tracks cumulative file reads per skill invocation.
+ *
+ * Maintains a session-scoped counter in .planning/.context-tracker.
+ * Warns only at meaningful thresholds to reduce noise:
+ *   - Unique files read crosses milestone (10, 20, 30, ...)
+ *   - Total chars read crosses milestone (50k, 100k, 150k, ...)
+ *   - A single file read is unusually large (> 5,000 chars)
+ * Resets when .active-skill changes (new skill invocation).
+ *
+ * Exit codes:
+ *   0 = always (PostToolUse hook, advisory only)
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { logHook } = require('./hook-logger');
+
+const UNIQUE_FILE_MILESTONE = 10;    // warn every 10 unique files
+const CHAR_MILESTONE = 50000;        // warn every 50k chars
+const LARGE_FILE_THRESHOLD = 5000;   // warn if single read > 5k chars
+
+function main() {
+  let input = '';
+
+  process.stdin.setEncoding('utf8');
+  process.stdin.on('data', (chunk) => { input += chunk; });
+  process.stdin.on('end', () => {
+    try {
+      const cwd = process.cwd();
+      const planningDir = path.join(cwd, '.planning');
+      if (!fs.existsSync(planningDir)) {
+        process.exit(0);
+      }
+
+      const data = JSON.parse(input);
+      const filePath = data.tool_input?.file_path || '';
+      if (!filePath) {
+        process.exit(0);
+      }
+
+      // Skip plugin-internal files — these are loaded by the plugin system,
+      // not by the orchestrator, so they shouldn't count against context budget
+      const pluginRoot = process.env.CLAUDE_PLUGIN_ROOT || '';
+      if (pluginRoot) {
+        const normalizedFile = path.resolve(filePath);
+        const normalizedPlugin = path.resolve(pluginRoot);
+        if (normalizedFile.startsWith(normalizedPlugin + path.sep) || normalizedFile === normalizedPlugin) {
+          process.exit(0);
+        }
+      }
+
+      // Estimate chars read (use limit if provided, otherwise assume ~2000 lines × 40 chars avg)
+      const limit = data.tool_input?.limit;
+      const estimatedChars = limit ? limit * 40 : 80000;
+      // Use actual output length if available
+      const actualChars = data.tool_output ? String(data.tool_output).length : estimatedChars;
+
+      const trackerPath = path.join(planningDir, '.context-tracker');
+      const skillPath = path.join(planningDir, '.active-skill');
+
+      // Check if active skill changed (reset tracker)
+      const currentSkill = readFileSafe(skillPath);
+      let tracker = loadTracker(trackerPath);
+
+      if (tracker.skill !== currentSkill) {
+        tracker = { skill: currentSkill, reads: 0, total_chars: 0, files: [] };
+      }
+
+      // Update tracker
+      const prevFileCount = tracker.files.length;
+      tracker.reads += 1;
+      tracker.total_chars += actualChars;
+      if (!tracker.files.includes(filePath)) {
+        tracker.files.push(filePath);
+      }
+
+      // Save tracker
+      try {
+        fs.writeFileSync(trackerPath, JSON.stringify(tracker), 'utf8');
+      } catch (_e) {
+        // Best-effort
+      }
+
+      // Check thresholds — only warn at milestone crossings, not every read
+      const warnings = [];
+
+      // Milestone: unique files read crosses a multiple of UNIQUE_FILE_MILESTONE
+      const curUniqueFiles = tracker.files.length;
+      if (curUniqueFiles >= UNIQUE_FILE_MILESTONE &&
+          Math.floor(curUniqueFiles / UNIQUE_FILE_MILESTONE) > Math.floor(prevFileCount / UNIQUE_FILE_MILESTONE)) {
+        warnings.push(`${curUniqueFiles} unique files read (milestone: every ${UNIQUE_FILE_MILESTONE})`);
+      }
+
+      // Milestone: total chars crosses a multiple of CHAR_MILESTONE
+      const prevChars = tracker.total_chars - actualChars;
+      if (tracker.total_chars >= CHAR_MILESTONE &&
+          Math.floor(tracker.total_chars / CHAR_MILESTONE) > Math.floor(prevChars / CHAR_MILESTONE)) {
+        const kChars = Math.round(tracker.total_chars / 1000);
+        warnings.push(`~${kChars}k chars read (milestone: every ${CHAR_MILESTONE / 1000}k)`);
+      }
+
+      // Single large file warning
+      if (actualChars >= LARGE_FILE_THRESHOLD) {
+        const kChars = Math.round(actualChars / 1000);
+        warnings.push(`large file read (~${kChars}k chars): ${path.basename(filePath)}`);
+      }
+
+      if (warnings.length > 0) {
+        logHook('track-context-budget', 'PostToolUse', 'warn', {
+          reads: tracker.reads,
+          total_chars: tracker.total_chars,
+          unique_files: tracker.files.length,
+        });
+
+        const output = {
+          additionalContext: `[Context Budget Warning] ${warnings.join(', ')}. ${tracker.files.length} unique files read. Consider delegating remaining reads to a Task() subagent to protect orchestrator context.`
+        };
+        process.stdout.write(JSON.stringify(output));
+      }
+
+      process.exit(0);
+    } catch (_e) {
+      // Never block on tracking errors
+      process.exit(0);
+    }
+  });
+}
+
+function readFileSafe(filePath) {
+  try {
+    return fs.readFileSync(filePath, 'utf8').trim();
+  } catch (_e) {
+    return '';
+  }
+}
+
+function loadTracker(trackerPath) {
+  try {
+    const content = fs.readFileSync(trackerPath, 'utf8');
+    return JSON.parse(content);
+  } catch (_e) {
+    return { skill: '', reads: 0, total_chars: 0, files: [] };
+  }
+}
+
+main();