specmem-hardwicksoftware 3.5.99

package/claude-hooks/agent-output-interceptor.js

@@ -0,0 +1,193 @@
+#!/usr/bin/env node
+/**
+ * AGENT OUTPUT INTERCEPTOR - Token-saving version
+ * Blocks verbose agent output reads AND TaskOutput to conserve context
+ * Redirects to compact MCP team messages instead
+ */
+
+const specmemPaths = require('./specmem-paths.cjs');
+
+const fs = require('fs');
+const path = require('path');
+
+// Auto-expand cwd for project isolation
+const projectPath = process.env.SPECMEM_PROJECT_PATH || process.cwd();
+const homeDir = process.env.HOME || '/root';
+
+async function main() {
+  // ═══════════════════════════════════════════════════════════════════
+  // BYPASS: Debug mode for when you NEED to read raw agent output
+  // WARNING: Raw agent output = 10k-50k tokens per read!
+  // ═══════════════════════════════════════════════════════════════════
+  // Option 1: SPECMEM_DEBUG_AGENTS=1 env var
+  // Option 2: touch ~/.claude/.debug-agents
+  //
+  // Only use this if you're debugging agent failures!
+  // This burns tokens like crazy - use read_team_messages() normally.
+  // ═══════════════════════════════════════════════════════════════════
+  if (process.env.SPECMEM_DEBUG_AGENTS === '1') {
+    process.exit(0);
+  }
+  const debugFlagPath = path.join(homeDir, '.claude', '.debug-agents');
+  if (fs.existsSync(debugFlagPath)) {
+    process.exit(0);
+  }
+
+  let input = '';
+  process.stdin.setEncoding('utf8');
+  for await (const chunk of process.stdin) input += chunk;
+
+  try {
+    const data = JSON.parse(input);
+    const tool = data.tool_name || '';
+    const toolInput = data.tool_input || {};
+
+    // ═══════════════════════════════════════════════════════════════════
+    // INTERCEPT TaskOutput - This is the main token waster!
+    // TaskOutput returns full verbose JSON which burns 10k+ tokens
+    // ═══════════════════════════════════════════════════════════════════
+    if (tool === 'TaskOutput') {
+      const taskId = toolInput.task_id || 'unknown';
+
+      // Check if task is very recent (< 5 seconds) - allow first check
+      // This gives agents time to post to team channel before we block
+      const taskIdShort = taskId.slice(0, 8);
+
+      // Use a state file to track first access per task
+      const stateDir = path.join(projectPath, 'specmem', 'sockets');
+      const statePath = path.join(stateDir, 'task-output-state.json');
+
+      try {
+        // Ensure state dir exists
+        if (!fs.existsSync(stateDir)) {
+          fs.mkdirSync(stateDir, { recursive: true });
+        }
+
+        // Load or create state
+        let state = {};
+        if (fs.existsSync(statePath)) {
+          try {
+            state = JSON.parse(fs.readFileSync(statePath, 'utf8'));
+          } catch (e) {
+            state = {};
+          }
+        }
+
+        const now = Date.now();
+        const firstAccess = state[taskId];
+
+        if (!firstAccess) {
+          // First time checking this task - allow it through and record timestamp
+          state[taskId] = now;
+          fs.writeFileSync(statePath, JSON.stringify(state));
+          process.exit(0); // Allow first check
+        }
+
+        // Clean up old entries (> 30 min) to prevent state bloat
+        const thirtyMinsAgo = now - 30 * 60 * 1000;
+        for (const [tid, ts] of Object.entries(state)) {
+          if (ts < thirtyMinsAgo) {
+            delete state[tid];
+          }
+        }
+        fs.writeFileSync(statePath, JSON.stringify(state));
+
+      } catch (e) {
+        // On error, allow access (fail open)
+        process.exit(0);
+      }
+
+      // Subsequent access - deny and redirect to team messages
+      console.log(JSON.stringify({
+        hookSpecificOutput: {
+          hookEventName: 'PreToolUse',
+          permissionDecision: 'deny',
+          permissionDecisionReason: `⚡ Token saver: Use mcp__specmem__read_team_messages({limit:5}) to check agent updates. Task ${taskIdShort} results are in team channel. (First check was allowed - subsequent checks blocked)`
+        }
+      }));
+      process.exit(0);
+    }
+
+    // ═══════════════════════════════════════════════════════════════════
+    // INTERCEPT Read/Bash of .output files
+    // ═══════════════════════════════════════════════════════════════════
+    const filePath = toolInput.file_path || toolInput.command || '';
+
+    // Check for agent output files in multiple locations:
+    // 1. Legacy: /tmp/claude/.../tasks/[hash].output
+    // 2. Current: ~/.claude/projects/.../subagents/agent-[hash].jsonl
+    const isLegacyOutput = /\/tmp\/claude\/.*\/tasks\/[a-f0-9]+\.output/.test(filePath);
+    const isSubagentOutput = /\.claude\/projects\/.*\/subagents\/agent-[a-f0-9]+\.jsonl/.test(filePath);
+    const isAgentOutput = isLegacyOutput || isSubagentOutput;
+
+    if (isAgentOutput && (tool === 'Read' || tool === 'Bash')) {
+      // Extract agent ID from either path format
+      const legacyMatch = filePath.match(/tasks\/([a-f0-9]+)\.output/);
+      const subagentMatch = filePath.match(/agent-([a-f0-9]+)\.jsonl/);
+      const agentId = (legacyMatch || subagentMatch)?.[1] || 'unknown';
+
+      // Allow first access per agent (same pattern as TaskOutput)
+      const stateDir = path.join(projectPath, 'specmem', 'sockets');
+      const statePath = path.join(stateDir, 'agent-output-state.json');
+
+      try {
+        if (!fs.existsSync(stateDir)) {
+          fs.mkdirSync(stateDir, { recursive: true });
+        }
+
+        let state = {};
+        if (fs.existsSync(statePath)) {
+          try {
+            state = JSON.parse(fs.readFileSync(statePath, 'utf8'));
+          } catch (e) {
+            state = {};
+          }
+        }
+
+        const now = Date.now();
+        const firstAccess = state[agentId];
+
+        if (!firstAccess) {
+          // First time reading this agent's output - allow it
+          state[agentId] = now;
+          fs.writeFileSync(statePath, JSON.stringify(state));
+          process.exit(0); // Allow first read
+        }
+
+        // Clean up old entries (> 30 min)
+        const thirtyMinsAgo = now - 30 * 60 * 1000;
+        for (const [aid, ts] of Object.entries(state)) {
+          if (ts < thirtyMinsAgo) {
+            delete state[aid];
+          }
+        }
+        fs.writeFileSync(statePath, JSON.stringify(state));
+
+      } catch (e) {
+        // On error, allow access (fail open)
+        process.exit(0);
+      }
+
+      console.log(JSON.stringify({
+        hookSpecificOutput: {
+          hookEventName: 'PreToolUse',
+          permissionDecision: 'deny',
+          permissionDecisionReason: `⚡ Token saver: Use mcp__specmem__read_team_messages() for agent ${agentId.slice(0,8)} results. (First read was allowed - subsequent reads blocked)`
+        }
+      }));
+      process.exit(0);
+    }
+
+    // Allow everything else
+    process.exit(0);
+  } catch (e) {
+    // LOW-44 FIX: Log errors before exit
+    console.error('[agent-output-interceptor] Error:', e.message || e);
+    process.exit(0);
+  }
+}
+
+main().catch((e) => {
+  console.error('[agent-output-interceptor] Unhandled error:', e.message || e);
+  process.exit(0);
+});

package/claude-hooks/agent-type-matcher.js

@@ -0,0 +1,419 @@
+#!/usr/bin/env node
+/**
+ * Agent Type Matcher - Auto-match task requirements to agent capabilities
+ * =======================================================================
+ *
+ * Analyzes the task prompt and automatically selects (or rejects) agent types
+ * based on their ACTUAL capabilities. Prevents issues like:
+ *   - Deploying Explore agents for tasks requiring file writes
+ *   - Using Bash agents for tasks needing code analysis
+ *   - Picking feature-dev agents when Edit/Write is required
+ *
+ * Hook Event: PreToolUse
+ * Matcher: Task
+ * Priority: Should run BEFORE agent-loading-hook.js
+ *
+ * Set SPECMEM_AUTO_MATCH=1 to auto-upgrade agents when capabilities don't match.
+ * Set SPECMEM_STRICT_MATCH=1 to block mismatched agents entirely.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// ============================================================================
+// AGENT CAPABILITY DEFINITIONS - What each agent type CAN and CANNOT do
+// ============================================================================
+
+const AGENT_CAPABILITIES = {
+  // FULL ACCESS AGENTS - Can do everything
+  'general-purpose': {
+    canWrite: true,
+    canRead: true,
+    canBash: true,
+    canSearch: true,
+    canPlan: true,
+    canWebSearch: true,
+    bestFor: ['complex tasks', 'multi-step work', 'any task'],
+    description: 'Full toolset - can do anything',
+    tools: ['All tools available']
+  },
+
+  'Plan': {
+    canWrite: true,
+    canRead: true,
+    canBash: true,
+    canSearch: true,
+    canPlan: true,
+    canWebSearch: true,
+    bestFor: ['architecture', 'design', 'implementation plans'],
+    description: 'Architecture and planning specialist',
+    tools: ['All tools available']
+  },
+
+  // READ-ONLY AGENTS - Cannot modify files!
+  'Explore': {
+    canWrite: false,  // CRITICAL: Cannot write files!
+    canRead: true,
+    canBash: false,
+    canSearch: true,
+    canPlan: false,
+    canWebSearch: true,
+    bestFor: ['codebase exploration', 'finding files', 'understanding code'],
+    description: 'Fast codebase search - READ-ONLY',
+    tools: ['All tools for reading/searching'],
+    warnings: ['Cannot write, edit, or create files']
+  },
+
+  'feature-dev:code-explorer': {
+    canWrite: false,  // No Edit/Write tools!
+    canRead: true,
+    canBash: false,   // Only BashOutput, not full Bash
+    canSearch: true,
+    canPlan: false,
+    canWebSearch: true,
+    bestFor: ['deep code analysis', 'tracing execution', 'understanding features'],
+    description: 'Deep analysis - READ-ONLY',
+    tools: ['Glob', 'Grep', 'LS', 'Read', 'NotebookRead', 'WebFetch', 'TodoWrite', 'WebSearch'],
+    warnings: ['Cannot write, edit, or create files', 'Cannot run arbitrary bash commands']
+  },
+
+  'feature-dev:code-architect': {
+    canWrite: false,
+    canRead: true,
+    canBash: false,
+    canSearch: true,
+    canPlan: true,  // Can plan but not execute
+    canWebSearch: true,
+    bestFor: ['architecture design', 'implementation blueprints', 'feature design'],
+    description: 'Architecture design - READ-ONLY',
+    tools: ['Glob', 'Grep', 'LS', 'Read', 'NotebookRead', 'WebFetch', 'TodoWrite', 'WebSearch'],
+    warnings: ['Cannot write, edit, or create files - only designs']
+  },
+
+  'feature-dev:code-reviewer': {
+    canWrite: false,
+    canRead: true,
+    canBash: false,
+    canSearch: true,
+    canPlan: false,
+    canWebSearch: true,
+    bestFor: ['code review', 'finding bugs', 'security analysis'],
+    description: 'Code review - READ-ONLY',
+    tools: ['Glob', 'Grep', 'LS', 'Read', 'NotebookRead', 'WebFetch', 'TodoWrite', 'WebSearch'],
+    warnings: ['Cannot write, edit, or create files - only reviews']
+  },
+
+  // LIMITED AGENTS
+  'Bash': {
+    canWrite: false,  // Only through bash commands
+    canRead: false,
+    canBash: true,
+    canSearch: false,
+    canPlan: false,
+    canWebSearch: false,
+    bestFor: ['git operations', 'npm commands', 'shell scripts', 'CLI tools'],
+    description: 'Shell command specialist - Bash only',
+    tools: ['Bash'],
+    warnings: ['Only has Bash tool - no file tools']
+  }
+};
+
+// ============================================================================
+// TASK REQUIREMENT DETECTION - Analyze what the task needs
+// ============================================================================
+
+/**
+ * Patterns that indicate the task requires file writing
+ */
+const WRITE_PATTERNS = [
+  /\b(write|create|make|add|implement|build|generate)\b.*\b(file|code|function|class|component|module|test|documentation)/i,
+  /\b(fix|update|modify|change|edit|refactor|rename)\b/i,
+  /\b(save|store|output)\b.*\b(to|in)\b/i,
+  /\b(create|write|generate|add)\b.*\b(new|a)\b/i,
+  /\bimplementing\b/i,
+  /\badd\b.*\bto\b/i,
+  /\binsert\b/i,
+  /\bdelete\b.*\b(from|in)\b/i,
+  /\breplace\b/i,
+  /\bcommit\b/i,
+  /\bpush\b/i,
+];
+
+/**
+ * Patterns that indicate read-only exploration is sufficient
+ */
+const READ_PATTERNS = [
+  /\b(find|search|look for|locate)\b/i,
+  /\b(explain|understand|analyze|describe)\b/i,
+  /\b(what|where|how|why|which)\b.*\?/i,
+  /\b(trace|follow|track)\b.*\b(execution|flow|path)\b/i,
+  /\b(list|show|display)\b.*\b(files|functions|classes)\b/i,
+  /\b(review|check|examine|inspect)\b/i,
+  /\bexplore\b/i,
+];
+
+/**
+ * Patterns that indicate bash/CLI is needed
+ */
+const BASH_PATTERNS = [
+  /\b(run|execute|npm|yarn|pnpm|git|docker)\b/i,
+  /\b(install|build|test|deploy)\b\s+(the|this)?/i,
+  /\b(start|stop|restart)\b.*\b(server|service|process)\b/i,
+  /\b(command|terminal|shell|cli)\b/i,
+];
+
+/**
+ * Patterns indicating architecture/planning needs
+ */
+const PLAN_PATTERNS = [
+  /\b(design|architect|plan|strategy)\b/i,
+  /\b(blueprint|roadmap|specification)\b/i,
+  /\bhow (should|would|could) (we|i)\b/i,
+  /\b(approach|implementation plan)\b/i,
+];
+
+/**
+ * Analyze task prompt to determine requirements
+ */
+function analyzeTaskRequirements(prompt) {
+  const requirements = {
+    needsWrite: false,
+    needsRead: true,  // Almost always needed
+    needsBash: false,
+    needsSearch: false,
+    needsPlan: false,
+    confidence: 'low',
+    detectedPatterns: []
+  };
+
+  // Check for write requirements
+  for (const pattern of WRITE_PATTERNS) {
+    if (pattern.test(prompt)) {
+      requirements.needsWrite = true;
+      requirements.detectedPatterns.push(`write: ${pattern.toString()}`);
+    }
+  }
+
+  // Check for bash requirements
+  for (const pattern of BASH_PATTERNS) {
+    if (pattern.test(prompt)) {
+      requirements.needsBash = true;
+      requirements.detectedPatterns.push(`bash: ${pattern.toString()}`);
+    }
+  }
+
+  // Check for plan requirements
+  for (const pattern of PLAN_PATTERNS) {
+    if (pattern.test(prompt)) {
+      requirements.needsPlan = true;
+      requirements.detectedPatterns.push(`plan: ${pattern.toString()}`);
+    }
+  }
+
+  // Check for read-only patterns
+  let readOnlyMatches = 0;
+  for (const pattern of READ_PATTERNS) {
+    if (pattern.test(prompt)) {
+      readOnlyMatches++;
+      requirements.needsSearch = true;
+      requirements.detectedPatterns.push(`read: ${pattern.toString()}`);
+    }
+  }
+
+  // Determine confidence
+  if (requirements.detectedPatterns.length >= 3) {
+    requirements.confidence = 'high';
+  } else if (requirements.detectedPatterns.length >= 1) {
+    requirements.confidence = 'medium';
+  }
+
+  // Special case: if ONLY read patterns match and no write patterns
+  if (readOnlyMatches > 0 && !requirements.needsWrite && !requirements.needsBash) {
+    requirements.readOnlySufficient = true;
+  }
+
+  return requirements;
+}
+
+// ============================================================================
+// AGENT MATCHING LOGIC
+// ============================================================================
+
+/**
+ * Check if an agent type can fulfill task requirements
+ */
+function agentCanFulfill(agentType, requirements) {
+  const caps = AGENT_CAPABILITIES[agentType];
+  if (!caps) return { canFulfill: true, reason: 'Unknown agent - allowing by default' };
+
+  const issues = [];
+
+  if (requirements.needsWrite && !caps.canWrite) {
+    issues.push(`Cannot write files (task requires: write/edit/create)`);
+  }
+
+  if (requirements.needsBash && !caps.canBash) {
+    issues.push(`Cannot run bash commands (task requires: shell/git/npm)`);
+  }
+
+  return {
+    canFulfill: issues.length === 0,
+    issues,
+    agentCaps: caps
+  };
+}
+
+/**
+ * Find the best agent type for given requirements
+ */
+function findBestAgent(requirements) {
+  // If write is needed, use general-purpose or Plan
+  if (requirements.needsWrite) {
+    if (requirements.needsPlan) {
+      return { agent: 'Plan', reason: 'Task needs architecture planning AND file modifications' };
+    }
+    return { agent: 'general-purpose', reason: 'Task requires file modifications' };
+  }
+
+  // If only bash is needed
+  if (requirements.needsBash && !requirements.needsWrite && !requirements.needsSearch) {
+    return { agent: 'Bash', reason: 'Task only needs shell commands' };
+  }
+
+  // If planning is needed but no write
+  if (requirements.needsPlan && !requirements.needsWrite) {
+    return { agent: 'feature-dev:code-architect', reason: 'Architecture design (read-only)' };
+  }
+
+  // Read-only exploration
+  if (requirements.readOnlySufficient) {
+    return { agent: 'Explore', reason: 'Read-only exploration is sufficient' };
+  }
+
+  // Default to general-purpose for ambiguous cases
+  return { agent: 'general-purpose', reason: 'Default choice for complex/ambiguous tasks' };
+}
+
+// ============================================================================
+// HOOK HANDLER
+// ============================================================================
+
+async function main() {
+  let input = '';
+  process.stdin.setEncoding('utf8');
+  for await (const chunk of process.stdin) {
+    input += chunk;
+  }
+
+  try {
+    const data = JSON.parse(input);
+    const toolName = data.tool_name || '';
+    const toolInput = data.tool_input || {};
+
+    // Only process Task tool
+    if (toolName !== 'Task') {
+      process.exit(0);
+    }
+
+    const prompt = toolInput.prompt || '';
+    const description = toolInput.description || '';
+    const requestedType = toolInput.subagent_type || 'general-purpose';
+
+    // Skip if already has matcher marker
+    if (prompt.includes('[AGENT_TYPE_MATCHED]')) {
+      process.exit(0);
+    }
+
+    // Analyze requirements
+    const requirements = analyzeTaskRequirements(prompt + ' ' + description);
+
+    // Check if requested agent can fulfill
+    const fulfillment = agentCanFulfill(requestedType, requirements);
+
+    // Settings from env
+    const AUTO_MATCH = process.env.SPECMEM_AUTO_MATCH === '1';
+    const STRICT_MATCH = process.env.SPECMEM_STRICT_MATCH === '1';
+
+    if (!fulfillment.canFulfill) {
+      // Agent CAN'T fulfill the task!
+      const best = findBestAgent(requirements);
+
+      if (STRICT_MATCH) {
+        // Block and explain
+        console.log(JSON.stringify({
+          hookSpecificOutput: {
+            hookEventName: 'PreToolUse',
+            permissionDecision: 'deny',
+            permissionDecisionReason: `❌ AGENT MISMATCH: "${requestedType}" cannot fulfill task requirements!\n\nIssues:\n${fulfillment.issues.map(i => '  • ' + i).join('\n')}\n\nRecommended: "${best.agent}" (${best.reason})\n\nRe-deploy with correct agent type, or set SPECMEM_AUTO_MATCH=1 for auto-upgrade.`
+          }
+        }));
+        process.exit(0);
+      }
+
+      if (AUTO_MATCH) {
+        // Auto-upgrade to correct agent
+        const upgradedInput = {
+          ...toolInput,
+          subagent_type: best.agent,
+          prompt: `[AGENT_TYPE_MATCHED] Auto-upgraded from ${requestedType} to ${best.agent}: ${best.reason}\n\n${prompt}`
+        };
+
+        console.log(JSON.stringify({
+          hookSpecificOutput: {
+            hookEventName: 'PreToolUse',
+            permissionDecision: 'allow',
+            permissionDecisionReason: `⚡ AUTO-MATCH: Upgraded ${requestedType} → ${best.agent} (${best.reason})`,
+            updatedInput: upgradedInput
+          }
+        }));
+        process.exit(0);
+      }
+
+      // Default: Warn but allow (for backward compat)
+      const warningContext = `
+[AGENT-TYPE-WARNING]
+⚠️ POTENTIAL CAPABILITY MISMATCH DETECTED
+
+Requested Agent: ${requestedType}
+Issues:
+${fulfillment.issues.map(i => '  • ' + i).join('\n')}
+
+Recommended: ${best.agent} (${best.reason})
+
+The task MAY fail. Consider re-deploying with "${best.agent}" if issues occur.
+
+Set SPECMEM_AUTO_MATCH=1 for automatic agent upgrades.
+Set SPECMEM_STRICT_MATCH=1 to block mismatches.
+[/AGENT-TYPE-WARNING]
+`;
+
+      const warnedInput = {
+        ...toolInput,
+        prompt: prompt + warningContext
+      };
+
+      console.log(JSON.stringify({
+        hookSpecificOutput: {
+          hookEventName: 'PreToolUse',
+          permissionDecision: 'allow',
+          permissionDecisionReason: `⚠️ Capability mismatch: ${requestedType} may not handle this task. Recommended: ${best.agent}`,
+          updatedInput: warnedInput
+        }
+      }));
+      process.exit(0);
+    }
+
+    // Agent CAN fulfill - proceed normally
+    process.exit(0);
+
+  } catch (e) {
+    // LOW-44 FIX: Log errors before exit
+    console.error('[agent-type-matcher] Error:', e.message || e);
+    process.exit(0);
+  }
+}
+
+main().catch((e) => {
+  console.error('[agent-type-matcher] Unhandled error:', e.message || e);
+  process.exit(0);
+});

package/claude-hooks/auto-bypass.py

@@ -0,0 +1,74 @@
+#!/usr/bin/env python3
+"""
+Auto-bypass - ALWAYS sends Enter after a delay
+PreToolUse hooks fire BEFORE the permission prompt appears,
+so we need to send Enter AFTER the prompt renders.
+
+Works in standalone mode (no PM2 required)
+"""
+
+import os
+import sys
+import time
+import subprocess
+from datetime import datetime
+
+# Use project-scoped path for logging
+SPECMEM_HOME = os.environ.get('SPECMEM_HOME', os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+SPECMEM_RUN_DIR = os.environ.get('SPECMEM_RUN_DIR', os.path.join(SPECMEM_HOME, 'run'))
+LOG_FILE = os.path.join(SPECMEM_HOME, 'logs', 'auto-bypass.log')
+
+def log(msg):
+    try:
+        log_dir = os.path.dirname(LOG_FILE)
+        if not os.path.exists(log_dir):
+            os.makedirs(log_dir, exist_ok=True)
+        with open(LOG_FILE, 'a') as f:
+            f.write(f"[{datetime.now()}] {msg}\n")
+    except:
+        pass
+
+def send_enter():
+    """Send Enter key via multiple methods"""
+    os.environ['DISPLAY'] = ':1'
+
+    # Method 1: pynput
+    try:
+        from pynput.keyboard import Key, Controller
+        keyboard = Controller()
+        keyboard.press(Key.enter)
+        keyboard.release(Key.enter)
+        log("PYNPUT: Enter sent")
+    except Exception as e:
+        log(f"PYNPUT ERROR: {e}")
+
+    # Method 2: xdotool to all terminals
+    try:
+        result = subprocess.run(
+            ['xdotool', 'search', '--name', 'Terminal'],
+            capture_output=True, text=True, timeout=2
+        )
+        for win in result.stdout.strip().split('\n'):
+            if win:
+                subprocess.run(['xdotool', 'key', '--window', win, 'Return'],
+                             capture_output=True, timeout=1)
+        log("XDOTOOL: Enter sent to terminals")
+    except Exception as e:
+        log(f"XDOTOOL ERROR: {e}")
+
+def main():
+    log("HOOK FIRED - forking to background")
+
+    # Fork to background so hook returns immediately
+    pid = os.fork()
+    if pid > 0:
+        # Parent exits fast so  continues
+        sys.exit(0)
+
+    # Child waits for prompt to appear then sends Enter
+    time.sleep(0.5)  # Wait for permission prompt to render
+    send_enter()
+    log("AUTO-BYPASS COMPLETE")
+
+if __name__ == '__main__':
+    main()