@sienklogic/plan-build-run 2.34.0 → 2.38.0

package/plugins/pbr/references/verification-patterns.md

@@ -4,9 +4,9 @@ Reference patterns for deriving verification criteria from goals. Used by the pl
 
 ---
 
-## The Three-Layer Check
+## The Four-Layer Check
 
-Every must-have is verified through three layers, checked in order:
+Every must-have is verified through up to four layers, checked in order:
 
 ### Layer 1: Existence
 
@@ -62,6 +62,28 @@ grep -q "prisma" src/app.ts
 grep -q "DISCORD_CLIENT_ID" src/auth/discord.ts
 ```
 
+### Layer 4: Functional
+
+Does the artifact actually work when executed?
+
+```bash
+# Tests pass
+npm test -- --testPathPattern auth
+pytest tests/test_auth.py -v
+
+# Build succeeds
+npm run build
+npx tsc --noEmit
+
+# API returns correct data
+curl -s http://localhost:3000/api/auth/login -X POST -d '{"code":"test"}' | jq '.token'
+
+# CLI produces expected output
+node src/cli.js --help | grep -q "Usage:"
+```
+
+**When to apply L4:** Only when automated verification commands exist (test suites, build scripts, API endpoints with test data). Skip for items requiring manual/visual testing. L4 is optional — artifacts passing L1-L3 without available automated tests are reported as `PASSED (L3 only)`.
+
 ---
 
 ## Verification by Feature Type
@@ -69,41 +91,46 @@ grep -q "DISCORD_CLIENT_ID" src/auth/discord.ts
 ### API Endpoint
 
 ```
-Existence:  curl returns non-404 status
-Substance:  curl returns expected response shape (correct fields)
-Wiring:     endpoint calls the right service, middleware is applied
+Existence:   curl returns non-404 status
+Substance:   curl returns expected response shape (correct fields)
+Wiring:      endpoint calls the right service, middleware is applied
+Functional:  POST/GET with test data returns correct response, error cases handled
 ```
 
 ### Database Schema
 
 ```
-Existence:  table/collection exists, can query without error
-Substance:  columns/fields match specification, constraints are applied
-Wiring:     application code references the schema, migrations run cleanly
+Existence:   table/collection exists, can query without error
+Substance:   columns/fields match specification, constraints are applied
+Wiring:      application code references the schema, migrations run cleanly
+Functional:  CRUD operations work end-to-end, constraints reject invalid data
 ```
 
 ### Authentication
 
 ```
-Existence:  auth routes exist, auth module exports functions
-Substance:  login flow returns token, invalid creds return error
-Wiring:     protected routes use auth middleware, tokens are validated
+Existence:   auth routes exist, auth module exports functions
+Substance:   login flow returns token, invalid creds return error
+Wiring:      protected routes use auth middleware, tokens are validated
+Functional:  auth tests pass (valid token, expired token, missing token, malformed token)
 ```
 
 ### UI Component
 
 ```
-Existence:  component file exists, exports default component
-Substance:  component renders expected elements (test or visual check)
-Wiring:     component is imported in parent, receives correct props, routes to it
+Existence:   component file exists, exports default component
+Substance:   component renders expected elements (test or visual check)
+Wiring:      component is imported in parent, receives correct props, routes to it
+Functional:  component tests pass, build succeeds with component included
 ```
 
 ### Configuration
 
 ```
-Existence:  config file exists, environment variables documented
-Substance:  config values are used (not dead code), defaults are sensible
-Wiring:     application reads config at startup, config changes take effect
+Existence:   config file exists, environment variables documented
+Substance:   config values are used (not dead code), defaults are sensible
+Wiring:      application reads config at startup, config changes take effect
+Functional:  app starts with config, missing config produces clear error message
 ```
 
 ---
@@ -196,3 +223,55 @@ Bad:  "Tests pass"
 Good: "All 5 auth middleware tests pass: valid token, expired token,
        missing token, malformed token, and correct user extraction"
 ```
+
+---
+
+## Wiring Verification Patterns
+
+4 concrete patterns for verifying components are actually connected, not just present.
+
+### Pattern 1: Component to API
+1. Find the fetch/axios call in the component
+2. Verify the call is NOT commented out
+3. Verify the response is assigned to state (not discarded)
+4. Verify error handling exists (try/catch or .catch)
+
+### Pattern 2: API to Database
+1. Find the database query in the route handler
+2. Verify `await` is present (not fire-and-forget)
+3. Verify the result is returned in the response (not discarded)
+4. Verify error cases return appropriate HTTP status codes
+
+### Pattern 3: Form to Handler
+1. Find the form's onSubmit handler
+2. Verify it calls an API function (not just preventDefault)
+3. Verify form validation runs before the API call
+4. Verify success/error feedback is shown to the user
+
+### Pattern 4: State to Render
+1. Find state variables (useState, store, etc.)
+2. Verify they appear in JSX/template via .map(), interpolation, or conditional rendering
+3. Verify loading/error states are rendered (not just success state)
+4. Verify empty state is handled (not just "no data" crash)
+
+### Quick Verification Checklists
+
+**Component Checklist (8 items):**
+- [ ] Component file exists and exports correctly
+- [ ] Props/types are defined (not `any`)
+- [ ] API calls use actual endpoints (not hardcoded data)
+- [ ] Loading state renders something meaningful
+- [ ] Error state renders something meaningful
+- [ ] Empty state renders something meaningful
+- [ ] User interactions trigger actual handlers
+- [ ] Component is imported and rendered in parent
+
+**API Route Checklist (8 items):**
+- [ ] Route file exists and exports handler
+- [ ] Route is registered in router/app
+- [ ] Request validation exists (body, params, query)
+- [ ] Database query uses parameterized inputs
+- [ ] Success response includes expected data shape
+- [ ] Error response includes status code and message
+- [ ] Authentication/authorization check exists if needed
+- [ ] Response matches what the frontend expects

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

@@ -194,7 +194,7 @@ function validatePlan(content, _filePath) {
 
     // Skip checkpoint tasks - they have different required elements
     const taskTag = taskTags[index] || '';
-    if (taskTag.includes('checkpoint')) {
+    if (/\btype\s*=\s*["']?checkpoint/i.test(taskTag) || /\bcheckpoint\s*[:=]/i.test(taskTag)) {
       return; // Checkpoint tasks have different structure
     }
 
@@ -205,6 +205,18 @@ function validatePlan(content, _filePath) {
     }
   });
 
+  // Path traversal check: ensure <files> elements don't escape project root
+  const filesTags = content.match(/<files>([\s\S]*?)<\/files>/g) || [];
+  for (const filesTag of filesTags) {
+    const filesContent = filesTag.replace(/<\/?files>/g, '');
+    const paths = filesContent.split(/[\n,]/).map(p => p.trim()).filter(Boolean);
+    for (const p of paths) {
+      if (p.includes('..') || path.isAbsolute(p.replace(/^[A-Za-z]:/, ''))) {
+        warnings.push(`Path traversal risk in <files>: "${p}" — use relative paths without ".." segments`);
+      }
+    }
+  }
+
   return { errors, warnings };
 }
 

package/plugins/pbr/scripts/check-state-sync.js

@@ -26,7 +26,25 @@ const fs = require('fs');
 const path = require('path');
 const { logHook } = require('./hook-logger');
 const { logEvent } = require('./event-logger');
-const { lockedFileUpdate } = require('./pbr-tools');
+
+/**
+ * Write content to a file atomically using write-then-rename.
+ * Writes to a PID-stamped temp file, then renames over the original.
+ * If the rename fails, cleans up the temp file and re-throws.
+ *
+ * @param {string} filePath - Target file path
+ * @param {string} content - Content to write
+ */
+function atomicWriteFile(filePath, content) {
+  const tmpPath = filePath + '.tmp.' + process.pid;
+  try {
+    fs.writeFileSync(tmpPath, content, 'utf8');
+    fs.renameSync(tmpPath, filePath);
+  } catch (e) {
+    try { fs.unlinkSync(tmpPath); } catch (_) { /* best effort cleanup */ }
+    throw e;
+  }
+}
 
 /**
  * Extract phase number from a phase directory name.
@@ -326,7 +344,7 @@ function checkStateSync(data) {
     return null;
   }
 
-  const cwd = process.cwd();
+  const cwd = process.env.PBR_PROJECT_ROOT || process.cwd();
   const planningDir = path.join(cwd, '.planning');
   const roadmapPath = path.join(planningDir, 'ROADMAP.md');
   const statePath = path.join(planningDir, 'STATE.md');
@@ -370,7 +388,7 @@ function checkStateSync(data) {
         } else {
           const updatedRoadmap = updateProgressTable(roadmapContent, phaseNum, plansComplete, newStatus, completedDate);
           if (updatedRoadmap !== roadmapContent) {
-            lockedFileUpdate(roadmapPath, () => updatedRoadmap);
+            atomicWriteFile(roadmapPath, updatedRoadmap);
             messages.push(`ROADMAP.md: Phase ${phaseNum} → ${plansComplete} plans, ${newStatus}`);
           }
         }
@@ -410,7 +428,7 @@ function checkStateSync(data) {
 
         const updatedState = updateStatePosition(stateContent, stateUpdates);
         if (updatedState !== stateContent) {
-          lockedFileUpdate(statePath, () => updatedState);
+          atomicWriteFile(statePath, updatedState);
           messages.push(`STATE.md: ${artifacts.completeSummaries}/${artifacts.plans} plans, ${overallPct}%`);
         }
       } catch (e) {
@@ -455,7 +473,7 @@ function checkStateSync(data) {
         } else {
           const updatedRoadmap = updateProgressTable(roadmapContent, phaseNum, plansComplete, roadmapStatus, completedDate);
           if (updatedRoadmap !== roadmapContent) {
-            lockedFileUpdate(roadmapPath, () => updatedRoadmap);
+            atomicWriteFile(roadmapPath, updatedRoadmap);
             messages.push(`ROADMAP.md: Phase ${phaseNum} → ${roadmapStatus}`);
           }
         }
@@ -493,7 +511,7 @@ function checkStateSync(data) {
 
         const updatedState = updateStatePosition(stateContent, stateUpdates);
         if (updatedState !== stateContent) {
-          lockedFileUpdate(statePath, () => updatedState);
+          atomicWriteFile(statePath, updatedState);
           messages.push(`STATE.md: ${stateStatus}, ${overallPct}%`);
         }
       } catch (e) {
@@ -543,7 +561,7 @@ function checkStateSync(data) {
             const plansComplete = `${artifacts.completeSummaries}/${artifacts.plans}`;
             const updatedRoadmap = updateProgressTable(roadmapContent, phaseNum, plansComplete, 'Planning', null);
             if (updatedRoadmap !== roadmapContent) {
-              lockedFileUpdate(roadmapPath, () => updatedRoadmap);
+              atomicWriteFile(roadmapPath, updatedRoadmap);
               messages.push(`ROADMAP.md: Phase ${phaseNum} → Planning`);
             }
           }
@@ -588,6 +606,7 @@ function main() {
 
 if (require.main === module || process.argv[1] === __filename) { main(); }
 module.exports = {
+  atomicWriteFile,
   extractPhaseNum,
   countPhaseArtifacts,
   updateProgressTable,

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

@@ -20,6 +20,7 @@
 const fs = require('fs');
 const path = require('path');
 const { logHook } = require('./hook-logger');
+const { KNOWN_AGENTS } = require('./pbr-tools');
 const { resolveConfig } = require('./local-llm/health');
 const { classifyError } = require('./local-llm/operations/classify-error');
 
@@ -27,7 +28,7 @@ const { classifyError } = require('./local-llm/operations/classify-error');
  * Check if a file was modified recently (within thresholdMs).
  * Returns false if file doesn't exist or on error.
  */
-function isRecent(filePath, thresholdMs = 300000) {
+function isRecent(filePath, thresholdMs = 1800000) {
   try {
     const stat = fs.statSync(filePath);
     return (Date.now() - stat.mtimeMs) < thresholdMs;
@@ -151,6 +152,25 @@ const AGENT_OUTPUTS = {
     description: 'advisory output (no file expected)',
     noFileExpected: true,
     check: () => []
+  },
+  'pbr:audit': {
+    description: 'audit report in .planning/audits/',
+    check: (planningDir) => {
+      const auditsDir = path.join(planningDir, 'audits');
+      if (!fs.existsSync(auditsDir)) return [];
+      try {
+        return fs.readdirSync(auditsDir)
+          .filter(f => f.endsWith('.md'))
+          .map(f => path.join('audits', f));
+      } catch (_e) {
+        return [];
+      }
+    }
+  },
+  'pbr:dev-sync': {
+    description: 'advisory output (no file expected)',
+    noFileExpected: true,
+    check: () => []
   }
 };
 
@@ -324,7 +344,7 @@ function loadLocalLlmConfig(cwd) {
 
 async function main() {
   const data = readStdin();
-  const cwd = process.cwd();
+  const cwd = process.env.PBR_PROJECT_ROOT || process.cwd();
   const planningDir = path.join(cwd, '.planning');
 
   // Only relevant for Plan-Build-Run projects
@@ -338,6 +358,14 @@ async function main() {
   // Only check known Plan-Build-Run agent types
   const outputSpec = AGENT_OUTPUTS[agentType];
   if (!outputSpec) {
+    // Log when agent is in KNOWN_AGENTS but missing from AGENT_OUTPUTS
+    const shortName = agentType.startsWith('pbr:') ? agentType.slice(4) : agentType;
+    if (KNOWN_AGENTS && KNOWN_AGENTS.includes && KNOWN_AGENTS.includes(shortName)) {
+      logHook('check-subagent-output', 'PostToolUse', 'missing-output-spec', {
+        agent_type: agentType,
+        message: `Agent ${agentType} is in KNOWN_AGENTS but has no AGENT_OUTPUTS entry. Add one to check-subagent-output.js.`
+      });
+    }
     process.exit(0);
   }
 

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

@@ -4,7 +4,8 @@
   "description": "Configuration schema for .planning/config.json",
   "type": "object",
   "properties": {
-    "version": { "type": "integer", "enum": [1, 2] },
+    "version": { "type": ["integer", "string"], "enum": [1, 2, "1", "2"], "description": "Planning format version. v2 is current." },
+    "schema_version": { "type": "integer", "enum": [1], "description": "Config schema version for migration detection. Increment when config structure changes." },
     "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)" },
@@ -131,6 +132,15 @@
       },
       "additionalProperties": false
     },
+    "timeouts": {
+      "type": "object",
+      "properties": {
+        "task_default_ms": { "type": "integer", "minimum": 30000, "description": "Default timeout per task in milliseconds (default: 300000 = 5 min)" },
+        "build_max_ms": { "type": "integer", "minimum": 60000, "description": "Maximum time for entire build command in milliseconds" },
+        "verify_max_ms": { "type": "integer", "minimum": 30000, "description": "Maximum time for verification in milliseconds" }
+      },
+      "additionalProperties": false
+    },
     "hooks": {
       "type": "object",
       "properties": {

package/plugins/pbr/scripts/context-bridge.js

@@ -0,0 +1,265 @@
+#!/usr/bin/env node
+
+/**
+ * PostToolUse hook: Context monitor bridge.
+ *
+ * Replaces heuristic context budget estimation with real data when available.
+ * Writes context state to .planning/.context-budget.json for consumption by
+ * track-context-budget.js and suggest-compact.js.
+ *
+ * Context tiers:
+ *   PEAK      (0-30%)  — no warnings
+ *   GOOD      (30-50%) — no warnings
+ *   DEGRADING (50-70%) — suggest subagent delegation
+ *   POOR      (70-85%) — recommend /pbr:pause
+ *   CRITICAL  (85%+)   — urgent stop, context rot imminent
+ *
+ * Debounce: same-tier warnings suppressed for 5 tool calls (2 for CRITICAL).
+ * Tier escalation always warns immediately.
+ *
+ * Exit codes:
+ *   0 = always (PostToolUse hook, advisory only)
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { logHook } = require('./hook-logger');
+
+const TIERS = [
+  { name: 'PEAK', min: 0, max: 30 },
+  { name: 'GOOD', min: 30, max: 50 },
+  { name: 'DEGRADING', min: 50, max: 70 },
+  { name: 'POOR', min: 70, max: 85 },
+  { name: 'CRITICAL', min: 85, max: 100 }
+];
+
+const TIER_MESSAGES = {
+  DEGRADING: 'Context at ~50-70%. Delegate heavy reads and analysis to Task() subagents to preserve orchestrator quality.',
+  POOR: 'Context at ~70-85%. Run /pbr:pause soon to save state before quality degrades.',
+  CRITICAL: 'STOP — Context at 85%+. Run /pbr:pause NOW. Context rot is imminent — further work risks hallucinations and skipped steps.'
+};
+
+const DEBOUNCE_INTERVAL = 5; // tool calls between same-tier warnings
+const CRITICAL_DEBOUNCE_INTERVAL = 2; // shorter debounce for CRITICAL tier
+
+/**
+ * Determine the context tier for a given percentage.
+ * @param {number} percent - Context usage percentage (0-100)
+ * @returns {{ name: string, min: number, max: number }}
+ */
+function getTier(percent) {
+  for (const tier of TIERS) {
+    if (percent < tier.max) return tier;
+  }
+  return TIERS[TIERS.length - 1];
+}
+
+/**
+ * Load the bridge state file.
+ * @param {string} bridgePath - Absolute path to .context-budget.json
+ * @returns {Object} Bridge state
+ */
+function loadBridge(bridgePath) {
+  try {
+    const content = fs.readFileSync(bridgePath, 'utf8');
+    return JSON.parse(content);
+  } catch (_e) {
+    return null;
+  }
+}
+
+/**
+ * Save the bridge state file atomically.
+ * @param {string} bridgePath - Absolute path to .context-budget.json
+ * @param {Object} data - Bridge state to persist
+ */
+function saveBridge(bridgePath, data) {
+  try {
+    const tmpPath = bridgePath + '.' + process.pid;
+    fs.writeFileSync(tmpPath, JSON.stringify(data, null, 2), 'utf8');
+    fs.renameSync(tmpPath, bridgePath);
+  } catch (_e) {
+    // Best-effort — clean up temp file if rename failed
+    try { fs.unlinkSync(bridgePath + '.' + process.pid); } catch (_e2) { /* best-effort */ }
+  }
+}
+
+/**
+ * Estimate context percentage from heuristic tracker data.
+ * Uses the .context-tracker file written by track-context-budget.js.
+ * Assumes 200k token context window (~800k chars).
+ *
+ * @param {string} planningDir - Path to .planning/
+ * @returns {number} Estimated context usage percentage (0-100)
+ */
+function estimateFromHeuristic(planningDir) {
+  const trackerPath = path.join(planningDir, '.context-tracker');
+  try {
+    const content = fs.readFileSync(trackerPath, 'utf8');
+    const tracker = JSON.parse(content);
+    const totalChars = tracker.total_chars || 0;
+    // 200k tokens ~ 800k chars; use 800000 as denominator
+    const percent = Math.min(100, Math.round((totalChars / 800000) * 100));
+    return percent;
+  } catch (_e) {
+    return 0;
+  }
+}
+
+/**
+ * Check if a tier warning should fire, applying debounce logic.
+ *
+ * @param {Object} bridge - Current bridge state
+ * @param {string} tierName - Current tier name
+ * @returns {boolean} True if warning should fire
+ */
+function shouldWarn(bridge, tierName) {
+  // No warning for PEAK or GOOD
+  if (tierName === 'PEAK' || tierName === 'GOOD') return false;
+
+  const prevTier = bridge.last_warned_tier || 'PEAK';
+  const callsSinceWarn = bridge.calls_since_warn || 0;
+
+  // Tier escalation — always warn
+  const tierOrder = { PEAK: 0, GOOD: 1, DEGRADING: 2, POOR: 3, CRITICAL: 4 };
+  if ((tierOrder[tierName] || 0) > (tierOrder[prevTier] || 0)) {
+    return true;
+  }
+
+  // Same tier — debounce (CRITICAL uses shorter interval)
+  const interval = tierName === 'CRITICAL' ? CRITICAL_DEBOUNCE_INTERVAL : DEBOUNCE_INTERVAL;
+  if (callsSinceWarn >= interval) {
+    return true;
+  }
+
+  return false;
+}
+
+/**
+ * Core bridge logic: update bridge state, return warning if applicable.
+ *
+ * @param {string} planningDir - Path to .planning/
+ * @param {Object} stdinData - Parsed stdin JSON from Claude Code
+ * @returns {{ bridge: Object, output: Object|null }} Updated bridge and optional warning output
+ */
+function updateBridge(planningDir, stdinData) {
+  const bridgePath = path.join(planningDir, '.context-budget.json');
+
+  // Check if Claude Code provides real context percentage in stdin
+  // Look for context_percent, usage_percent, context_usage, or similar fields
+  const contextPercent = stdinData.context_percent
+    || stdinData.usage_percent
+    || (stdinData.context && stdinData.context.percent)
+    || null;
+
+  const source = contextPercent !== null ? 'bridge' : 'heuristic';
+  const estimatedPercent = contextPercent !== null
+    ? Math.round(contextPercent)
+    : estimateFromHeuristic(planningDir);
+
+  // Load existing bridge state
+  let bridge = loadBridge(bridgePath) || {
+    timestamp: new Date().toISOString(),
+    estimated_percent: 0,
+    source: 'heuristic',
+    chars_read: 0,
+    warnings_issued: [],
+    last_warned_tier: 'PEAK',
+    calls_since_warn: 0,
+    tool_calls: 0
+  };
+
+  // Update bridge
+  bridge.timestamp = new Date().toISOString();
+  bridge.estimated_percent = estimatedPercent;
+  bridge.source = source;
+  bridge.tool_calls = (bridge.tool_calls || 0) + 1;
+  bridge.calls_since_warn = (bridge.calls_since_warn || 0) + 1;
+
+  // Read chars from tracker if available
+  const trackerPath = path.join(planningDir, '.context-tracker');
+  try {
+    const tracker = JSON.parse(fs.readFileSync(trackerPath, 'utf8'));
+    bridge.chars_read = tracker.total_chars || 0;
+  } catch (_e) {
+    // Keep existing value
+  }
+
+  const tier = getTier(estimatedPercent);
+  let output = null;
+
+  if (shouldWarn(bridge, tier.name)) {
+    const msg = TIER_MESSAGES[tier.name];
+    if (msg) {
+      bridge.last_warned_tier = tier.name;
+      bridge.calls_since_warn = 0;
+      bridge.warnings_issued = bridge.warnings_issued || [];
+      bridge.warnings_issued.push({
+        tier: tier.name,
+        percent: estimatedPercent,
+        timestamp: new Date().toISOString()
+      });
+
+      // Keep only last 20 warnings
+      if (bridge.warnings_issued.length > 20) {
+        bridge.warnings_issued = bridge.warnings_issued.slice(-20);
+      }
+
+      output = {
+        additionalContext: `[Context Monitor — ${tier.name}] ${estimatedPercent}% used (${source}). ${msg}`
+      };
+    }
+  }
+
+  // Save bridge state
+  saveBridge(bridgePath, bridge);
+
+  return { bridge, output };
+}
+
+function main() {
+  let input = '';
+
+  process.stdin.setEncoding('utf8');
+  process.stdin.on('data', (chunk) => { input += chunk; });
+  process.stdin.on('end', () => {
+    try {
+      const cwd = process.cwd();
+      const planningDir = path.join(cwd, '.planning');
+      if (!fs.existsSync(planningDir)) {
+        process.exit(0);
+      }
+
+      const data = input ? JSON.parse(input) : {};
+      const { output } = updateBridge(planningDir, data);
+
+      if (output) {
+        logHook('context-bridge', 'PostToolUse', 'warn', {
+          percent: output.additionalContext.match(/(\d+)%/)?.[1],
+          source: 'bridge'
+        });
+        process.stdout.write(JSON.stringify(output));
+      }
+
+      process.exit(0);
+    } catch (_e) {
+      // Never block on tracking errors
+      process.exit(0);
+    }
+  });
+}
+
+module.exports = {
+  getTier,
+  loadBridge,
+  saveBridge,
+  estimateFromHeuristic,
+  shouldWarn,
+  updateBridge,
+  TIERS,
+  TIER_MESSAGES,
+  DEBOUNCE_INTERVAL,
+  CRITICAL_DEBOUNCE_INTERVAL
+};
+
+if (require.main === module || process.argv[1] === __filename) { main(); }