@sienklogic/plan-build-run 2.1.0 → 2.1.1

package/dashboard/vite.config.js

@@ -0,0 +1,41 @@
+import { defineConfig } from 'vite';
+import react from '@vitejs/plugin-react';
+
+const backendPort = process.env.PBR_DASHBOARD_PORT || '3141';
+
+export default defineConfig({
+  plugins: [react()],
+  server: {
+    port: 5173,
+    proxy: {
+      '/api': { target: `http://localhost:${backendPort}`, changeOrigin: true },
+      '/ws': { target: `ws://localhost:${backendPort}`, ws: true },
+    },
+  },
+  build: {
+    rollupOptions: {
+      output: {
+        manualChunks(id) {
+          if (id.includes('node_modules/recharts')) {
+            return 'recharts';
+          }
+          if (id.includes('node_modules/d3-') || id.includes('node_modules/internmap') || id.includes('node_modules/delaunator') || id.includes('node_modules/robust-predicates')) {
+            return 'recharts-deps';
+          }
+          if (id.includes('node_modules/react-dom')) {
+            return 'react-vendor';
+          }
+          if (id.includes('node_modules/react/') || id.includes('node_modules/react-is') || id.includes('node_modules/scheduler')) {
+            return 'react-vendor';
+          }
+        },
+      },
+    },
+  },
+  test: {
+    environment: 'jsdom',
+    globals: true,
+    setupFiles: ['./tests/setup.js'],
+    include: ['tests/**/*.test.{js,jsx}'],
+  },
+});

package/hooks/dist/auto-continue.js

@@ -0,0 +1,201 @@
+#!/usr/bin/env node
+
+/**
+ * Stop hook: Auto-continue via signal files.
+ *
+ * When enabled (features.auto_continue: true in config.json),
+ * reads .planning/.auto-next signal file on session stop.
+ * If present, reads the next command and injects it.
+ * Signal file is ONE-SHOT: read and delete to prevent infinite loops.
+ *
+ * Hard stops (signal file NOT written):
+ * - Milestone completion
+ * - human_needed flag set
+ * - Execution errors
+ * - Gap closure attempted 3+ times
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { spawn } = require('child_process');
+const { logHook } = require('./hook-logger');
+const { configLoad } = require('../plan-build-run/bin/lib/config.cjs');
+const { loadTracker } = require('./session-tracker');
+const { resolveSessionPath } = require('../plan-build-run/bin/lib/core.cjs');
+
+function main() {
+  try {
+    // Parse hook input from stdin (Claude Code passes JSON with stop_hook_active flag)
+    let hookInput = {};
+    try {
+      const stdin = fs.readFileSync(0, 'utf8').trim();
+      if (stdin) hookInput = JSON.parse(stdin);
+    } catch (_parseErr) {
+      // No stdin or invalid JSON — proceed with defaults
+    }
+
+    // Guard against infinite loops: if we're already in a Stop hook continuation, bail out
+    if (hookInput.stop_hook_active) {
+      logHook('auto-continue', 'Stop', 'already-active', {});
+      process.exit(0);
+    }
+
+    const cwd = hookInput.cwd || process.cwd();
+    const planningDir = path.join(cwd, '.planning');
+    const sessionId = hookInput.session_id || null;
+    const signalPath = sessionId
+      ? resolveSessionPath(planningDir, '.auto-next', sessionId)
+      : path.join(planningDir, '.auto-next');
+
+    // Check if auto-continue is enabled
+    const config = configLoad(planningDir);
+    if (!config || !config.features || !config.features.auto_continue) {
+      process.exit(0);
+    }
+
+    // Phase-limit detection: check if session has completed enough phases to trigger a cycle
+    const tracker = loadTracker(planningDir, sessionId);
+    const phaseLimit = (config.session_phase_limit !== undefined) ? config.session_phase_limit : 3;
+    if (phaseLimit > 0 && tracker && tracker.phases_completed >= phaseLimit) {
+      // Write signal file with /pbr:pause-work to trigger the pause chain
+      try { fs.writeFileSync(signalPath, '/pbr:pause-work', 'utf8'); } catch (_writeErr) { /* ignore */ }
+
+      let reasonStr;
+      const cyclingMethod = config.session_cycling || (process.env.TMUX ? 'tmux' : 'compact');
+      if (cyclingMethod === 'tmux') {
+        // TMUX environment: spawn detached process to auto-cycle
+        // On Windows, Claude Code's bash is MSYS2 (no tmux) — bridge through wsl.exe to reach the WSL tmux server
+        // On Linux/macOS, tmux is available directly
+        const isWindows = process.platform === 'win32';
+        let cycleCmd;
+        if (isWindows) {
+          // Use pbr-tmux cycle which handles pane targeting via WSL tmux
+          cycleCmd = 'sleep 3 && wsl.exe -d Ubuntu -- pbr-tmux cycle --non-interactive';
+        } else {
+          cycleCmd = 'sleep 3 && tmux send-keys "/clear" Enter && sleep 1 && tmux send-keys "/pbr:resume-work" Enter';
+        }
+        const child = spawn('bash', ['-c', cycleCmd], { detached: true, stdio: 'ignore' });
+        child.unref();
+        logHook('auto-continue', 'Stop', 'cycle-tmux', { phases: tracker.phases_completed, limit: phaseLimit, bridge: isWindows ? 'wsl' : 'native' });
+        reasonStr = 'Auto-continue: execute /pbr:pause-work \u2014 Session checkpoint after ' + tracker.phases_completed + ' phases. TMUX auto-cycle will send /clear + /pbr:resume-work after pause completes.';
+      } else if (cyclingMethod === 'compact') {
+        // Compact mode: keep session alive, compress context, then continue
+        logHook('auto-continue', 'Stop', 'cycle-compact', { phases: tracker.phases_completed, limit: phaseLimit });
+        reasonStr = 'Auto-continue: session checkpoint after ' + tracker.phases_completed + ' phases.\n\n'
+          + 'IMPORTANT: Context cycling required. You MUST do these steps IN ORDER:\n'
+          + '1. Run /pbr:pause-work to save session state\n'
+          + '2. Run /compact to compress context\n'
+          + '3. Run /pbr:resume-work to continue with fresh context\n\n'
+          + 'Execute /pbr:pause-work now.';
+      } else {
+        // Manual mode or unknown: show checkpoint banner with manual instructions
+        logHook('auto-continue', 'Stop', 'cycle-banner', { phases: tracker.phases_completed, limit: phaseLimit });
+        reasonStr = 'Auto-continue: execute /pbr:pause-work \u2014 Session checkpoint after ' + tracker.phases_completed + ' phases.\n\n'
+          + '+==============================================================+\n'
+          + '|  PLAN-BUILD-RUN > SESSION CHECKPOINT                         |\n'
+          + '+==============================================================+\n\n'
+          + 'Context cycling recommended after ' + tracker.phases_completed + ' phases completed.\n'
+          + 'After pause completes, run:\n\n'
+          + '  1. /clear\n'
+          + '  2. /pbr:resume-work\n';
+      }
+
+      process.stdout.write(JSON.stringify({ decision: 'block', reason: reasonStr }));
+      process.exit(0);
+    }
+
+    // Check for signal file
+    if (!fs.existsSync(signalPath)) {
+      // No auto-continue signal — check for pending todos as a reminder
+      const todoPendingDir = path.join(planningDir, 'todos', 'pending');
+      try {
+        if (fs.existsSync(todoPendingDir)) {
+          const pending = fs.readdirSync(todoPendingDir).filter(f => f.endsWith('.md'));
+          if (pending.length > 0) {
+            logHook('auto-continue', 'Stop', 'pending-todos', { count: pending.length });
+            // Non-blocking reminder — write to stderr so it shows in hook output
+            process.stderr.write(`[pbr] ${pending.length} pending todo(s) in .planning/todos/pending/ — run /pbr:todo list to review\n`);
+          }
+        }
+      } catch (_todoErr) {
+        // Ignore errors scanning todos
+      }
+      // Reset continue count on normal session stop (no signal)
+      const countPathNoSig = path.join(planningDir, '.continue-count');
+      try { fs.unlinkSync(countPathNoSig); } catch (_e) { /* ignore */ }
+      logHook('auto-continue', 'Stop', 'no-signal', {});
+      process.exit(0);
+    }
+
+    // Read and DELETE the signal file (one-shot)
+    const nextCommand = fs.readFileSync(signalPath, 'utf8').trim();
+    // Retry unlink with exponential backoff for Windows file locking (antivirus/indexer)
+    for (let attempt = 0; attempt < 3; attempt++) {
+      try {
+        fs.unlinkSync(signalPath);
+        break;
+      } catch (unlinkErr) {
+        if (attempt === 2) {
+          logHook('auto-continue', 'Stop', 'unlink-failed', { error: unlinkErr.message });
+        } else {
+          // Exponential backoff: 100ms, 200ms — use Atomics.wait for non-spinning delay
+          const delay = 100 * Math.pow(2, attempt);
+          try {
+            const buf = new SharedArrayBuffer(4);
+            Atomics.wait(new Int32Array(buf), 0, 0, delay);
+          } catch (_atomicsErr) {
+            // No SharedArrayBuffer — skip delay, retry immediately
+          }
+        }
+      }
+    }
+
+    if (!nextCommand) {
+      logHook('auto-continue', 'Stop', 'empty-signal', {});
+      process.exit(0);
+    }
+
+    // Track consecutive continues for session length guard
+    const countPath = path.join(planningDir, '.continue-count');
+    let continueCount = 0;
+    try {
+      continueCount = parseInt(fs.readFileSync(countPath, 'utf8').trim(), 10) || 0;
+    } catch (_e) { /* file missing — start at 0 */ }
+    continueCount++;
+    try { fs.writeFileSync(countPath, String(continueCount)); } catch (_e) { /* ignore */ }
+
+    // Hard stop after 6 consecutive continues — context is likely degraded
+    if (continueCount > 6) {
+      logHook('auto-continue', 'Stop', 'hard-stop-session-length', { count: continueCount });
+      process.exit(0);
+    }
+
+    // Extract last_assistant_message for richer continuation context
+    const lastMsg = hookInput.last_assistant_message || '';
+    const msgSuffix = lastMsg
+      ? ` (last message excerpt: ${lastMsg.slice(0, 200)})`
+      : '';
+
+    logHook('auto-continue', 'Stop', 'continue', { next: nextCommand, hasLastMsg: !!lastMsg, continueCount });
+
+    // Build reason string with optional advisory
+    let reasonStr = `Auto-continue: execute ${nextCommand}${msgSuffix}`;
+    if (continueCount > 3) {
+      reasonStr += `\n\n[pbr] Advisory: ${continueCount} consecutive continues. Consider /pbr:pause-work + fresh session to avoid context degradation.`;
+    }
+
+    // Block the stop and inject the next command as Claude's continuation reason.
+    // Claude Code Stop hooks use { decision: "block", reason: "..." } to keep going.
+    const output = {
+      decision: 'block',
+      reason: reasonStr
+    };
+    process.stdout.write(JSON.stringify(output));
+    process.exit(0);
+  } catch (_e) {
+    // Don't block on errors
+    process.exit(0);
+  }
+}
+
+main();

package/hooks/dist/block-skill-self-read.js

@@ -0,0 +1,77 @@
+#!/usr/bin/env node
+
+/**
+ * PreToolUse Read hook: blocks skills from re-reading their own SKILL.md.
+ *
+ * Skills are already loaded into context by Claude Code — re-reading
+ * wastes ~13k tokens. This hook checks .planning/.active-skill to
+ * determine the current skill and blocks if the Read target matches.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { logHook } = require('./hook-logger');
+const { resolveSessionPath } = require('../plan-build-run/bin/lib/core.cjs');
+
+function main() {
+  try {
+    let hookInput = {};
+    try {
+      const stdin = fs.readFileSync(0, 'utf8').trim();
+      if (stdin) hookInput = JSON.parse(stdin);
+    } catch (_parseErr) {
+      // No stdin or invalid JSON
+    }
+
+    const cwd = hookInput.cwd || process.cwd();
+    const toolInput = hookInput.tool_input || {};
+    const filePath = toolInput.file_path || '';
+
+    if (!filePath) {
+      process.exit(0);
+    }
+
+    // Read .active-skill to get current skill name (session-scoped)
+    const sessionId = hookInput.session_id || null;
+    const planningDir = path.join(cwd, '.planning');
+    const activeSkillPath = sessionId
+      ? resolveSessionPath(planningDir, '.active-skill', sessionId)
+      : path.join(planningDir, '.active-skill');
+    let skillName = '';
+    try {
+      skillName = fs.readFileSync(activeSkillPath, 'utf8').trim();
+    } catch (_readErr) {
+      // No .active-skill file — nothing to block
+      process.exit(0);
+    }
+
+    if (!skillName) {
+      process.exit(0);
+    }
+
+    // Check if file_path ends with skills/{skill-name}/SKILL.md
+    const normalized = filePath.replace(/\\/g, '/');
+    const pattern = `skills/${skillName}/SKILL.md`.toLowerCase();
+    const match = normalized.toLowerCase().endsWith(pattern);
+
+    if (match) {
+      logHook('block-skill-self-read', 'PreToolUse', 'block', { skill: skillName, file: filePath });
+      const output = {
+        decision: 'block',
+        reason: `SKILL.md self-read blocked.\n\nThe active skill (${skillName}) attempted to read its own SKILL.md. Skills are already loaded into context by Claude Code \u2014 re-reading wastes ~13k tokens.\n\nNo action needed. The skill content is already available in your prompt.`
+      };
+      process.stdout.write(JSON.stringify(output));
+    } else {
+      logHook('block-skill-self-read', 'PreToolUse', 'allow', { skill: skillName, file: filePath });
+    }
+
+    process.exit(0);
+  } catch (_e) {
+    // Don't block on errors
+    process.exit(0);
+  }
+}
+
+main();

package/hooks/dist/branding-audit.js

@@ -0,0 +1,232 @@
+#!/usr/bin/env node
+"use strict";
+
+/**
+ * branding-audit.js — Detect upstream GSD framework references in PBR code.
+ *
+ * Usage:  node scripts/branding-audit.js [directory]
+ *
+ * Scans the target directory (default: plugins/pbr/) for two categories of
+ * upstream framework leakage:
+ *   1. String matches  — literal references to GSD naming
+ *   2. Structural patterns — file names, imports, path refs, template vars
+ *
+ * Exit 0 (PASS) when zero matches found; exit 1 (FAIL) otherwise.
+ */
+
+const fs = require("fs");
+const path = require("path");
+
+// ---------------------------------------------------------------------------
+// Configuration
+// ---------------------------------------------------------------------------
+
+const SCAN_EXTENSIONS = new Set([".js", ".md", ".tmpl", ".json"]);
+const SKIP_DIRS = new Set(["node_modules", ".git"]);
+
+// Category 1: String match patterns (applied per-line)
+const STRING_PATTERNS = [
+  { name: "get-shit-done (hyphenated)", regex: /get-shit-done/gi },
+  { name: "get.shit.done (dotted)", regex: /get\.shit\.done/gi },
+  { name: "gsd (standalone word)", regex: /\bgsd\b/gi },
+  { name: "/gsd: (slash-command)", regex: /\/gsd:/gi },
+  { name: "gsd-tools (tool name)", regex: /gsd-tools/gi },
+  { name: "gsd-verifier (agent name)", regex: /gsd-verifier/gi },
+];
+
+// Category 2: Structural patterns (applied per-line)
+const STRUCTURAL_PATTERNS = [
+  {
+    name: "require/import gsd module",
+    regex: /(?:require\s*\(\s*['"][^'"]*gsd[^'"]*['"]\s*\))|(?:from\s+['"][^'"]*gsd[^'"]*['"])/gi,
+  },
+  {
+    name: "workflow path with gsd",
+    regex: /(?:get-shit-done|\.claude\/get-shit-done)/gi,
+  },
+  {
+    name: "gsd_ template variable",
+    regex: /\bgsd_\w+/gi,
+  },
+];
+
+// ---------------------------------------------------------------------------
+// File collection
+// ---------------------------------------------------------------------------
+
+function collectFiles(dir, selfPath) {
+  const results = [];
+
+  let entries;
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return results;
+  }
+
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+
+    if (entry.isDirectory()) {
+      if (!SKIP_DIRS.has(entry.name)) {
+        results.push(...collectFiles(fullPath, selfPath));
+      }
+      continue;
+    }
+
+    if (!entry.isFile()) continue;
+
+    // Skip self
+    if (path.resolve(fullPath) === selfPath) continue;
+
+    const ext = path.extname(entry.name).toLowerCase();
+    if (!SCAN_EXTENSIONS.has(ext)) continue;
+
+    results.push(fullPath);
+  }
+
+  return results;
+}
+
+// ---------------------------------------------------------------------------
+// File-name structural check
+// ---------------------------------------------------------------------------
+
+function checkFileName(filePath) {
+  const base = path.basename(filePath).toLowerCase();
+  if (/gsd/i.test(base)) {
+    return { pattern: "gsd in filename", file: filePath, line: 0, text: base };
+  }
+  return null;
+}
+
+// ---------------------------------------------------------------------------
+// Line scanning
+// ---------------------------------------------------------------------------
+
+function scanFile(filePath) {
+  const stringMatches = [];
+  const structuralMatches = [];
+
+  let content;
+  try {
+    content = fs.readFileSync(filePath, "utf8");
+  } catch {
+    return { stringMatches, structuralMatches };
+  }
+
+  const lines = content.split(/\r?\n/);
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const lineNum = i + 1;
+
+    for (const pat of STRING_PATTERNS) {
+      pat.regex.lastIndex = 0;
+      if (pat.regex.test(line)) {
+        stringMatches.push({
+          pattern: pat.name,
+          file: filePath,
+          line: lineNum,
+          text: line.trim(),
+        });
+      }
+    }
+
+    for (const pat of STRUCTURAL_PATTERNS) {
+      pat.regex.lastIndex = 0;
+      if (pat.regex.test(line)) {
+        structuralMatches.push({
+          pattern: pat.name,
+          file: filePath,
+          line: lineNum,
+          text: line.trim(),
+        });
+      }
+    }
+  }
+
+  return { stringMatches, structuralMatches };
+}
+
+// ---------------------------------------------------------------------------
+// Reporting
+// ---------------------------------------------------------------------------
+
+function printCategory(label, matches) {
+  if (matches.length === 0) {
+    console.log(`\n  ${label}: 0 matches`);
+    return;
+  }
+
+  console.log(`\n  ${label}: ${matches.length} match(es)`);
+
+  // Group by pattern
+  const groups = {};
+  for (const m of matches) {
+    if (!groups[m.pattern]) groups[m.pattern] = [];
+    groups[m.pattern].push(m);
+  }
+
+  for (const [pattern, items] of Object.entries(groups)) {
+    console.log(`    [${pattern}]`);
+    for (const item of items) {
+      const loc = item.line > 0 ? `${item.file}:${item.line}` : item.file;
+      console.log(`      ${loc}  ${item.text}`);
+    }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+
+function main() {
+  const targetDir = process.argv[2] || "plugins/pbr/";
+  const resolved = path.resolve(targetDir);
+  const selfPath = path.resolve(__filename);
+
+  if (!fs.existsSync(resolved)) {
+    console.error(`Error: directory not found: ${resolved}`);
+    process.exit(2);
+  }
+
+  console.log(`Branding audit: scanning ${resolved}`);
+
+  const files = collectFiles(resolved, selfPath);
+  console.log(`Files to scan: ${files.length}`);
+
+  const allString = [];
+  const allStructural = [];
+
+  // Check file names first
+  for (const f of files) {
+    const hit = checkFileName(f);
+    if (hit) allStructural.push(hit);
+  }
+
+  // Scan file contents
+  for (const f of files) {
+    const { stringMatches, structuralMatches } = scanFile(f);
+    allString.push(...stringMatches);
+    allStructural.push(...structuralMatches);
+  }
+
+  const total = allString.length + allStructural.length;
+
+  console.log("\n--- Results ---");
+  printCategory("String matches", allString);
+  printCategory("Structural patterns", allStructural);
+
+  console.log("\n" + "=".repeat(60));
+  if (total === 0) {
+    console.log("BRANDING AUDIT: PASS (0 matches)");
+    process.exit(0);
+  } else {
+    console.log(`BRANDING AUDIT: FAIL (${total} matches)`);
+    process.exit(1);
+  }
+}
+
+if (require.main === module || process.argv[1] === __filename) { main(); }
+module.exports = { collectFiles, scanFile, checkFileName };

package/hooks/dist/check-agent-state-write.js

@@ -0,0 +1,63 @@
+#!/usr/bin/env node
+
+/**
+ * PreToolUse hook: Blocks subagents (except pbr:general) from writing STATE.md.
+ *
+ * STATE.md is the source of truth for project position and should only be
+ * written by skills (orchestrators) or the general agent, never by specialized
+ * agents like executor, planner, or verifier.
+ *
+ * Detection: reads .planning/.active-agent (written by log-subagent.js).
+ *
+ * Exit codes:
+ *   0 = allowed or not applicable
+ *   2 = blocked (agent not allowed to write STATE.md)
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const BLOCKED_AGENTS = [
+  'pbr:executor',
+  'pbr:planner',
+  'pbr:verifier',
+  'pbr:researcher',
+  'pbr:plan-checker',
+  'pbr:integration-checker',
+  'pbr:debugger',
+  'pbr:codebase-mapper',
+  'pbr:synthesizer',
+  'pbr:audit',
+];
+
+function checkAgentStateWrite(data) {
+  const filePath = data.tool_input?.file_path || data.tool_input?.path || '';
+  if (!filePath) return null;
+
+  const normalized = filePath.replace(/\\/g, '/');
+  if (!normalized.endsWith('.planning/STATE.md')) return null;
+
+  // Check if we're inside a subagent
+  const cwd = process.cwd();
+  const agentFile = path.join(cwd, '.planning', '.active-agent');
+
+  let agent;
+  try {
+    agent = fs.readFileSync(agentFile, 'utf8').trim();
+  } catch (_e) {
+    // No .active-agent file — not in an agent context
+    return null;
+  }
+
+  if (!agent || !BLOCKED_AGENTS.includes(agent)) return null;
+
+  return {
+    exitCode: 2,
+    output: {
+      decision: 'block',
+      reason: `Agent write to STATE.md blocked.\n\n${agent} is not allowed to write STATE.md. Only skills (orchestrators) and pbr:general may update this file to prevent state corruption.\n\nReturn results to the calling skill and let it update STATE.md.`
+    }
+  };
+}
+
+module.exports = { checkAgentStateWrite, BLOCKED_AGENTS };