@sienklogic/plan-build-run 2.18.1 → 2.19.1

package/plugins/pbr/scripts/trust-tracker.js

@@ -0,0 +1,193 @@
+/**
+ * trust-tracker.js — Per-agent pass/fail trust scoring.
+ *
+ * Tracks agent outcomes by type and task category, persisting scores
+ * to .planning/trust/agent-scores.json. Used by confidence calibration
+ * to weight deliverable confidence based on historical accuracy.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const TRUST_DIR = 'trust';
+const TRUST_FILE = 'agent-scores.json';
+
+const HIGH_THRESHOLD = 0.9;
+const MEDIUM_THRESHOLD = 0.7;
+
+/**
+ * Load trust scores from disk.
+ * @param {string} planningDir - Path to .planning directory
+ * @returns {object} Parsed scores or empty object
+ */
+function loadScores(planningDir) {
+  const filePath = path.join(planningDir, TRUST_DIR, TRUST_FILE);
+  try {
+    const raw = fs.readFileSync(filePath, 'utf8');
+    return JSON.parse(raw);
+  } catch (_err) {
+    return {};
+  }
+}
+
+/**
+ * Save trust scores to disk (creates dir if needed).
+ * @param {string} planningDir - Path to .planning directory
+ * @param {object} scores - Scores object to persist
+ */
+function saveScores(planningDir, scores) {
+  const dirPath = path.join(planningDir, TRUST_DIR);
+  fs.mkdirSync(dirPath, { recursive: true });
+  fs.writeFileSync(
+    path.join(dirPath, TRUST_FILE),
+    JSON.stringify(scores, null, 2),
+    'utf8'
+  );
+}
+
+/**
+ * Record a pass or fail outcome for an agent+category.
+ * @param {string} planningDir - Path to .planning directory
+ * @param {string} agentType - Agent identifier (e.g. "executor")
+ * @param {string} taskCategory - Task category (e.g. "build")
+ * @param {boolean} passed - Whether the outcome was a pass
+ */
+function recordOutcome(planningDir, agentType, taskCategory, passed) {
+  const scores = loadScores(planningDir);
+  if (!scores[agentType]) scores[agentType] = {};
+  if (!scores[agentType][taskCategory]) {
+    scores[agentType][taskCategory] = { pass: 0, fail: 0, rate: 0 };
+  }
+  const entry = scores[agentType][taskCategory];
+  if (passed) {
+    entry.pass++;
+  } else {
+    entry.fail++;
+  }
+  const total = entry.pass + entry.fail;
+  entry.rate = total > 0 ? entry.pass / total : 0;
+  saveScores(planningDir, scores);
+  logTrustEvent(planningDir, agentType, taskCategory, passed, entry.rate);
+}
+
+/**
+ * Get confidence data for an agent+category.
+ * @param {string} planningDir - Path to .planning directory
+ * @param {string} agentType - Agent identifier
+ * @param {string} taskCategory - Task category
+ * @returns {{ rate: number, total: number, label: string } | null}
+ */
+function getConfidence(planningDir, agentType, taskCategory) {
+  const scores = loadScores(planningDir);
+  if (!scores[agentType] || !scores[agentType][taskCategory]) return null;
+  const entry = scores[agentType][taskCategory];
+  const total = entry.pass + entry.fail;
+  let label;
+  if (entry.rate >= HIGH_THRESHOLD) {
+    label = 'high';
+  } else if (entry.rate >= MEDIUM_THRESHOLD) {
+    label = 'medium';
+  } else {
+    label = 'low';
+  }
+  return { rate: entry.rate, total, label };
+}
+
+/**
+ * Log a trust event to .planning/logs/trust-events.jsonl for audit trail.
+ * Never throws — failures are silently swallowed.
+ * @param {string} planningDir - Path to .planning directory
+ * @param {string} agent - Agent identifier
+ * @param {string} category - Task category
+ * @param {boolean} passed - Whether the outcome was a pass
+ * @param {number} newRate - Updated pass rate after this outcome
+ */
+function logTrustEvent(planningDir, agent, category, passed, newRate) {
+  try {
+    const logsDir = path.join(planningDir, 'logs');
+    fs.mkdirSync(logsDir, { recursive: true });
+    const entry = {
+      ts: new Date().toISOString(),
+      agent,
+      category,
+      passed,
+      new_rate: newRate
+    };
+    fs.appendFileSync(
+      path.join(logsDir, 'trust-events.jsonl'),
+      JSON.stringify(entry) + '\n',
+      'utf8'
+    );
+  } catch (_err) {
+    // Never throw from audit logging
+  }
+}
+
+/**
+ * Get a confidence summary for an agent across all categories.
+ * @param {string} planningDir - Path to .planning directory
+ * @param {string} agentType - Agent identifier
+ * @returns {{ agent: string, categories: object, overall_rate: number, overall_total: number } | null}
+ */
+function getConfidenceSummary(planningDir, agentType) {
+  const scores = loadScores(planningDir);
+  if (!scores[agentType]) return null;
+  const agentScores = scores[agentType];
+  const categories = {};
+  let totalPass = 0;
+  let totalFail = 0;
+  for (const [cat, entry] of Object.entries(agentScores)) {
+    const total = (entry.pass || 0) + (entry.fail || 0);
+    let label;
+    if (entry.rate >= HIGH_THRESHOLD) {
+      label = 'high';
+    } else if (entry.rate >= MEDIUM_THRESHOLD) {
+      label = 'medium';
+    } else {
+      label = 'low';
+    }
+    categories[cat] = {
+      pass: entry.pass || 0,
+      fail: entry.fail || 0,
+      rate: entry.rate || 0,
+      total,
+      label
+    };
+    totalPass += entry.pass || 0;
+    totalFail += entry.fail || 0;
+  }
+  const overallTotal = totalPass + totalFail;
+  const overallRate = overallTotal > 0 ? totalPass / overallTotal : 0;
+  return {
+    agent: agentType,
+    categories,
+    overall_rate: overallRate,
+    overall_total: overallTotal
+  };
+}
+
+/**
+ * Delete the trust scores file.
+ * @param {string} planningDir - Path to .planning directory
+ */
+function resetScores(planningDir) {
+  const filePath = path.join(planningDir, TRUST_DIR, TRUST_FILE);
+  try {
+    fs.unlinkSync(filePath);
+  } catch (_err) {
+    // File doesn't exist — no-op
+  }
+}
+
+module.exports = {
+  loadScores,
+  recordOutcome,
+  getConfidence,
+  getConfidenceSummary,
+  logTrustEvent,
+  resetScores,
+  TRUST_DIR,
+  TRUST_FILE
+};

package/plugins/pbr/scripts/validate-commit.js

@@ -3,8 +3,12 @@
 /**
  * PreToolUse hook: Validates git commit message format.
  *
- * Expected format: {type}({phase}-{plan}): {description}
- * Valid types: feat, fix, refactor, test, docs, chore
+ * Expected format: {type}({scope}): {description}
+ * Valid types: feat, fix, refactor, test, docs, chore, wip, revert, perf, ci, build
+ *
+ * Scopes: Component names (hooks, skills, agents, cli, dashboard, templates,
+ * plugin, ci, config, tests, commands, refs), descriptive words, quick-{NNN},
+ * planning, or legacy phase-plan numbers ({NN}-{MM}).
  *
  * Also accepts:
  * - Merge commits (starts with "Merge")
@@ -17,12 +21,15 @@
  *   2 = invalid commit message format (blocks the tool)
  */
 
+const fs = require('fs');
 const path = require('path');
 const { execSync } = require('child_process');
 const { logHook } = require('./hook-logger');
 const { logEvent } = require('./event-logger');
+const { resolveConfig } = require('./lib/local-llm/health');
+const { classifyCommit } = require('./lib/local-llm/operations/classify-commit');
 
-const VALID_TYPES = ['feat', 'fix', 'refactor', 'test', 'docs', 'chore', 'wip'];
+const VALID_TYPES = ['feat', 'fix', 'refactor', 'test', 'docs', 'chore', 'wip', 'revert', 'perf', 'ci', 'build'];
 
 const SENSITIVE_PATTERNS = [
   /^\.env$/,                          // .env exactly (not .env.example)
@@ -43,8 +50,8 @@ const SAFE_PATTERNS = [
 ];
 
 // Pattern: type(scope): description
-// Scope can be: NN-MM (phase-plan), quick-NNN, planning, or any word
-const COMMIT_PATTERN = /^(feat|fix|refactor|test|docs|chore|wip)(\([a-zA-Z0-9._-]+\))?:\s+.+/;
+// Scope can be: component name, NN-MM (phase-plan), quick-NNN, planning, or any word
+const COMMIT_PATTERN = /^(feat|fix|refactor|test|docs|chore|wip|revert|perf|ci|build)(\([a-zA-Z0-9._/-]+\))?!?:\s+.+/;
 
 // Merge commits are always allowed
 const MERGE_PATTERN = /^Merge\s/;
@@ -52,9 +59,9 @@ const MERGE_PATTERN = /^Merge\s/;
 // AI co-author patterns to block
 const AI_COAUTHOR_PATTERN = /Co-Authored-By:.*(?:Claude|Anthropic|noreply@anthropic\.com|OpenAI|Copilot|GPT|AI Assistant)/i;
 
-function checkAiCoAuthorResult(command) {
+function checkAiCoAuthorResult(command, sessionId) {
   if (AI_COAUTHOR_PATTERN.test(command)) {
-    logHook('validate-commit', 'PreToolUse', 'block-coauthor', { command: command.substring(0, 200) });
+    logHook('validate-commit', 'PreToolUse', 'block-coauthor', { command: command.substring(0, 200), sessionId });
     return {
       output: {
         decision: 'block',
@@ -66,7 +73,7 @@ function checkAiCoAuthorResult(command) {
   return null;
 }
 
-function checkSensitiveFilesResult() {
+function checkSensitiveFilesResult(sessionId) {
   try {
     const output = execSync('git diff --cached --name-only', { encoding: 'utf8' });
     const files = output.trim().split('\n').filter(Boolean);
@@ -80,7 +87,7 @@ function checkSensitiveFilesResult() {
     });
 
     if (matched.length > 0) {
-      logHook('validate-commit', 'PreToolUse', 'block-sensitive', { files: matched });
+      logHook('validate-commit', 'PreToolUse', 'block-sensitive', { files: matched, sessionId });
       return {
         output: {
           decision: 'block',
@@ -102,6 +109,7 @@ function checkSensitiveFilesResult() {
  */
 function checkCommit(data) {
   const command = data.tool_input?.command || '';
+  const sessionId = data.session_id || null;
 
   // Only validate git commit commands
   if (!isGitCommit(command)) {
@@ -112,19 +120,19 @@ function checkCommit(data) {
   const message = extractCommitMessage(command);
   if (!message) {
     // Could not parse message - let it through (might be --amend or other form)
-    logHook('validate-commit', 'PreToolUse', 'allow', { reason: 'unparseable message' });
+    logHook('validate-commit', 'PreToolUse', 'allow', { reason: 'unparseable message', sessionId });
     return null;
   }
 
   // Validate format
   if (MERGE_PATTERN.test(message)) {
-    logHook('validate-commit', 'PreToolUse', 'allow', { message, reason: 'merge commit' });
+    logHook('validate-commit', 'PreToolUse', 'allow', { message, reason: 'merge commit', sessionId });
     return null;
   }
 
   if (!COMMIT_PATTERN.test(message)) {
-    logHook('validate-commit', 'PreToolUse', 'block', { message });
-    logEvent('workflow', 'commit-validated', { message: message.substring(0, 80), status: 'block' });
+    logHook('validate-commit', 'PreToolUse', 'block', { message, sessionId });
+    logEvent('workflow', 'commit-validated', { message: message.substring(0, 80), status: 'block', sessionId });
     return {
       output: {
         decision: 'block',
@@ -135,26 +143,78 @@ function checkCommit(data) {
   }
 
   // Valid format
-  logHook('validate-commit', 'PreToolUse', 'allow', { message });
-  logEvent('workflow', 'commit-validated', { message: message.substring(0, 80), status: 'allow' });
+  logHook('validate-commit', 'PreToolUse', 'allow', { message, sessionId });
+  logEvent('workflow', 'commit-validated', { message: message.substring(0, 80), status: 'allow', sessionId });
 
   // Check AI co-author
-  const coAuthorResult = checkAiCoAuthorResult(command);
+  const coAuthorResult = checkAiCoAuthorResult(command, sessionId);
   if (coAuthorResult) return coAuthorResult;
 
   // Check sensitive files
-  const sensitiveResult = checkSensitiveFilesResult();
+  const sensitiveResult = checkSensitiveFilesResult(sessionId);
   if (sensitiveResult) return sensitiveResult;
 
   return null;
 }
 
+/**
+ * Load and resolve the local_llm config block from .planning/config.json.
+ * Returns a resolved config (always safe to use — disabled by default on error).
+ */
+function loadLocalLlmConfig(cwd) {
+  try {
+    const configPath = path.join(cwd || process.cwd(), '.planning', 'config.json');
+    const parsed = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+    return resolveConfig(parsed.local_llm);
+  } catch (_e) {
+    return resolveConfig(undefined);
+  }
+}
+
+/**
+ * Async LLM enrichment for commit messages. Returns an advisory string or null.
+ * Called after checkCommit passes (valid format) to provide semantic classification.
+ *
+ * @param {object} data - parsed hook data
+ * @returns {Promise<string|null>}
+ */
+async function enrichCommitLlm(data) {
+  try {
+    const command = data.tool_input?.command || '';
+    const message = extractCommitMessage(command);
+    if (!message) return null;
+
+    const cwd = process.cwd();
+    const llmConfig = loadLocalLlmConfig(cwd);
+    const planningDir = path.join(cwd, '.planning');
+
+    // Get staged files for scope validation
+    let stagedFiles = [];
+    try {
+      const output = execSync('git diff --cached --name-only', { encoding: 'utf8' });
+      stagedFiles = output.trim().split('\n').filter(Boolean);
+    } catch (_e) {
+      // Not in a git repo — skip staged files context
+    }
+
+    const llmResult = await classifyCommit(llmConfig, planningDir, message, stagedFiles, data.session_id);
+    if (llmResult && llmResult.classification !== 'correct') {
+      return 'LLM commit advisory: ' + llmResult.classification +
+        ' (confidence: ' + (llmResult.confidence * 100).toFixed(0) + '%)';
+    }
+    return null;
+  } catch (_llmErr) {
+    // Never propagate LLM errors
+    return null;
+  }
+}
+
 function main() {
   let input = '';
 
   process.stdin.setEncoding('utf8');
   process.stdin.on('data', (chunk) => { input += chunk; });
-  process.stdin.on('end', () => {
+  process.stdin.on('end', async () => {
     try {
       const data = JSON.parse(input);
       const result = checkCommit(data);
@@ -162,9 +222,19 @@ function main() {
         process.stdout.write(JSON.stringify(result.output));
         process.exit(result.exitCode);
       }
+
+      // LLM semantic classification — advisory only (after format validation passes)
+      const llmAdvisory = await enrichCommitLlm(data);
+      if (llmAdvisory) {
+        process.stdout.write(JSON.stringify({
+          additionalContext: '[pbr] ' + llmAdvisory
+        }));
+      }
+
       process.exit(0);
     } catch (_e) {
       // Parse error - don't block
+      process.stdout.write(JSON.stringify({ additionalContext: '⚠ [PBR] validate-commit failed: ' + _e.message }));
       process.exit(0);
     }
   });
@@ -178,6 +248,14 @@ function isGitCommit(command) {
 }
 
 function extractCommitMessage(command) {
+  // Try heredoc first: -m "$(cat <<'EOF'\n...\nEOF\n)" or -m "$(cat <<EOF\n...\nEOF\n)"
+  // Must check before generic -m patterns to avoid capturing heredoc syntax as the message
+  const heredocMatch = command.match(/<<'?EOF'?\s*\n([\s\S]*?)\nEOF/);
+  if (heredocMatch) {
+    // First line of heredoc is the commit message
+    return heredocMatch[1].trim().split('\n')[0].trim();
+  }
+
   // Try -m "message" or -m 'message'
   const mFlagMatch = command.match(/-m\s+["']([^"']+)["']/);
   if (mFlagMatch) return mFlagMatch[1];
@@ -186,15 +264,8 @@ function extractCommitMessage(command) {
   const mFlagMatch2 = command.match(/-m\s+"([^"]+)"/);
   if (mFlagMatch2) return mFlagMatch2[1];
 
-  // Try heredoc: -m "$(cat <<'EOF'\n...\nEOF\n)"
-  const heredocMatch = command.match(/<<'?EOF'?\s*\n([\s\S]*?)\nEOF/);
-  if (heredocMatch) {
-    // First line of heredoc is the commit message
-    return heredocMatch[1].trim().split('\n')[0].trim();
-  }
-
   return null;
 }
 
-module.exports = { checkCommit };
+module.exports = { checkCommit, enrichCommitLlm };
 if (require.main === module || process.argv[1] === __filename) { main(); }

package/plugins/pbr/scripts/validate-skill-args.js

@@ -4,7 +4,7 @@
  * PreToolUse hook: Validates Skill tool arguments before execution.
  *
  * Currently validates:
- *   - /pbr:plan — blocks freeform text arguments that don't match
+ *   - /pbr:plan-phase — blocks freeform text arguments that don't match
  *     valid patterns (phase number, subcommand, flags).
  *
  * When freeform text is detected, analyzes it to suggest the most
@@ -12,13 +12,60 @@
  *
  * Exit codes:
  *   0 = allowed (valid args or non-plan skill)
- *   2 = blocked (freeform text detected for /pbr:plan)
+ *   2 = blocked (freeform text detected for /pbr:plan-phase)
  */
 
+const fs = require('fs');
+const path = require('path');
 const { logHook } = require('./hook-logger');
 
 /**
- * Valid argument patterns for /pbr:plan.
+ * Skills that accept a phase number as their first argument.
+ */
+const PHASE_SKILLS = new Set([
+  'pbr:plan-phase', 'pbr:execute-phase', 'pbr:discuss-phase',
+  'pbr:research-phase', 'pbr:list-phase-assumptions',
+  'pbr:insert-phase', 'pbr:remove-phase'
+]);
+
+/**
+ * Validate that a phase number exists in ROADMAP.md.
+ * Returns null if valid or no roadmap, or an advisory string if phase not found.
+ */
+function validatePhaseExists(phaseNum) {
+  const cwd = process.env.PBR_PROJECT_ROOT || process.cwd();
+  const roadmapPath = path.join(cwd, '.planning', 'ROADMAP.md');
+  try {
+    if (!fs.existsSync(roadmapPath)) return null;
+    const roadmap = fs.readFileSync(roadmapPath, 'utf8');
+    // Look for phase number in roadmap (e.g., "| 03 |" or "## Phase 3")
+    const padded = String(phaseNum).padStart(2, '0');
+    const patterns = [
+      new RegExp(`\\|\\s*${phaseNum}\\s*\\|`),
+      new RegExp(`\\|\\s*${padded}\\s*\\|`),
+      new RegExp(`##\\s+Phase\\s+${phaseNum}\\b`),
+      new RegExp(`##\\s+Phase\\s+${padded}\\b`),
+      new RegExp(`${padded}-[a-z]`)
+    ];
+    if (patterns.some(p => p.test(roadmap))) return null;
+    // Phase not found — extract valid phase numbers
+    const phaseNums = [];
+    const tableRows = roadmap.match(/\|\s*(\d+(?:\.\d+)?)\s*\|/g);
+    if (tableRows) {
+      for (const row of tableRows) {
+        const m = row.match(/\|\s*(\d+(?:\.\d+)?)\s*\|/);
+        if (m) phaseNums.push(m[1]);
+      }
+    }
+    const validList = phaseNums.length > 0 ? ` Valid phases: ${phaseNums.join(', ')}.` : '';
+    return `Phase ${phaseNum} not found in ROADMAP.md.${validList}`;
+  } catch (_e) {
+    return null; // Can't read roadmap — don't block
+  }
+}
+
+/**
+ * Valid argument patterns for /pbr:plan-phase.
  *
  * Matches:
  *   - Empty / whitespace only
@@ -46,7 +93,7 @@ const ROUTE_PATTERNS = [
   },
   {
     pattern: /\b(refactor|redesign|architect|migrate|restructure|overhaul|rewrite|multi-?phase|complex|system|infrastructure)\b/i,
-    skill: '/pbr:plan add',
+    skill: '/pbr:plan-phase add',
     reason: 'Looks like a complex task that needs full planning'
   },
   {
@@ -79,7 +126,28 @@ function checkSkillArgs(data) {
   const skill = toolInput.skill || '';
   const args = toolInput.args || '';
 
-  // Only validate /pbr:plan for now
+  // Phase number existence check for all phase-taking skills
+  const fullSkillName = skill.startsWith('pbr:') ? skill : `pbr:${skill}`;
+  if (PHASE_SKILLS.has(fullSkillName) && args) {
+    const phaseMatch = args.trim().match(/^(\d+(?:\.\d+)?)/);
+    if (phaseMatch) {
+      const warning = validatePhaseExists(phaseMatch[1]);
+      if (warning) {
+        logHook('validate-skill-args', 'PreToolUse', 'phase-not-found', {
+          skill, phase: phaseMatch[1]
+        });
+        return {
+          output: {
+            decision: 'block',
+            reason: `[pbr] ${warning} Check your ROADMAP.md or use /pbr:progress to see current phases.`
+          },
+          exitCode: 2
+        };
+      }
+    }
+  }
+
+  // Only validate pbr:plan (invoked as /pbr:plan-phase) arg format for now
   if (skill !== 'pbr:plan') {
     return null;
   }
@@ -101,17 +169,18 @@ function checkSkillArgs(data) {
 
   return {
     output: {
-      additionalContext: [
-        'BLOCKED: /pbr:plan received freeform text instead of a phase number.',
+      decision: 'block',
+      reason: [
+        'BLOCKED: /pbr:plan-phase received freeform text instead of a phase number.',
         '',
         'The arguments "' + args.substring(0, 80) + (args.length > 80 ? '...' : '') + '" do not match any valid pattern.',
         '',
-        'Valid /pbr:plan usage:',
-        '  /pbr:plan <N>              Plan phase N',
-        '  /pbr:plan <N> --gaps       Create gap-closure plans',
-        '  /pbr:plan add              Add a new phase',
-        '  /pbr:plan insert <N>       Insert a phase at position N',
-        '  /pbr:plan remove <N>       Remove phase N',
+        'Valid /pbr:plan-phase usage:',
+        '  /pbr:plan-phase <N>              Plan phase N',
+        '  /pbr:plan-phase <N> --gaps       Create gap-closure plans',
+        '  /pbr:plan-phase add              Add a new phase',
+        '  /pbr:plan-phase insert <N>       Insert a phase at position N',
+        '  /pbr:plan-phase remove <N>       Remove phase N',
         '',
         'Suggested skill for this text:',
         '  ' + suggestion.skill + ' — ' + suggestion.reason,
@@ -140,11 +209,14 @@ function main() {
 
       process.exit(0);
     } catch (_e) {
-      // Don't block on errors
+      // Don't block on errors — emit valid output for Claude Code
+      process.stderr.write(`[pbr] validate-skill-args error: ${_e.message}
+`);
+      process.stdout.write(JSON.stringify({ decision: "allow", additionalContext: '⚠ [PBR] validate-skill-args failed: ' + _e.message }));
       process.exit(0);
     }
   });
 }
 
-module.exports = { checkSkillArgs, suggestSkill, PLAN_VALID_PATTERN, ROUTE_PATTERNS };
+module.exports = { checkSkillArgs, suggestSkill, validatePhaseExists, PLAN_VALID_PATTERN, ROUTE_PATTERNS, PHASE_SKILLS };
 if (require.main === module || process.argv[1] === __filename) { main(); }