@sienklogic/plan-build-run 2.0.0

package/plugins/pbr/scripts/config-schema.json

@@ -0,0 +1,251 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "Plan-Build-Run Config",
+  "description": "Configuration schema for .planning/config.json",
+  "type": "object",
+  "properties": {
+    "version": { "type": "integer", "enum": [1, 2] },
+    "context_strategy": { "type": "string", "enum": ["aggressive", "conservative", "balanced"] },
+    "mode": { "type": "string", "enum": ["interactive", "autonomous"] },
+    "depth": { "type": "string", "enum": ["quick", "standard", "comprehensive"], "description": "Workflow depth: quick = budget mode (fewer spawns, skip optional stages), standard = balanced mode (conditional spawns), comprehensive = thorough mode (all spawns, current default)" },
+    "features": {
+      "type": "object",
+      "properties": {
+        "structured_planning": { "type": "boolean" },
+        "goal_verification": { "type": "boolean" },
+        "integration_verification": { "type": "boolean" },
+        "context_isolation": { "type": "boolean" },
+        "atomic_commits": { "type": "boolean" },
+        "session_persistence": { "type": "boolean" },
+        "research_phase": { "type": "boolean" },
+        "plan_checking": { "type": "boolean" },
+        "tdd_mode": { "type": "boolean" },
+        "status_line": { "type": "boolean" },
+        "auto_continue": { "type": "boolean" },
+        "auto_advance": { "type": "boolean" },
+        "team_discussions": { "type": "boolean" },
+        "inline_verify": { "type": "boolean" }
+      },
+      "additionalProperties": false
+    },
+    "models": {
+      "type": "object",
+      "properties": {
+        "researcher": { "type": "string" },
+        "planner": { "type": "string" },
+        "executor": { "type": "string" },
+        "verifier": { "type": "string" },
+        "integration_checker": { "type": "string" },
+        "debugger": { "type": "string" },
+        "mapper": { "type": "string" },
+        "synthesizer": { "type": "string" },
+        "complexity_map": {
+          "type": "object",
+          "properties": {
+            "simple": { "type": "string", "default": "haiku" },
+            "medium": { "type": "string", "default": "sonnet" },
+            "complex": { "type": "string", "default": "inherit" }
+          },
+          "additionalProperties": false
+        }
+      },
+      "additionalProperties": false
+    },
+    "parallelization": {
+      "type": "object",
+      "properties": {
+        "enabled": { "type": "boolean" },
+        "plan_level": { "type": "boolean" },
+        "task_level": { "type": "boolean" },
+        "max_concurrent_agents": { "type": "integer", "minimum": 1, "maximum": 10 },
+        "min_plans_for_parallel": { "type": "integer", "minimum": 1 },
+        "use_teams": { "type": "boolean" }
+      },
+      "additionalProperties": false
+    },
+    "teams": {
+      "type": "object",
+      "properties": {
+        "planning_roles": {
+          "type": "array",
+          "items": { "type": "string" },
+          "default": ["architect", "security-reviewer", "test-designer"]
+        },
+        "review_roles": {
+          "type": "array",
+          "items": { "type": "string" },
+          "default": ["functional-reviewer", "security-auditor", "performance-analyst"]
+        },
+        "synthesis_model": {
+          "type": "string",
+          "default": "sonnet",
+          "description": "Model used for the synthesizer agent that combines team outputs"
+        },
+        "coordination": {
+          "type": "string",
+          "enum": ["file-based", "sequential"],
+          "default": "file-based",
+          "description": "How team members coordinate: file-based (parallel writes to separate files) or sequential"
+        }
+      },
+      "additionalProperties": false
+    },
+    "planning": {
+      "type": "object",
+      "properties": {
+        "commit_docs": { "type": "boolean" },
+        "max_tasks_per_plan": { "type": "integer", "minimum": 1, "maximum": 10 },
+        "search_gitignored": { "type": "boolean" }
+      },
+      "additionalProperties": false
+    },
+    "git": {
+      "type": "object",
+      "properties": {
+        "branching": { "type": "string", "enum": ["none", "phase", "milestone", "disabled"] },
+        "commit_format": { "type": "string" },
+        "phase_branch_template": { "type": "string" },
+        "milestone_branch_template": { "type": "string" },
+        "mode": { "type": "string", "enum": ["enabled", "disabled"] }
+      },
+      "additionalProperties": false
+    },
+    "gates": {
+      "type": "object",
+      "properties": {
+        "confirm_project": { "type": "boolean" },
+        "confirm_roadmap": { "type": "boolean" },
+        "confirm_plan": { "type": "boolean" },
+        "confirm_execute": { "type": "boolean" },
+        "confirm_transition": { "type": "boolean" },
+        "issues_review": { "type": "boolean" }
+      },
+      "additionalProperties": false
+    },
+    "safety": {
+      "type": "object",
+      "properties": {
+        "always_confirm_destructive": { "type": "boolean" },
+        "always_confirm_external_services": { "type": "boolean" },
+        "enforce_phase_boundaries": { "type": "boolean" }
+      },
+      "additionalProperties": false
+    },
+    "hooks": {
+      "type": "object",
+      "properties": {
+        "autoFormat": { "type": "boolean" },
+        "typeCheck": { "type": "boolean" },
+        "detectConsoleLogs": { "type": "boolean" },
+        "blockDocSprawl": { "type": "boolean" },
+        "compactThreshold": { "type": "integer", "minimum": 10, "maximum": 200 }
+      },
+      "additionalProperties": false
+    },
+    "depth_profiles": {
+      "type": "object",
+      "description": "Depth profile overrides. Each profile maps depth value to effective feature/gate settings.",
+      "properties": {
+        "quick": {
+          "type": "object",
+          "properties": {
+            "features.research_phase": { "type": "boolean" },
+            "features.plan_checking": { "type": "boolean" },
+            "features.goal_verification": { "type": "boolean" },
+            "features.inline_verify": { "type": "boolean" },
+            "scan.mapper_count": { "type": "integer", "minimum": 1, "maximum": 4 },
+            "scan.mapper_areas": { "type": "array", "items": { "type": "string" } },
+            "debug.max_hypothesis_rounds": { "type": "integer", "minimum": 1, "maximum": 20 }
+          },
+          "additionalProperties": false
+        },
+        "standard": {
+          "type": "object",
+          "properties": {
+            "features.research_phase": { "type": "boolean" },
+            "features.plan_checking": { "type": "boolean" },
+            "features.goal_verification": { "type": "boolean" },
+            "features.inline_verify": { "type": "boolean" },
+            "scan.mapper_count": { "type": "integer", "minimum": 1, "maximum": 4 },
+            "scan.mapper_areas": { "type": "array", "items": { "type": "string" } },
+            "debug.max_hypothesis_rounds": { "type": "integer", "minimum": 1, "maximum": 20 }
+          },
+          "additionalProperties": false
+        },
+        "comprehensive": {
+          "type": "object",
+          "properties": {
+            "features.research_phase": { "type": "boolean" },
+            "features.plan_checking": { "type": "boolean" },
+            "features.goal_verification": { "type": "boolean" },
+            "features.inline_verify": { "type": "boolean" },
+            "scan.mapper_count": { "type": "integer", "minimum": 1, "maximum": 4 },
+            "scan.mapper_areas": { "type": "array", "items": { "type": "string" } },
+            "debug.max_hypothesis_rounds": { "type": "integer", "minimum": 1, "maximum": 20 }
+          },
+          "additionalProperties": false
+        }
+      },
+      "additionalProperties": false
+    },
+    "debug": {
+      "type": "object",
+      "properties": {
+        "max_hypothesis_rounds": { "type": "integer", "minimum": 1, "maximum": 20 }
+      },
+      "additionalProperties": false
+    },
+    "spinner_tips": {
+      "type": "object",
+      "description": "Custom spinner tips shown during agent execution (Claude Code 2.1.45+)",
+      "properties": {
+        "tips": {
+          "type": "array",
+          "items": { "type": "string" },
+          "description": "Array of custom tip strings to display in the spinner"
+        },
+        "exclude_defaults": {
+          "type": "boolean",
+          "description": "When true, only show custom tips (no default Claude Code tips)"
+        }
+      },
+      "additionalProperties": false
+    },
+    "status_line": {
+      "type": "object",
+      "properties": {
+        "sections": {
+          "type": "array",
+          "items": { "type": "string", "enum": ["phase", "plan", "status", "context"] }
+        },
+        "brand_text": { "type": "string" },
+        "max_status_length": { "type": "integer", "minimum": 10, "maximum": 200 },
+        "context_bar": {
+          "type": "object",
+          "properties": {
+            "width": { "type": "integer", "minimum": 1, "maximum": 50 },
+            "thresholds": {
+              "type": "object",
+              "properties": {
+                "green": { "type": "integer", "minimum": 0, "maximum": 100 },
+                "yellow": { "type": "integer", "minimum": 0, "maximum": 100 }
+              },
+              "additionalProperties": false
+            },
+            "chars": {
+              "type": "object",
+              "properties": {
+                "filled": { "type": "string" },
+                "empty": { "type": "string" }
+              },
+              "additionalProperties": false
+            }
+          },
+          "additionalProperties": false
+        }
+      },
+      "additionalProperties": false
+    }
+  },
+  "additionalProperties": false
+}

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

@@ -0,0 +1,287 @@
+#!/usr/bin/env node
+
+/**
+ * PreCompact hook: Preserves current state to STATE.md before
+ * lossy context compaction.
+ *
+ * Updates STATE.md with:
+ * - Timestamp of last compaction
+ * - ROADMAP progress summary (phase list, status)
+ * - Current plan context (objective from latest PLAN.md)
+ * - Config highlights (depth, mode, models, gates)
+ * - Active operation context
+ *
+ * Also outputs additionalContext for post-compaction recovery.
+ *
+ * Exit codes:
+ *   0 = always (informational hook, never blocks)
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { logHook } = require('./hook-logger');
+const { logEvent } = require('./event-logger');
+const { atomicWrite, configLoad, tailLines } = require('./pbr-tools');
+
+function main() {
+  const cwd = process.cwd();
+  const planningDir = path.join(cwd, '.planning');
+  const stateFile = path.join(planningDir, 'STATE.md');
+
+  // Not a Plan-Build-Run project or no STATE.md
+  if (!fs.existsSync(stateFile)) {
+    process.exit(0);
+  }
+
+  try {
+    let content = fs.readFileSync(stateFile, 'utf8');
+    const timestamp = new Date().toISOString();
+
+    // Gather context from multiple sources
+    const activeOp = readActiveOperation(planningDir);
+    const roadmapSummary = readRoadmapSummary(planningDir);
+    const currentPlan = readCurrentPlan(planningDir, content);
+    const configHighlights = readConfigHighlights(planningDir);
+    const recentErrors = readRecentErrors(planningDir, 3);
+    const recentAgents = readRecentAgents(planningDir, 5);
+
+    // Build continuity section
+    const continuityParts = [
+      `Last session: ${timestamp}`,
+      'Compaction occurred: context was auto-compacted at this point'
+    ];
+
+    if (activeOp) {
+      continuityParts.push(`Active operation at compaction: ${activeOp}`);
+    }
+    if (roadmapSummary) {
+      continuityParts.push(`Roadmap progress:\n${roadmapSummary}`);
+    }
+    if (currentPlan) {
+      continuityParts.push(`Current plan: ${currentPlan}`);
+    }
+    if (configHighlights) {
+      continuityParts.push(`Config: ${configHighlights}`);
+    }
+    if (recentErrors.length > 0) {
+      continuityParts.push(`Recent errors:\n${recentErrors.map(e => '  - ' + e).join('\n')}`);
+    }
+    if (recentAgents.length > 0) {
+      continuityParts.push(`Recent agents: ${recentAgents.join(', ')}`);
+    }
+
+    continuityParts.push('Note: Some conversation context may have been lost. Check STATE.md and SUMMARY.md files for ground truth.');
+
+    // Update or add Session Continuity section
+    const continuityHeader = '## Session Continuity';
+    const continuityContent = continuityParts.join('\n');
+
+    if (content.includes(continuityHeader)) {
+      // Replace existing section
+      content = content.replace(
+        /## Session Continuity[\s\S]*?(?=\n## |\n---|\s*$)/,
+        `${continuityHeader}\n${continuityContent}\n`
+      );
+    } else {
+      // Append section
+      content = content.trimEnd() + `\n\n${continuityHeader}\n${continuityContent}\n`;
+    }
+
+    atomicWrite(stateFile, content);
+
+    // Output additionalContext for post-compaction recovery
+    const recoveryContext = buildRecoveryContext(activeOp, roadmapSummary, currentPlan, configHighlights, recentErrors, recentAgents);
+    if (recoveryContext) {
+      const output = {
+        additionalContext: recoveryContext
+      };
+      process.stdout.write(JSON.stringify(output));
+    }
+
+    logHook('context-budget-check', 'PreCompact', 'saved', {
+      stateFile: 'STATE.md',
+      hasRoadmap: !!roadmapSummary,
+      hasPlan: !!currentPlan,
+      hasConfig: !!configHighlights
+    });
+    logEvent('workflow', 'compaction', { timestamp });
+  } catch (e) {
+    logHook('context-budget-check', 'PreCompact', 'error', { error: e.message });
+  }
+
+  process.exit(0);
+}
+
+function readActiveOperation(planningDir) {
+  const activeOpFile = path.join(planningDir, '.active-operation');
+  if (!fs.existsSync(activeOpFile)) return '';
+  try {
+    return fs.readFileSync(activeOpFile, 'utf8').trim();
+  } catch (_e) {
+    return '';
+  }
+}
+
+function readRoadmapSummary(planningDir) {
+  const roadmapFile = path.join(planningDir, 'ROADMAP.md');
+  if (!fs.existsSync(roadmapFile)) return '';
+
+  try {
+    const roadmap = fs.readFileSync(roadmapFile, 'utf8');
+
+    // Extract progress table
+    const progressMatch = roadmap.match(/## Progress[\s\S]*?\|[\s\S]*?(?=\n##|\s*$)/);
+    if (!progressMatch) return '';
+
+    const rows = progressMatch[0].split('\n').filter(r => r.includes('|'));
+    // Skip header and separator rows
+    const dataRows = rows.filter(r => !r.includes('---') && !r.toLowerCase().includes('phase'));
+
+    if (dataRows.length === 0) return '';
+
+    // Build compact summary
+    const phases = [];
+    for (const row of dataRows) {
+      const cols = row.split('|').map(c => c.trim()).filter(Boolean);
+      if (cols.length >= 4) {
+        const num = cols[0];
+        const name = cols[1] || '';
+        const status = cols[3] || '';
+        if (num && /^\d+/.test(num)) {
+          phases.push(`  Phase ${num} (${name.substring(0, 30)}): ${status}`);
+        }
+      }
+    }
+
+    return phases.join('\n');
+  } catch (_e) {
+    return '';
+  }
+}
+
+function readCurrentPlan(planningDir, stateContent) {
+  // Prefer .active-plan signal file (definitive) over directory listing (guesswork)
+  const activePlanFile = path.join(planningDir, '.active-plan');
+  if (fs.existsSync(activePlanFile)) {
+    try {
+      const activePlan = fs.readFileSync(activePlanFile, 'utf8').trim();
+      if (activePlan) return activePlan;
+    } catch (_e) { /* fall through */ }
+  }
+
+  // Fallback: Extract current phase from STATE.md and find latest plan
+  const phaseMatch = stateContent.match(/Phase:\s*(\d+)\s+of\s+\d+/);
+  if (!phaseMatch) return '';
+
+  const currentPhase = phaseMatch[1].padStart(2, '0');
+
+  // Find the phase directory
+  const phasesDir = path.join(planningDir, 'phases');
+  if (!fs.existsSync(phasesDir)) return '';
+
+  try {
+    const dirs = fs.readdirSync(phasesDir).filter(d => d.startsWith(currentPhase));
+    if (dirs.length === 0) return '';
+
+    const phaseDir = path.join(phasesDir, dirs[0]);
+
+    // Find PLAN.md files
+    const planFiles = fs.readdirSync(phaseDir).filter(f => f.endsWith('PLAN.md'));
+    if (planFiles.length === 0) return 'No PLAN.md found in current phase';
+
+    // Read the last plan's objective only (frontmatter + objective tag)
+    const planFile = path.join(phaseDir, planFiles[planFiles.length - 1]);
+    const planContent = fs.readFileSync(planFile, 'utf8');
+
+    const objMatch = planContent.match(/<objective>([\s\S]*?)<\/objective>/);
+    const objective = objMatch ? objMatch[1].trim().substring(0, 150) : '';
+
+    return `${dirs[0]}/${planFiles[planFiles.length - 1]}${objective ? ' — ' + objective : ''}`;
+  } catch (_e) {
+    return '';
+  }
+}
+
+function readRecentErrors(planningDir, maxErrors) {
+  const count = maxErrors || 3;
+  try {
+    const eventsLog = path.join(planningDir, 'logs', 'events.jsonl');
+    // Only read the last 50 lines — errors are rare, so 50 tail lines
+    // is more than enough to find the most recent ones
+    const lines = tailLines(eventsLog, 50);
+    if (lines.length === 0) return [];
+
+    const errors = [];
+    // Read backwards for most recent
+    for (let i = lines.length - 1; i >= 0 && errors.length < count; i--) {
+      try {
+        const entry = JSON.parse(lines[i]);
+        if (entry.cat === 'error' || entry.event === 'tool-failure' || (entry.cat === 'workflow' && entry.status === 'block')) {
+          errors.push(`${entry.event || entry.cat}: ${entry.error || entry.reason || entry.message || 'unknown'}`.substring(0, 120));
+        }
+      } catch (_e) { /* skip */ }
+    }
+    return errors;
+  } catch (_e) {
+    return [];
+  }
+}
+
+function readRecentAgents(planningDir, maxAgents) {
+  const count = maxAgents || 5;
+  try {
+    const hooksLog = path.join(planningDir, 'logs', 'hooks.jsonl');
+    // Only read the last 30 lines — agent spawns are interspersed with
+    // other hook events, so 30 tail lines covers recent agents well
+    const lines = tailLines(hooksLog, 30);
+    if (lines.length === 0) return [];
+
+    const agents = [];
+    // Read backwards for most recent
+    for (let i = lines.length - 1; i >= 0 && agents.length < count; i--) {
+      try {
+        const entry = JSON.parse(lines[i]);
+        if (entry.event === 'SubagentStart' && entry.decision === 'spawned') {
+          const type = entry.agent_type || 'unknown';
+          const desc = entry.description ? ` (${entry.description.substring(0, 60)})` : '';
+          agents.push(`${type}${desc}`);
+        }
+      } catch (_e) { /* skip */ }
+    }
+    return agents.reverse(); // Chronological order
+  } catch (_e) {
+    return [];
+  }
+}
+
+function readConfigHighlights(planningDir) {
+  const config = configLoad(planningDir);
+  if (!config) return '';
+
+  const parts = [];
+  if (config.depth) parts.push(`depth=${config.depth}`);
+  if (config.mode) parts.push(`mode=${config.mode}`);
+  if (config.models && config.models.executor) parts.push(`executor=${config.models.executor}`);
+  if (config.gates && config.gates.verification !== undefined) parts.push(`verify=${config.gates.verification}`);
+  if (config.git && config.git.auto_commit !== undefined) parts.push(`auto_commit=${config.git.auto_commit}`);
+  return parts.join(', ');
+}
+
+function buildRecoveryContext(activeOp, roadmapSummary, currentPlan, configHighlights, recentErrors, recentAgents) {
+  const parts = ['[Post-Compaction Recovery] Context was auto-compacted. Key state preserved:'];
+
+  if (activeOp) parts.push(`Active operation: ${activeOp}`);
+  if (currentPlan) parts.push(`Current plan: ${currentPlan}`);
+  if (configHighlights) parts.push(`Config: ${configHighlights}`);
+  if (recentErrors && recentErrors.length > 0) parts.push(`Recent errors: ${recentErrors.join('; ')}`);
+  if (recentAgents && recentAgents.length > 0) parts.push(`Recent agents: ${recentAgents.join(', ')}`);
+  if (roadmapSummary) parts.push(`Progress:\n${roadmapSummary}`);
+
+  parts.push('Read .planning/STATE.md for full context.');
+
+  // Only return if we have something meaningful beyond header and footer
+  return parts.length > 2 ? parts.join('\n') : '';
+}
+
+module.exports = { readRoadmapSummary, readCurrentPlan, readConfigHighlights, buildRecoveryContext, readRecentErrors, readRecentAgents };
+if (require.main === module) { main(); }

package/plugins/pbr/scripts/event-handler.js

@@ -0,0 +1,151 @@
+#!/usr/bin/env node
+
+/**
+ * SubagentStop event handler for auto-verification triggering.
+ *
+ * Detects executor agent completion and conditionally queues verification
+ * by writing a .auto-verify signal file. Respects depth profile and
+ * config.features.goal_verification setting.
+ *
+ * Non-blocking — exits 0 always.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { logHook } = require('./hook-logger');
+const { logEvent } = require('./event-logger');
+// configLoad not used here to avoid mtime-based cache issues across directories.
+// Config is read directly in shouldAutoVerify().
+
+function readStdin() {
+  try {
+    const input = fs.readFileSync(0, 'utf8').trim();
+    if (input) return JSON.parse(input);
+  } catch (_e) {
+    // empty or non-JSON stdin
+  }
+  return {};
+}
+
+/**
+ * Check if the stdin data represents an executor agent completion.
+ * @param {object} data - Parsed stdin JSON from SubagentStop event
+ * @returns {boolean}
+ */
+function isExecutorAgent(data) {
+  const agentType = data.agent_type || data.subagent_type || null;
+  return agentType === 'pbr:executor';
+}
+
+/**
+ * Determine whether auto-verification should run based on config.
+ * @param {string} planningDir - Path to .planning directory
+ * @returns {boolean}
+ */
+function shouldAutoVerify(planningDir) {
+  // Read config directly instead of using configLoad to avoid mtime-based
+  // cache issues when called repeatedly with different planning directories.
+  const configPath = path.join(planningDir, 'config.json');
+  let config;
+  try {
+    if (!fs.existsSync(configPath)) return false;
+    config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+  } catch (_e) {
+    return false;
+  }
+  if (config === null) return false;
+
+  // Check explicit goal_verification toggle
+  if (config.features && config.features.goal_verification === false) return false;
+
+  // Check depth profile
+  const depth = (config.depth || 'standard').toLowerCase();
+  if (depth === 'quick') return false;
+
+  // "standard", "comprehensive", and any other depth default to true
+  return true;
+}
+
+/**
+ * Parse current phase info from STATE.md.
+ * @param {string} planningDir - Path to .planning directory
+ * @returns {{ phase: number, total: number, status: string } | null}
+ */
+function getPhaseFromState(planningDir) {
+  const statePath = path.join(planningDir, 'STATE.md');
+  try {
+    if (!fs.existsSync(statePath)) return null;
+    const content = fs.readFileSync(statePath, 'utf8');
+
+    const phaseMatch = content.match(/Phase:\s*(\d+)\s+of\s+(\d+)/);
+    if (!phaseMatch) return null;
+
+    const statusMatch = content.match(/\*{0,2}(?:Phase\s+)?Status\*{0,2}:\s*["']?(\w+)["']?/i);
+    const status = statusMatch ? statusMatch[1] : null;
+
+    return {
+      phase: parseInt(phaseMatch[1], 10),
+      total: parseInt(phaseMatch[2], 10),
+      status: status
+    };
+  } catch (_e) {
+    return null;
+  }
+}
+
+/**
+ * Write signal file for orchestrator to pick up and spawn verifier.
+ * @param {string} planningDir - Path to .planning directory
+ * @param {number} phaseNumber - Current phase number
+ */
+function writeAutoVerifySignal(planningDir, phaseNumber) {
+  const signalPath = path.join(planningDir, '.auto-verify');
+  const payload = {
+    phase: phaseNumber,
+    timestamp: new Date().toISOString()
+  };
+  fs.writeFileSync(signalPath, JSON.stringify(payload, null, 2), 'utf8');
+}
+
+function main() {
+  const data = readStdin();
+
+  // Only handle executor agent completions
+  if (!isExecutorAgent(data)) {
+    process.exit(0);
+  }
+
+  const agentType = data.agent_type || data.subagent_type;
+
+  logHook('event-handler', 'SubagentStop', 'executor-complete', { agent_type: agentType });
+  logEvent('workflow', 'executor-complete', { agent_type: agentType });
+
+  const planningDir = path.join(process.cwd(), '.planning');
+  if (!fs.existsSync(planningDir)) {
+    process.exit(0);
+  }
+
+  if (!shouldAutoVerify(planningDir)) {
+    logHook('event-handler', 'SubagentStop', 'skip-verify', { reason: 'config/depth' });
+    process.exit(0);
+  }
+
+  const stateInfo = getPhaseFromState(planningDir);
+  if (!stateInfo || stateInfo.status !== 'building') {
+    logHook('event-handler', 'SubagentStop', 'skip-verify', {
+      reason: stateInfo ? `status=${stateInfo.status}` : 'no-state'
+    });
+    process.exit(0);
+  }
+
+  writeAutoVerifySignal(planningDir, stateInfo.phase);
+
+  const output = {
+    message: `Executor complete. Auto-verification queued for Phase ${stateInfo.phase}.`
+  };
+  process.stdout.write(JSON.stringify(output));
+  process.exit(0);
+}
+
+module.exports = { isExecutorAgent, shouldAutoVerify, getPhaseFromState };
+if (require.main === module) { main(); }