@sienklogic/plan-build-run 2.7.0 → 2.8.0

package/CHANGELOG.md

@@ -5,6 +5,15 @@ All notable changes to Plan-Build-Run will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [2.8.0](https://github.com/SienkLogic/plan-build-run/compare/plan-build-run-v2.7.0...plan-build-run-v2.8.0) (2026-02-20)
+
+
+### Features
+
+* **03-01:** add review verifier, milestone complete, and build dependency gates ([bda474d](https://github.com/SienkLogic/plan-build-run/commit/bda474d8b88b128464df375d62de9acdeb9dff05))
+* **04-01:** add post-artifact validation for begin/plan/build and VERIFICATION.md ([3cb4bc1](https://github.com/SienkLogic/plan-build-run/commit/3cb4bc1c0f277c6beca99f7c336fba5e7376f9ec))
+* **05-01:** add STATE.md validation, checkpoint manifest check, and active-skill integrity warning ([d780d97](https://github.com/SienkLogic/plan-build-run/commit/d780d97e620915cb05e70372ce8c9d6003fd1ac8))
+
 ## [2.7.0](https://github.com/SienkLogic/plan-build-run/compare/plan-build-run-v2.6.0...plan-build-run-v2.7.0) (2026-02-19)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sienklogic/plan-build-run",
-  "version": "2.7.0",
+  "version": "2.8.0",
   "description": "Plan it, Build it, Run it — structured development workflow for Claude Code",
   "keywords": [
     "claude-code",

package/plugins/copilot-pbr/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "pbr",
   "displayName": "Plan-Build-Run",
-  "version": "2.7.0",
+  "version": "2.8.0",
   "description": "Plan-Build-Run — Structured development workflow for GitHub Copilot CLI. Solves context rot through disciplined agent delegation, structured planning, atomic execution, and goal-backward verification.",
   "author": {
     "name": "SienkLogic",

package/plugins/copilot-pbr/setup.sh

@@ -37,7 +37,7 @@ fi
 if command -v copilot &> /dev/null; then
   echo "Found Copilot CLI. Installing plugin via 'copilot plugin install'..."
   echo ""
-  copilot plugin install --local "$PLUGIN_DIR"
+  copilot plugin install "$PLUGIN_DIR"
   echo ""
   echo "Plugin installed successfully via Copilot CLI."
 else

package/plugins/cursor-pbr/.cursor-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "pbr",
   "displayName": "Plan-Build-Run",
-  "version": "2.7.0",
+  "version": "2.8.0",
   "description": "Plan-Build-Run — Structured development workflow for Cursor. Solves context rot through disciplined subagent delegation, structured planning, atomic execution, and goal-backward verification.",
   "author": {
     "name": "SienkLogic",

package/plugins/pbr/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "pbr",
-  "version": "2.7.0",
+  "version": "2.8.0",
   "description": "Plan-Build-Run — Structured development workflow for Claude Code. Solves context rot through disciplined subagent delegation, structured planning, atomic execution, and goal-backward verification.",
   "author": {
     "name": "SienkLogic",

package/plugins/pbr/scripts/check-plan-format.js

@@ -42,7 +42,9 @@ function main() {
       const isPlan = basename.endsWith('PLAN.md');
       const isSummary = basename.includes('SUMMARY') && basename.endsWith('.md');
 
-      if (!isPlan && !isSummary) {
+      const isVerification = basename === 'VERIFICATION.md';
+
+      if (!isPlan && !isSummary && !isVerification) {
         process.exit(0);
       }
 
@@ -53,9 +55,11 @@ function main() {
       const content = fs.readFileSync(filePath, 'utf8');
       const result = isPlan
         ? validatePlan(content, filePath)
-        : validateSummary(content, filePath);
+        : isVerification
+          ? validateVerification(content, filePath)
+          : validateSummary(content, filePath);
 
-      const eventType = isPlan ? 'plan-validated' : 'summary-validated';
+      const eventType = isPlan ? 'plan-validated' : isVerification ? 'verification-validated' : 'summary-validated';
 
       if (result.errors.length > 0) {
         // Structural errors — block and force correction
@@ -231,16 +235,19 @@ function checkPlanWrite(data) {
   const basename = path.basename(filePath);
   const isPlan = basename.endsWith('PLAN.md');
   const isSummary = basename.includes('SUMMARY') && basename.endsWith('.md');
+  const isVerification = basename === 'VERIFICATION.md';
 
-  if (!isPlan && !isSummary) return null;
+  if (!isPlan && !isSummary && !isVerification) return null;
   if (!fs.existsSync(filePath)) return null;
 
   const content = fs.readFileSync(filePath, 'utf8');
   const result = isPlan
     ? validatePlan(content, filePath)
-    : validateSummary(content, filePath);
+    : isVerification
+      ? validateVerification(content, filePath)
+        : validateSummary(content, filePath);
 
-  const eventType = isPlan ? 'plan-validated' : 'summary-validated';
+  const eventType = isPlan ? 'plan-validated' : isVerification ? 'verification-validated' : 'summary-validated';
 
   if (result.errors.length > 0) {
     logHook('check-plan-format', 'PostToolUse', 'block', { file: basename, errors: result.errors });
@@ -266,5 +273,80 @@ function checkPlanWrite(data) {
   return null;
 }
 
-module.exports = { validatePlan, validateSummary, checkPlanWrite };
+function validateState(content, _filePath) {
+  const errors = [];
+  const warnings = [];
+
+  // STATE.md uses warnings (not errors) because it's written by multiple hooks
+  // and auto-sync processes. Blocking would create feedback loops.
+  if (!content.startsWith('---')) {
+    warnings.push('Missing YAML frontmatter');
+  } else {
+    const frontmatterEnd = content.indexOf('---', 3);
+    if (frontmatterEnd === -1) {
+      warnings.push('Unclosed YAML frontmatter');
+    } else {
+      const frontmatter = content.substring(3, frontmatterEnd);
+      const requiredFields = ['version', 'current_phase', 'total_phases', 'phase_slug', 'status'];
+      for (const field of requiredFields) {
+        if (!frontmatter.includes(`${field}:`)) {
+          warnings.push(`Frontmatter missing "${field}" field`);
+        }
+      }
+    }
+  }
+
+  return { errors, warnings };
+}
+
+function validateVerification(content, _filePath) {
+  const errors = [];
+  const warnings = [];
+
+  if (!content.startsWith('---')) {
+    errors.push('Missing YAML frontmatter');
+  } else {
+    const frontmatterEnd = content.indexOf('---', 3);
+    if (frontmatterEnd === -1) {
+      errors.push('Unclosed YAML frontmatter');
+    } else {
+      const frontmatter = content.substring(3, frontmatterEnd);
+      const requiredFields = ['status', 'phase', 'checked_at', 'must_haves_checked', 'must_haves_passed', 'must_haves_failed'];
+      for (const field of requiredFields) {
+        if (!frontmatter.includes(`${field}:`)) {
+          errors.push(`Frontmatter missing "${field}" field`);
+        }
+      }
+    }
+  }
+
+  return { errors, warnings };
+}
+
+/**
+ * Separate STATE.md validation for use by dispatchers.
+ * Kept separate from checkPlanWrite because STATE.md routing in the
+ * dispatcher must happen AFTER roadmap sync (which also triggers on STATE.md).
+ */
+function checkStateWrite(data) {
+  const filePath = data.tool_input?.file_path || data.tool_input?.path || '';
+  const basename = path.basename(filePath);
+  if (basename !== 'STATE.md') return null;
+  if (!fs.existsSync(filePath)) return null;
+
+  const content = fs.readFileSync(filePath, 'utf8');
+  const result = validateState(content, filePath);
+
+  if (result.warnings.length > 0) {
+    logHook('check-plan-format', 'PostToolUse', 'warn', { file: basename, warnings: result.warnings });
+    logEvent('workflow', 'state-validated', { file: basename, status: 'warn', warningCount: result.warnings.length });
+    return { output: { additionalContext: `${basename} warnings:\n${result.warnings.map(i => `  - ${i}`).join('\n')}` } };
+  }
+
+  logHook('check-plan-format', 'PostToolUse', 'pass', { file: basename });
+  logEvent('workflow', 'state-validated', { file: basename, status: 'pass' });
+  return null;
+}
+
+module.exports = { validatePlan, validateSummary, validateVerification, validateState, checkPlanWrite, checkStateWrite };
 if (require.main === module || process.argv[1] === __filename) { main(); }

package/plugins/pbr/scripts/check-subagent-output.js

@@ -188,6 +188,30 @@ function findInQuickDir(planningDir, pattern) {
   return matches;
 }
 
+function checkSummaryCommits(planningDir, foundFiles, warnings) {
+  // Look for SUMMARY files in found list
+  const summaryFiles = foundFiles.filter(f => /SUMMARY/i.test(f));
+  for (const relPath of summaryFiles) {
+    try {
+      const fullPath = path.join(planningDir, relPath);
+      const content = fs.readFileSync(fullPath, 'utf8');
+      // Parse frontmatter for commits field
+      const fmMatch = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+      if (!fmMatch) continue;
+      const fm = fmMatch[1];
+      const commitsMatch = fm.match(/commits:\s*(\[.*?\]|.*)/);
+      if (!commitsMatch) {
+        warnings.push(`${relPath}: No "commits" field in frontmatter. Executor should record commit hashes.`);
+        continue;
+      }
+      const commitsVal = commitsMatch[1].trim();
+      if (commitsVal === '[]' || commitsVal === '' || commitsVal === '~' || commitsVal === 'null') {
+        warnings.push(`${relPath}: "commits" field is empty. Executor may have failed to commit changes.`);
+      }
+    } catch (_e) { /* best-effort */ }
+  }
+}
+
 function readStdin() {
   try {
     const input = fs.readFileSync(0, 'utf8').trim();
@@ -217,20 +241,72 @@ function main() {
     process.exit(0);
   }
 
+  // Read active skill
+  let activeSkill = '';
+  try {
+    activeSkill = fs.readFileSync(path.join(planningDir, '.active-skill'), 'utf8').trim();
+  } catch (_e) { /* no active skill */ }
+
   // Check for expected outputs
   const found = outputSpec.check(planningDir);
 
-  if (found.length === 0 && !outputSpec.noFileExpected) {
+  const genericMissing = found.length === 0 && !outputSpec.noFileExpected;
+
+  // Skill-specific post-completion validation
+  const skillWarnings = [];
+
+  // GAP-04: Begin planner must produce core files
+  if (activeSkill === 'begin' && agentType === 'pbr:planner') {
+    const coreFiles = ['REQUIREMENTS.md', 'ROADMAP.md', 'STATE.md'];
+    for (const f of coreFiles) {
+      if (!fs.existsSync(path.join(planningDir, f))) {
+        skillWarnings.push(`Begin planner: ${f} was not created. The project may be in an incomplete state.`);
+      }
+    }
+  }
+
+  // GAP-05: Plan researcher should produce phase-level RESEARCH.md
+  if (activeSkill === 'plan' && agentType === 'pbr:researcher') {
+    const phaseResearch = findInPhaseDir(planningDir, /^RESEARCH\.md$/i);
+    if (found.length === 0 && phaseResearch.length === 0) {
+      skillWarnings.push('Plan researcher: No research output found in .planning/research/ or in the phase directory.');
+    }
+  }
+
+  // GAP-06: Build executor SUMMARY should have commits
+  if (activeSkill === 'build' && agentType === 'pbr:executor') {
+    checkSummaryCommits(planningDir, found, skillWarnings);
+  }
+
+  // Output logic: avoid duplicating warnings
+  if (genericMissing && skillWarnings.length > 0) {
+    logHook('check-subagent-output', 'PostToolUse', 'skill-warning', {
+      skill: activeSkill,
+      agent_type: agentType,
+      warnings: skillWarnings
+    });
+    const msg = `Warning: Agent ${agentType} completed but no ${outputSpec.description} was found.\nSkill-specific warnings:\n` +
+      skillWarnings.map(w => `- ${w}`).join('\n');
+    process.stdout.write(JSON.stringify({ additionalContext: msg }));
+  } else if (genericMissing) {
     logHook('check-subagent-output', 'PostToolUse', 'warning', {
       agent_type: agentType,
       expected: outputSpec.description,
       found: 'none'
     });
-
     const output = {
       additionalContext: `Warning: Agent ${agentType} completed but no ${outputSpec.description} was found. The agent may have failed silently. Check agent output for errors.`
     };
     process.stdout.write(JSON.stringify(output));
+  } else if (skillWarnings.length > 0) {
+    logHook('check-subagent-output', 'PostToolUse', 'skill-warning', {
+      skill: activeSkill,
+      agent_type: agentType,
+      warnings: skillWarnings
+    });
+    process.stdout.write(JSON.stringify({
+      additionalContext: 'Skill-specific warnings:\n' + skillWarnings.map(w => `- ${w}`).join('\n')
+    }));
   } else {
     logHook('check-subagent-output', 'PostToolUse', 'verified', {
       agent_type: agentType,
@@ -241,5 +317,5 @@ function main() {
   process.exit(0);
 }
 
-module.exports = { AGENT_OUTPUTS, findInPhaseDir, findInQuickDir };
+module.exports = { AGENT_OUTPUTS, findInPhaseDir, findInQuickDir, checkSummaryCommits };
 if (require.main === module || process.argv[1] === __filename) { main(); }

package/plugins/pbr/scripts/post-write-dispatch.js

@@ -18,7 +18,7 @@
  *   0 = always (PostToolUse hooks are advisory)
  */
 
-const { checkPlanWrite } = require('./check-plan-format');
+const { checkPlanWrite, checkStateWrite } = require('./check-plan-format');
 const { checkSync } = require('./check-roadmap-sync');
 const { checkStateSync } = require('./check-state-sync');
 
@@ -48,6 +48,13 @@ function main() {
         process.exit(0);
       }
 
+      // STATE.md frontmatter validation (after roadmap sync, advisory only)
+      const stateResult = checkStateWrite(data);
+      if (stateResult) {
+        process.stdout.write(JSON.stringify(stateResult.output));
+        process.exit(0);
+      }
+
       // State sync check (SUMMARY/VERIFICATION → STATE.md + ROADMAP.md)
       const stateSyncResult = checkStateSync(data);
       if (stateSyncResult) {

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

@@ -306,6 +306,330 @@ function checkReviewPlannerGate(data) {
   return null;
 }
 
+/**
+ * Blocking check: when the active skill is "review" and a verifier is being
+ * spawned, verify that a SUMMARY*.md exists in the current phase directory.
+ * Returns { block: true, reason: "..." } if blocked, or null if OK.
+ */
+function checkReviewVerifierGate(data) {
+  const toolInput = data.tool_input || {};
+  const subagentType = toolInput.subagent_type || '';
+
+  // Only gate pbr:verifier
+  if (subagentType !== 'pbr:verifier') return null;
+
+  const cwd = process.cwd();
+  const planningDir = path.join(cwd, '.planning');
+  const activeSkillFile = path.join(planningDir, '.active-skill');
+
+  // Only gate when active skill is "review"
+  try {
+    const activeSkill = fs.readFileSync(activeSkillFile, 'utf8').trim();
+    if (activeSkill !== 'review') return null;
+  } catch (_e) {
+    return null;
+  }
+
+  // Read STATE.md for current phase
+  const stateFile = path.join(planningDir, 'STATE.md');
+  try {
+    const state = fs.readFileSync(stateFile, 'utf8');
+    const phaseMatch = state.match(/Phase:\s*(\d+)/);
+    if (!phaseMatch) return null;
+
+    const currentPhase = phaseMatch[1].padStart(2, '0');
+    const phasesDir = path.join(planningDir, 'phases');
+    if (!fs.existsSync(phasesDir)) return null;
+
+    const dirs = fs.readdirSync(phasesDir).filter(d => d.startsWith(currentPhase + '-'));
+    if (dirs.length === 0) return null;
+
+    const phaseDir = path.join(phasesDir, dirs[0]);
+    const files = fs.readdirSync(phaseDir);
+    const hasSummary = files.some(f => {
+      if (!/^SUMMARY/i.test(f)) return false;
+      try {
+        return fs.statSync(path.join(phaseDir, f)).size > 0;
+      } catch (_e) {
+        return false;
+      }
+    });
+
+    if (!hasSummary) {
+      return {
+        block: true,
+        reason: 'Review verifier gate: Cannot spawn verifier without SUMMARY.md in phase directory. Run /pbr:build first.'
+      };
+    }
+  } catch (_e) {
+    return null;
+  }
+
+  return null;
+}
+
+/**
+ * Blocking check: when the active skill is "milestone" and a general/planner agent
+ * is being spawned for a "complete" operation, verify all milestone phases have VERIFICATION.md.
+ * Returns { block: true, reason: "..." } if blocked, or null if OK.
+ */
+function checkMilestoneCompleteGate(data) {
+  const toolInput = data.tool_input || {};
+  const subagentType = toolInput.subagent_type || '';
+  const description = toolInput.description || '';
+
+  const cwd = process.cwd();
+  const planningDir = path.join(cwd, '.planning');
+  const activeSkillFile = path.join(planningDir, '.active-skill');
+
+  // Only gate when active skill is "milestone"
+  try {
+    const activeSkill = fs.readFileSync(activeSkillFile, 'utf8').trim();
+    if (activeSkill !== 'milestone') return null;
+  } catch (_e) {
+    return null;
+  }
+
+  // Only gate pbr:general and pbr:planner
+  if (subagentType !== 'pbr:general' && subagentType !== 'pbr:planner') return null;
+
+  // Only gate "complete" operations
+  if (!/complete/i.test(description)) return null;
+
+  // Read STATE.md for current phase
+  const stateFile = path.join(planningDir, 'STATE.md');
+  let currentPhase;
+  try {
+    const state = fs.readFileSync(stateFile, 'utf8');
+    const fmMatch = state.match(/current_phase:\s*(\d+)/);
+    if (fmMatch) {
+      currentPhase = parseInt(fmMatch[1], 10);
+    } else {
+      const bodyMatch = state.match(/Phase:\s*(\d+)/);
+      if (bodyMatch) currentPhase = parseInt(bodyMatch[1], 10);
+    }
+    if (!currentPhase) return null;
+  } catch (_e) {
+    return null;
+  }
+
+  // Read ROADMAP.md and find the milestone containing the current phase
+  const roadmapFile = path.join(planningDir, 'ROADMAP.md');
+  try {
+    const roadmap = fs.readFileSync(roadmapFile, 'utf8');
+
+    // Split into milestone sections
+    const milestoneSections = roadmap.split(/^## Milestone:/m).slice(1);
+
+    for (const section of milestoneSections) {
+      // Parse phase numbers from table rows
+      const phaseNumbers = [];
+      const tableRowRegex = /^\|\s*(\d+)\s*\|/gm;
+      let match;
+      while ((match = tableRowRegex.exec(section)) !== null) {
+        phaseNumbers.push(parseInt(match[1], 10));
+      }
+
+      // Check if current phase is in this milestone
+      if (!phaseNumbers.includes(currentPhase)) continue;
+
+      // Found the right milestone — check all phases have VERIFICATION.md
+      const phasesDir = path.join(planningDir, 'phases');
+      if (!fs.existsSync(phasesDir)) return null;
+
+      for (const phaseNum of phaseNumbers) {
+        const paddedPhase = String(phaseNum).padStart(2, '0');
+        const pDirs = fs.readdirSync(phasesDir).filter(d => d.startsWith(paddedPhase + '-'));
+        if (pDirs.length === 0) {
+          return {
+            block: true,
+            reason: `Milestone complete gate: Phase ${paddedPhase} directory not found. All milestone phases must be verified before completing milestone.`
+          };
+        }
+        const hasVerification = fs.existsSync(path.join(phasesDir, pDirs[0], 'VERIFICATION.md'));
+        if (!hasVerification) {
+          return {
+            block: true,
+            reason: `Milestone complete gate: Phase ${paddedPhase} (${pDirs[0]}) lacks VERIFICATION.md. All milestone phases must be verified before completing milestone.`
+          };
+        }
+      }
+
+      // All phases verified
+      return null;
+    }
+  } catch (_e) {
+    return null;
+  }
+
+  return null;
+}
+
+/**
+ * Blocking check: when the active skill is "build" and an executor is being
+ * spawned, verify that dependent phases (from ROADMAP.md) have VERIFICATION.md.
+ * Returns { block: true, reason: "..." } if blocked, or null if OK.
+ */
+function checkBuildDependencyGate(data) {
+  const toolInput = data.tool_input || {};
+  const subagentType = toolInput.subagent_type || '';
+
+  // Only gate pbr:executor
+  if (subagentType !== 'pbr:executor') return null;
+
+  const cwd = process.cwd();
+  const planningDir = path.join(cwd, '.planning');
+  const activeSkillFile = path.join(planningDir, '.active-skill');
+
+  // Only gate when active skill is "build"
+  try {
+    const activeSkill = fs.readFileSync(activeSkillFile, 'utf8').trim();
+    if (activeSkill !== 'build') return null;
+  } catch (_e) {
+    return null;
+  }
+
+  // Read STATE.md for current phase
+  const stateFile = path.join(planningDir, 'STATE.md');
+  let currentPhase;
+  try {
+    const state = fs.readFileSync(stateFile, 'utf8');
+    const phaseMatch = state.match(/Phase:\s*(\d+)/);
+    if (!phaseMatch) return null;
+    currentPhase = parseInt(phaseMatch[1], 10);
+  } catch (_e) {
+    return null;
+  }
+
+  // Read ROADMAP.md, find current phase section, check dependencies
+  const roadmapFile = path.join(planningDir, 'ROADMAP.md');
+  try {
+    const roadmap = fs.readFileSync(roadmapFile, 'utf8');
+
+    // Find ### Phase N: section
+    const phaseRegex = new RegExp(`### Phase ${currentPhase}:[\\s\\S]*?(?=### Phase \\d|$)`);
+    const phaseSection = roadmap.match(phaseRegex);
+    if (!phaseSection) return null;
+
+    // Look for **Depends on:** line
+    const depMatch = phaseSection[0].match(/\*\*Depends on:\*\*\s*(.*)/);
+    if (!depMatch) return null;
+
+    const depLine = depMatch[1].trim();
+    if (!depLine || /^none$/i.test(depLine)) return null;
+
+    // Parse phase numbers from "Phase 1", "Phase 1, Phase 2", etc.
+    const depPhases = [];
+    const depRegex = /Phase\s+(\d+)/gi;
+    let match;
+    while ((match = depRegex.exec(depLine)) !== null) {
+      depPhases.push(parseInt(match[1], 10));
+    }
+
+    if (depPhases.length === 0) return null;
+
+    // Check each dependent phase has VERIFICATION.md
+    const phasesDir = path.join(planningDir, 'phases');
+    if (!fs.existsSync(phasesDir)) return null;
+
+    for (const depPhase of depPhases) {
+      const paddedPhase = String(depPhase).padStart(2, '0');
+      const pDirs = fs.readdirSync(phasesDir).filter(d => d.startsWith(paddedPhase + '-'));
+      if (pDirs.length === 0) {
+        return {
+          block: true,
+          reason: `Build dependency gate: Dependent phase ${paddedPhase} lacks VERIFICATION.md. Run /pbr:review on dependent phases first.`
+        };
+      }
+      const hasVerification = fs.existsSync(path.join(phasesDir, pDirs[0], 'VERIFICATION.md'));
+      if (!hasVerification) {
+        return {
+          block: true,
+          reason: `Build dependency gate: Dependent phase ${paddedPhase} lacks VERIFICATION.md. Run /pbr:review on dependent phases first.`
+        };
+      }
+    }
+  } catch (_e) {
+    return null;
+  }
+
+  return null;
+}
+
+/**
+ * Advisory check: when active skill is "build" and an executor is being
+ * spawned, warn if .checkpoint-manifest.json is missing in the phase dir.
+ * Returns a warning string or null.
+ */
+function checkCheckpointManifest(data) {
+  const toolInput = data.tool_input || {};
+  const subagentType = toolInput.subagent_type || '';
+
+  if (subagentType !== 'pbr:executor') return null;
+
+  const cwd = process.cwd();
+  const planningDir = path.join(cwd, '.planning');
+  const activeSkillFile = path.join(planningDir, '.active-skill');
+
+  try {
+    const activeSkill = fs.readFileSync(activeSkillFile, 'utf8').trim();
+    if (activeSkill !== 'build') return null;
+  } catch (_e) {
+    return null;
+  }
+
+  // Find current phase dir
+  const stateFile = path.join(planningDir, 'STATE.md');
+  try {
+    const state = fs.readFileSync(stateFile, 'utf8');
+    const phaseMatch = state.match(/Phase:\s*(\d+)\s+of\s+\d+/);
+    if (!phaseMatch) return null;
+
+    const currentPhase = phaseMatch[1].padStart(2, '0');
+    const phasesDir = path.join(planningDir, 'phases');
+    if (!fs.existsSync(phasesDir)) return null;
+
+    const dirs = fs.readdirSync(phasesDir).filter(d => d.startsWith(currentPhase + '-'));
+    if (dirs.length === 0) return null;
+
+    const phaseDir = path.join(phasesDir, dirs[0]);
+    const manifestFile = path.join(phaseDir, '.checkpoint-manifest.json');
+    if (!fs.existsSync(manifestFile)) {
+      return 'Build advisory: .checkpoint-manifest.json not found in phase directory. The build skill should write this before spawning executors.';
+    }
+  } catch (_e) {
+    return null;
+  }
+
+  return null;
+}
+
+/**
+ * Advisory check: when any pbr:* agent is being spawned, warn if
+ * .planning/.active-skill doesn't exist. Without this file, all
+ * skill-specific enforcement is silently disabled.
+ * Returns a warning string or null.
+ */
+function checkActiveSkillIntegrity(data) {
+  const toolInput = data.tool_input || {};
+  const subagentType = toolInput.subagent_type || '';
+
+  if (typeof subagentType !== 'string' || !subagentType.startsWith('pbr:')) return null;
+
+  const cwd = process.cwd();
+  const planningDir = path.join(cwd, '.planning');
+
+  // Only check if .planning/ exists (PBR project)
+  if (!fs.existsSync(planningDir)) return null;
+
+  const activeSkillFile = path.join(planningDir, '.active-skill');
+  if (!fs.existsSync(activeSkillFile)) {
+    return 'Active-skill integrity: .planning/.active-skill not found. Skill-specific enforcement is disabled. The invoking skill should write this file.';
+  }
+
+  return null;
+}
+
 function main() {
   let input = '';
 
@@ -363,8 +687,48 @@ function main() {
         return;
       }
 
+      // Blocking gate: review verifier needs SUMMARY.md
+      const reviewVerifierGate = checkReviewVerifierGate(data);
+      if (reviewVerifierGate && reviewVerifierGate.block) {
+        logHook('validate-task', 'PreToolUse', 'blocked', { reason: reviewVerifierGate.reason });
+        process.stdout.write(JSON.stringify({
+          decision: 'block',
+          reason: reviewVerifierGate.reason
+        }));
+        process.exit(2);
+        return;
+      }
+
+      // Blocking gate: milestone complete needs all phases verified
+      const milestoneGate = checkMilestoneCompleteGate(data);
+      if (milestoneGate && milestoneGate.block) {
+        logHook('validate-task', 'PreToolUse', 'blocked', { reason: milestoneGate.reason });
+        process.stdout.write(JSON.stringify({
+          decision: 'block',
+          reason: milestoneGate.reason
+        }));
+        process.exit(2);
+        return;
+      }
+
+      // Blocking gate: build dependency check
+      const buildDepGate = checkBuildDependencyGate(data);
+      if (buildDepGate && buildDepGate.block) {
+        logHook('validate-task', 'PreToolUse', 'blocked', { reason: buildDepGate.reason });
+        process.stdout.write(JSON.stringify({
+          decision: 'block',
+          reason: buildDepGate.reason
+        }));
+        process.exit(2);
+        return;
+      }
+
       // Advisory warnings
       const warnings = checkTask(data);
+      const manifestWarning = checkCheckpointManifest(data);
+      if (manifestWarning) warnings.push(manifestWarning);
+      const activeSkillWarning = checkActiveSkillIntegrity(data);
+      if (activeSkillWarning) warnings.push(activeSkillWarning);
 
       if (warnings.length > 0) {
         for (const warning of warnings) {
@@ -383,5 +747,5 @@ function main() {
   });
 }
 
-module.exports = { checkTask, checkQuickExecutorGate, checkBuildExecutorGate, checkPlanExecutorGate, checkReviewPlannerGate, KNOWN_AGENTS, MAX_DESCRIPTION_LENGTH };
+module.exports = { checkTask, checkQuickExecutorGate, checkBuildExecutorGate, checkPlanExecutorGate, checkReviewPlannerGate, checkReviewVerifierGate, checkMilestoneCompleteGate, checkBuildDependencyGate, checkCheckpointManifest, checkActiveSkillIntegrity, KNOWN_AGENTS, MAX_DESCRIPTION_LENGTH };
 if (require.main === module || process.argv[1] === __filename) { main(); }