@sienklogic/plan-build-run 2.19.0 → 2.19.2

package/plugins/pbr/dist/pre-skill-dispatch.js

@@ -0,0 +1,114 @@
+#!/usr/bin/env node
+
+/**
+ * PreToolUse dispatcher for Skill hooks.
+ *
+ * Consolidates enforce-context-budget.js and validate-skill-args.js
+ * into a single process, reading stdin once and routing to both
+ * checks sequentially. Budget check runs first (cheap) and
+ * short-circuits before skill argument validation.
+ *
+ * ── Dispatch Order & Rationale ──────────────────────────────────
+ *
+ *   1. enforce-context-budget — Blocks Skill invocations when context
+ *      usage exceeds the hard_stop_percent threshold. Runs first
+ *      because it is a cheap file read that can short-circuit before
+ *      argument validation.
+ *
+ *   2. validate-skill-args   — Validates skill arguments (phase
+ *      number existence, freeform text detection for /pbr:plan-phase).
+ *      Can block (exit 2) or allow (exit 0).
+ *
+ * Exit codes:
+ *   0 = allowed or warning only
+ *   2 = blocked (budget exceeded or invalid skill args)
+ */
+
+const path = require('path');
+const { logHook } = require('./hook-logger');
+const { checkBudget } = require('./enforce-context-budget');
+const { checkSkillArgs } = require('./validate-skill-args');
+
+/**
+ * Core dispatch logic for PreToolUse:Skill events.
+ *
+ * Step 1: Budget check (cheap, fast — short-circuits on block)
+ * Step 2: Skill argument validation
+ * Step 3: All clear
+ *
+ * @param {Object} data - Parsed hook event data
+ * @returns {Object} { decision: 'block'|'allow', reason?: string, additionalContext?: string }
+ */
+async function processEvent(data) {
+  // Step 1 — Budget check (cheap, fast)
+  const planningDir = path.join(data.cwd || process.env.PBR_PROJECT_ROOT || process.cwd(), '.planning');
+  const budgetResult = checkBudget({ toolName: 'Skill', planningDir });
+  if (budgetResult) {
+    logHook('pre-skill-dispatch', 'PreToolUse', 'blocked', { handler: 'enforce-context-budget' });
+    return budgetResult; // already { decision: 'block', reason: '...' }
+  }
+
+  // Step 2 — Skill argument validation
+  const skillResult = checkSkillArgs(data);
+  if (skillResult) {
+    if (skillResult.exitCode === 2) {
+      // Blocking result
+      logHook('pre-skill-dispatch', 'PreToolUse', 'blocked', { handler: 'validate-skill-args' });
+      return skillResult.output; // { decision: 'block', reason: '...' }
+    }
+    // Advisory result (exitCode 0 with output)
+    if (skillResult.output) {
+      logHook('pre-skill-dispatch', 'PreToolUse', 'warn', { handler: 'validate-skill-args' });
+      return skillResult.output;
+    }
+  }
+
+  // Step 3 — All clear
+  logHook('pre-skill-dispatch', 'PreToolUse', 'allow', {});
+  return { decision: 'allow' };
+}
+
+/**
+ * HTTP handler for hook-server integration.
+ *
+ * @param {Object} reqBody - HTTP request body with { data: {...} }
+ * @param {Object} _cache - Hook server cache (unused)
+ * @returns {Object|null} Hook result or null on error
+ */
+async function handleHttp(reqBody, _cache) {
+  try {
+    const data = reqBody.data || {};
+    return await processEvent(data);
+  } catch (_e) {
+    return null;
+  }
+}
+
+function main() {
+  let input = '';
+
+  process.stdin.setEncoding('utf8');
+  process.stdin.on('data', (chunk) => { input += chunk; });
+  process.stdin.on('end', async () => {
+    try {
+      const data = JSON.parse(input);
+      const result = await processEvent(data);
+
+      if (result && result.decision === 'block') {
+        process.stdout.write(JSON.stringify(result));
+        process.exit(2);
+        return;
+      }
+
+      process.stdout.write(JSON.stringify(result || {}));
+      process.exit(0);
+    } catch (_e) {
+      process.stderr.write(`[pbr] pre-skill-dispatch error: ${_e.message}\n`);
+      process.stdout.write(JSON.stringify({ decision: 'allow', additionalContext: '[PBR] pre-skill-dispatch failed: ' + _e.message }));
+      process.exit(0);
+    }
+  });
+}
+
+module.exports = { handleHttp, processEvent };
+if (require.main === module || process.argv[1] === __filename) { main(); }

package/plugins/pbr/dist/pre-task-dispatch.js

@@ -0,0 +1,269 @@
+#!/usr/bin/env node
+
+/**
+ * PreToolUse dispatcher for Task hooks.
+ *
+ * Consolidates enforce-context-budget.js and validate-task.js into a
+ * single process, reading stdin once and routing to both checks
+ * sequentially. Budget check runs first (cheap) and short-circuits
+ * before expensive gate validation.
+ *
+ * ── Dispatch Order & Rationale ──────────────────────────────────
+ *
+ *   1. enforce-context-budget — Blocks Task invocations when context
+ *      usage exceeds the hard_stop_percent threshold. Runs first
+ *      because it is a cheap file read that can short-circuit before
+ *      the expensive gate cascade.
+ *
+ *   2. validate-task gates     — Full gate cascade: quick executor,
+ *      build executor, plan validation, plan executor, review planner,
+ *      review verifier, milestone complete, milestone summary, build
+ *      dependency, doc existence, non-PBR agent, checkpoint manifest,
+ *      debugger advisory, active skill integrity, user confirmation.
+ *      Can block (exit 2) or advise (exit 0).
+ *
+ * Exit codes:
+ *   0 = allowed or warning only
+ *   2 = blocked (budget exceeded or gate blocked)
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { logHook } = require('./hook-logger');
+const { checkBudget } = require('./enforce-context-budget');
+const { checkNonPbrAgent } = require('./enforce-pbr-workflow');
+const { KNOWN_AGENTS } = require('./lib/core');
+
+// Gate modules
+const { checkQuickExecutorGate } = require('./lib/gates/quick-executor');
+const { checkBuildExecutorGate } = require('./lib/gates/build-executor');
+const { checkPlanExecutorGate } = require('./lib/gates/plan-executor');
+const { checkReviewPlannerGate } = require('./lib/gates/review-planner');
+const { checkReviewVerifierGate } = require('./lib/gates/review-verifier');
+const { checkMilestoneCompleteGate } = require('./lib/gates/milestone-complete');
+const { checkMilestoneSummaryGate } = require('./lib/gates/milestone-summary');
+const { checkBuildDependencyGate } = require('./lib/gates/build-dependency');
+const { checkPlanValidationGate } = require('./lib/gates/plan-validation');
+const { checkDebuggerAdvisory, checkCheckpointManifest, checkActiveSkillIntegrity } = require('./lib/gates/advisories');
+const { checkDocExistence } = require('./lib/gates/doc-existence');
+const { checkUserConfirmationGate } = require('./lib/gates/user-confirmation');
+
+const MAX_DESCRIPTION_LENGTH = 100;
+
+/**
+ * Check a parsed hook data object for Task() validation issues.
+ * Returns an array of warning strings (empty if all good).
+ */
+function checkTask(data) {
+  const warnings = [];
+  const toolInput = data.tool_input || {};
+
+  const description = toolInput.description;
+  const subagentType = toolInput.subagent_type;
+
+  if (!description || (typeof description === 'string' && !description.trim())) {
+    warnings.push('Task() called without a description. Descriptions are required for audit logging and skill enforcement. Add a short description (3-5 words), e.g.: "Build phase 3 executor".');
+  } else if (typeof description === 'string') {
+    if (description.length > MAX_DESCRIPTION_LENGTH) {
+      warnings.push(
+        `Task() description is ${description.length} chars (recommended <=100). ` +
+        'Keep descriptions to 3-5 words.'
+      );
+    }
+    if (/\bpbr:/.test(description) && !subagentType) {
+      warnings.push(
+        'Task() description contains "pbr:" but no subagent_type is set. ' +
+        'Use subagent_type: "pbr:{name}" for automatic agent loading.'
+      );
+    }
+  }
+
+  if (typeof subagentType === 'string' && subagentType.startsWith('pbr:')) {
+    const agentName = subagentType.slice(4);
+    if (!KNOWN_AGENTS.includes(agentName)) {
+      warnings.push(
+        `Unknown pbr agent type: "${subagentType}". ` +
+        `Known types: ${KNOWN_AGENTS.map(a => 'pbr:' + a).join(', ')}`
+      );
+    }
+  }
+
+  return warnings;
+}
+
+/**
+ * Core dispatch logic for PreToolUse:Task events.
+ *
+ * Step 1: Budget check (cheap, fast — short-circuits on block)
+ * Step 2: Gate cascade from validate-task (expensive — all blocking gates)
+ * Step 3: Advisory warnings (non-blocking)
+ *
+ * @param {Object} data - Parsed hook event data
+ * @returns {Object} { decision: 'block'|'allow', reason?: string, additionalContext?: string }
+ */
+async function processEvent(data) {
+  // Step 1 — Budget check (cheap, fast)
+  const planningDir = path.join(data.cwd || process.env.PBR_PROJECT_ROOT || process.cwd(), '.planning');
+  const budgetResult = checkBudget({ toolName: 'Task', planningDir });
+  if (budgetResult) {
+    logHook('pre-task-dispatch', 'PreToolUse', 'blocked', { handler: 'enforce-context-budget' });
+    return budgetResult; // already { decision: 'block', reason: '...' }
+  }
+
+  // Step 2 — Gate cascade (expensive, blocking checks)
+
+  // User confirmation gate
+  const userConfGate = checkUserConfirmationGate(data);
+  if (userConfGate && userConfGate.block) {
+    logHook('pre-task-dispatch', 'PreToolUse', 'blocked', { handler: 'user-confirmation', reason: userConfGate.reason });
+    return { decision: 'block', reason: userConfGate.reason };
+  }
+
+  // Quick executor gate
+  const quickGate = checkQuickExecutorGate(data);
+  if (quickGate && quickGate.block) {
+    logHook('pre-task-dispatch', 'PreToolUse', 'blocked', { handler: 'quick-executor', reason: quickGate.reason });
+    return { decision: 'block', reason: quickGate.reason };
+  }
+
+  // Build executor gate
+  const buildGate = checkBuildExecutorGate(data);
+  if (buildGate && buildGate.block) {
+    logHook('pre-task-dispatch', 'PreToolUse', 'blocked', { handler: 'build-executor', reason: buildGate.reason });
+    return { decision: 'block', reason: buildGate.reason };
+  }
+
+  // Plan validation gate
+  const planValGate = checkPlanValidationGate(data);
+  if (planValGate && planValGate.block) {
+    logHook('pre-task-dispatch', 'PreToolUse', 'blocked', { handler: 'plan-validation', reason: planValGate.reason });
+    return { decision: 'block', reason: planValGate.reason };
+  }
+
+  // Review planner gate
+  const reviewGate = checkReviewPlannerGate(data);
+  if (reviewGate && reviewGate.block) {
+    logHook('pre-task-dispatch', 'PreToolUse', 'blocked', { handler: 'review-planner', reason: reviewGate.reason });
+    return { decision: 'block', reason: reviewGate.reason };
+  }
+
+  // Plan executor gate
+  const planGate = checkPlanExecutorGate(data);
+  if (planGate && planGate.block) {
+    logHook('pre-task-dispatch', 'PreToolUse', 'blocked', { handler: 'plan-executor', reason: planGate.reason });
+    return { decision: 'block', reason: planGate.reason };
+  }
+
+  // Review verifier gate
+  const reviewVerifierGate = checkReviewVerifierGate(data);
+  if (reviewVerifierGate && reviewVerifierGate.block) {
+    logHook('pre-task-dispatch', 'PreToolUse', 'blocked', { handler: 'review-verifier', reason: reviewVerifierGate.reason });
+    return { decision: 'block', reason: reviewVerifierGate.reason };
+  }
+
+  // Milestone complete gate
+  const milestoneGate = checkMilestoneCompleteGate(data);
+  if (milestoneGate && milestoneGate.block) {
+    logHook('pre-task-dispatch', 'PreToolUse', 'blocked', { handler: 'milestone-complete', reason: milestoneGate.reason });
+    return { decision: 'block', reason: milestoneGate.reason };
+  }
+
+  // Milestone summary gate
+  const milestoneSummaryGate = checkMilestoneSummaryGate(data);
+  if (milestoneSummaryGate && milestoneSummaryGate.block) {
+    logHook('pre-task-dispatch', 'PreToolUse', 'blocked', { handler: 'milestone-summary', reason: milestoneSummaryGate.reason });
+    return { decision: 'block', reason: milestoneSummaryGate.reason };
+  }
+
+  // Build dependency gate
+  const buildDepGate = checkBuildDependencyGate(data);
+  if (buildDepGate && buildDepGate.block) {
+    logHook('pre-task-dispatch', 'PreToolUse', 'blocked', { handler: 'build-dependency', reason: buildDepGate.reason });
+    return { decision: 'block', reason: buildDepGate.reason };
+  }
+
+  // Doc existence gate
+  const docGate = checkDocExistence(data);
+  if (docGate && docGate.block) {
+    logHook('pre-task-dispatch', 'PreToolUse', 'blocked', { handler: 'doc-existence', reason: docGate.reason });
+    return { decision: 'block', reason: docGate.reason };
+  }
+
+  // Non-PBR agent enforcement
+  const nonPbrAgentResult = checkNonPbrAgent(data);
+  if (nonPbrAgentResult && nonPbrAgentResult.exitCode === 2) {
+    logHook('pre-task-dispatch', 'PreToolUse', 'blocked', { handler: 'enforce-pbr-workflow' });
+    return nonPbrAgentResult.output;
+  }
+
+  // Step 3 — Advisory warnings (non-blocking)
+  const warnings = checkTask(data);
+  if (userConfGate && userConfGate.warning) warnings.push(userConfGate.warning);
+  const manifestWarning = checkCheckpointManifest(data);
+  if (manifestWarning) warnings.push(manifestWarning);
+  const debuggerWarning = checkDebuggerAdvisory(data);
+  if (debuggerWarning) warnings.push(debuggerWarning);
+  const activeSkillWarning = checkActiveSkillIntegrity(data);
+  if (activeSkillWarning) warnings.push(activeSkillWarning);
+  if (nonPbrAgentResult) warnings.push(nonPbrAgentResult.output.additionalContext);
+  if (planValGate && planValGate.warning) warnings.push(planValGate.warning);
+
+  if (warnings.length > 0) {
+    for (const warning of warnings) {
+      logHook('pre-task-dispatch', 'PreToolUse', 'warn', { warning });
+    }
+    return {
+      decision: 'allow',
+      additionalContext: 'Task() validation warnings:\n' + warnings.map(w => '- ' + w).join('\n')
+    };
+  }
+
+  // All clear
+  logHook('pre-task-dispatch', 'PreToolUse', 'allow', {});
+  return { decision: 'allow' };
+}
+
+/**
+ * HTTP handler for hook-server integration.
+ *
+ * @param {Object} reqBody - HTTP request body with { data: {...} }
+ * @param {Object} _cache - Hook server cache (unused)
+ * @returns {Object|null} Hook result or null on error
+ */
+async function handleHttp(reqBody, _cache) {
+  try {
+    const data = reqBody.data || {};
+    return await processEvent(data);
+  } catch (_e) {
+    return null;
+  }
+}
+
+function main() {
+  let input = '';
+
+  process.stdin.setEncoding('utf8');
+  process.stdin.on('data', (chunk) => { input += chunk; });
+  process.stdin.on('end', async () => {
+    try {
+      const data = JSON.parse(input);
+      const result = await processEvent(data);
+
+      if (result && result.decision === 'block') {
+        process.stdout.write(JSON.stringify(result));
+        process.exit(2);
+        return;
+      }
+
+      process.stdout.write(JSON.stringify(result || {}));
+      process.exit(0);
+    } catch (_e) {
+      process.stderr.write(`[pbr] pre-task-dispatch error: ${_e.message}\n`);
+      process.stdout.write(JSON.stringify({ decision: 'allow', additionalContext: '[PBR] pre-task-dispatch failed: ' + _e.message }));
+      process.exit(0);
+    }
+  });
+}
+
+module.exports = { handleHttp, processEvent };
+if (require.main === module || process.argv[1] === __filename) { main(); }

package/plugins/pbr/dist/pre-write-dispatch.js

@@ -0,0 +1,234 @@
+#!/usr/bin/env node
+
+/**
+ * PreToolUse dispatcher for Write|Edit hooks.
+ *
+ * Consolidates all PreToolUse Write|Edit checks into a single process,
+ * reading stdin once and running all checks sequentially.
+ *
+ * -- Dispatch Order & Rationale --
+ *
+ *   1. enforce-pbr-workflow  -- Warns or blocks source code writes that
+ *      happen without an active PBR skill. Runs first because this is
+ *      the most fundamental enforcement: if no PBR skill is managing
+ *      the session, all other skill-specific checks are moot.
+ *      Can block (exit 2) or advise (exit 0). Config-driven.
+ *
+ *   2. check-agent-state-write -- Blocks subagents from writing STATE.md
+ *      directly (except pbr:general). Runs before skill-specific checks
+ *      because agent isolation is a hard invariant. Can block (exit 2).
+ *
+ *   3. check-skill-workflow  -- Enforces planning-phase rules (e.g. no
+ *      code writes during the plan phase). Can block (exit 2).
+ *
+ *   4. check-summary-gate    -- Blocks STATE.md status advancement
+ *      (to built/verified/complete) unless a SUMMARY file exists for
+ *      the current phase. Can block (exit 2).
+ *
+ *   5. check-phase-boundary  -- Guards against writes that target files
+ *      outside the current phase directory. Can block (exit 2)
+ *      or warn (exit 0 with message).
+ *
+ *   6. check-doc-sprawl      -- Prevents creation of new .md/.txt files
+ *      outside a known allowlist (when enabled in config). Can block (exit 2).
+ *
+ *   7. prompt-guard           -- Scans .planning/ writes for prompt injection
+ *      patterns. Advisory only (exit 0).
+ *
+ * -- Short-Circuit Behavior --
+ *
+ *   If an earlier check returns a result (blocking or warning with
+ *   output), later checks are skipped entirely. For blocking results
+ *   (exit 2), this means the write is rejected without evaluating
+ *   remaining checks. This is intentional: the first failure is the
+ *   most relevant, and running further checks would be wasteful.
+ *
+ * -- Adding New Checks --
+ *
+ *   1. Create a new check module exporting a function that takes
+ *      the parsed hook data and returns null (pass) or
+ *      { output: {...}, exitCode: N }.
+ *   2. require() it at the top of this file.
+ *   3. Add the call in sequence below, following the pattern:
+ *        const result = checkFoo(data);
+ *        if (result) { write output; exit with code; }
+ *   4. Position the check based on severity: more fundamental /
+ *      broader checks should run earlier; narrow / granular checks
+ *      should run later.
+ *
+ * Exit codes:
+ *   0 = allowed or warning only
+ *   2 = blocked (workflow violation or phase boundary enforcement)
+ */
+
+const { logHook } = require('./hook-logger');
+const { checkAgentStateWrite } = require('./check-agent-state-write');
+const { checkWorkflow } = require('./check-skill-workflow');
+const { checkSummaryGate } = require('./check-summary-gate');
+const { checkBoundary } = require('./check-phase-boundary');
+const { checkDocSprawl } = require('./check-doc-sprawl');
+const { checkPromptInjection } = require('./prompt-guard');
+const { checkUnmanagedSourceWrite } = require('./enforce-pbr-workflow');
+
+/**
+ * Core dispatch logic extracted for both stdin (main) and HTTP (handleHttp) paths.
+ *
+ * Runs checks sequentially with short-circuit on first block.
+ * Advisory results are returned as { decision: 'allow', additionalContext }.
+ *
+ * @param {Object} data - Parsed hook input (same as stdin JSON)
+ * @returns {Object|null} Hook response: { decision: 'block', reason } or { decision: 'allow', additionalContext? } or advisory output or null
+ */
+function processEvent(data) {
+  try {
+    // Unmanaged source write check -- runs first as the most fundamental
+    // workflow enforcement: warn/block when source code is edited without
+    // an active PBR skill managing the session.
+    const unmanagedResult = checkUnmanagedSourceWrite(data);
+    if (unmanagedResult) {
+      if (unmanagedResult.exitCode === 2) {
+        return { decision: 'block', reason: unmanagedResult.output.reason || unmanagedResult.output.additionalContext || 'Unmanaged source write blocked' };
+      }
+      return unmanagedResult.output;
+    }
+
+    // Agent STATE.md write blocker -- most fundamental check
+    const agentResult = checkAgentStateWrite(data);
+    if (agentResult) {
+      if (agentResult.exitCode === 2) {
+        return { decision: 'block', reason: agentResult.output.reason || agentResult.output.additionalContext || 'Agent STATE.md write blocked' };
+      }
+      return agentResult.output;
+    }
+
+    // Skill workflow check -- can block
+    const workflowResult = checkWorkflow(data);
+    if (workflowResult) {
+      if (workflowResult.exitCode === 2) {
+        return { decision: 'block', reason: workflowResult.output.reason || workflowResult.output.additionalContext || 'Workflow violation' };
+      }
+      return workflowResult.output;
+    }
+
+    // SUMMARY gate -- blocks STATE.md advancement without SUMMARY
+    const summaryGateResult = checkSummaryGate(data);
+    if (summaryGateResult) {
+      if (summaryGateResult.exitCode === 2) {
+        return { decision: 'block', reason: summaryGateResult.output.reason || summaryGateResult.output.additionalContext || 'Summary gate violation' };
+      }
+      return summaryGateResult.output;
+    }
+
+    // Phase boundary check -- can block or warn
+    const boundaryResult = checkBoundary(data);
+    if (boundaryResult) {
+      if (boundaryResult.exitCode === 2) {
+        return { decision: 'block', reason: boundaryResult.output.reason || boundaryResult.output.additionalContext || 'Phase boundary violation' };
+      }
+      return boundaryResult.output;
+    }
+
+    // Doc sprawl check -- blocks new .md/.txt outside allowlist
+    const sprawlResult = checkDocSprawl(data);
+    if (sprawlResult) {
+      if (sprawlResult.exitCode === 2) {
+        return { decision: 'block', reason: sprawlResult.output.reason || sprawlResult.output.additionalContext || 'Doc sprawl blocked' };
+      }
+      return sprawlResult.output;
+    }
+
+    // Prompt injection scan -- advisory only (never blocks)
+    const injectionResult = checkPromptInjection(data);
+    if (injectionResult) {
+      return injectionResult.output;
+    }
+
+    // Soft warning: writing outside current phase directory
+    // (only when all hard checks passed and we're in a phase)
+    const filePath = data.tool_input?.file_path || data.tool_input?.path || '';
+    if (filePath) {
+      const normalized = filePath.replace(/\\/g, '/');
+      // Warn about writes to other phase directories (not blocked, just advisory)
+      const phaseMatch = normalized.match(/\.planning\/phases\/(\d+)-/);
+      if (phaseMatch) {
+        const fs = require('fs');
+        const path = require('path');
+        const statePath = path.join(process.env.PBR_PROJECT_ROOT || process.cwd(), '.planning', 'STATE.md');
+        try {
+          const stateContent = fs.readFileSync(statePath, 'utf8');
+          const currentPhase = stateContent.match(/Phase:\s*(\d+)\s+of/);
+          if (currentPhase && parseInt(phaseMatch[1], 10) !== parseInt(currentPhase[1], 10)) {
+            return {
+              additionalContext: `[pbr] Advisory: writing to phase ${phaseMatch[1]} but current phase is ${currentPhase[1]}. Ensure this cross-phase write is intentional.`
+            };
+          }
+        } catch (_e) {
+          // No STATE.md -- skip warning
+        }
+      }
+    }
+
+    // Log pass-through so hook activity is visible in logs AND session JSONL
+    const file = (data.tool_input?.file_path || data.tool_input?.path || '').split(/[/\\]/).pop();
+    logHook('pre-write-dispatch', 'PreToolUse', 'allow', { file });
+    return { decision: 'allow' };
+  } catch (e) {
+    logHook('pre-write-dispatch', 'PreToolUse', 'error', { error: e.message });
+    return null;
+  }
+}
+
+/**
+ * HTTP handler for hook-server.js.
+ * Called as handleHttp(reqBody, cache) where reqBody = { event, tool, data, planningDir, cache }.
+ * Must NOT call process.exit().
+ *
+ * @param {Object} reqBody - Request body from hook-server
+ * @param {Object} _cache - In-memory server cache (unused)
+ * @returns {Object|null} Hook response or null
+ */
+async function handleHttp(reqBody, _cache) {
+  const data = reqBody.data || {};
+  try {
+    return processEvent(data);
+  } catch (_e) {
+    logHook('pre-write-dispatch', 'PreToolUse', 'error', { error: _e.message });
+    return null;
+  }
+}
+
+module.exports = { handleHttp, processEvent };
+
+function main() {
+  let input = '';
+
+  process.stdin.setEncoding('utf8');
+  process.stdin.on('data', (chunk) => { input += chunk; });
+  process.stdin.on('end', () => {
+    try {
+      const data = JSON.parse(input);
+
+      const result = processEvent(data);
+
+      if (result && result.decision === 'block') {
+        process.stdout.write(JSON.stringify(result));
+        process.exit(2);
+      }
+
+      if (result) {
+        process.stdout.write(JSON.stringify(result));
+      } else {
+        // processEvent returned null (error) -- allow through
+        process.stdout.write(JSON.stringify({ decision: 'allow' }));
+      }
+      process.exit(0);
+    } catch (_e) {
+      // Don't block on errors -- emit valid output for Claude Code
+      process.stderr.write(`[pbr] pre-write-dispatch error: ${_e.message}\n`);
+      process.stdout.write(JSON.stringify({ decision: "allow", additionalContext: '\u26a0 [PBR] pre-write-dispatch failed: ' + _e.message }));
+      process.exit(0);
+    }
+  });
+}
+
+if (require.main === module || process.argv[1] === __filename) { main(); }