@causyne/agent 1.10.13 → 1.10.18

package/src/commands.js

@@ -20,7 +20,10 @@ import {
 } from './userSkills.js';
 import { buildContextText, buildUsageText, buildCheckpointsText, buildUndoText, buildStatusText } from './reporting.js';
 import { loadConfig, saveConfig } from './config.js';
-import { serverStatus, grantServer, revokeServer, addServer, removeServer } from './mcp/mcpRegistry.js';
+import {
+  serverStatus, grantServer, revokeServer, addServer, removeServer,
+  connectServer, disconnectServer, refreshServer
+} from './mcp/mcpRegistry.js';
 import { analyzeFiles, formatFindings } from './slopDetector.js';
 import { suggestMovements, formatMovementBrief, DESIGN_MOVEMENTS } from './designPalettes.js';
 import fs from 'fs';
@@ -657,10 +660,10 @@ export const COMMANDS = [
   {
     name: 'mcp',
     scope: 'local',
-    usage: '/mcp [add <name> <cmd…> | add <name> --url <url> | remove|grant|revoke <name>]',
-    description: 'Manage MCP servers: list, add, remove, grant, revoke',
+    usage: '/mcp [add <name> <cmd…> | add <name> --url <url> | remove|grant|revoke|connect|disconnect|test|refresh <name>]',
+    description: 'Manage and diagnose MCP server connections',
     dialogTitle: 'MCP servers',
-    run: (argv) => {
+    run: async (argv) => {
       const [action, serverName, ...rest] = argv;
 
       if (action === 'add') {
@@ -702,15 +705,40 @@ export const COMMANDS = [
         const known = serverStatus().some(s => s.name === serverName);
         if (!known) return fail(`No MCP server named "${serverName}" is configured.`);
         if (action === 'grant') {
-          grantServer(serverName);
+          const granted = grantServer(serverName);
+          if (!granted.ok) return fail(granted.error);
           return ok(`Granted "${serverName}". Its tools enter the catalogue on the next task.`);
         }
         revokeServer(serverName);
         return ok(`Revoked "${serverName}". Its tools are no longer callable.`);
       }
 
+      if (['connect', 'test', 'refresh', 'disconnect'].includes(action)) {
+        if (!serverName) return fail(`Usage: /mcp ${action} <server>`);
+        const known = serverStatus().some(server => server.name === serverName);
+        if (!known) return fail(`No MCP server named "${serverName}" is configured.`);
+
+        if (action === 'disconnect') {
+          await disconnectServer(serverName);
+          return ok(`Disconnected "${serverName}". Its grant remains in place.`);
+        }
+
+        if (action === 'refresh') {
+          const tools = await refreshServer(serverName);
+          return ok(`Refreshed "${serverName}": ${tools.length} tool(s) available${tools.length ? ` — ${tools.map(tool => tool.name).join(', ')}` : ''}.`);
+        }
+
+        const client = await connectServer(serverName);
+        return ok(
+          `${action === 'test' ? 'MCP test passed' : 'Connected'}: "${serverName}"\n`
+          + `Transport: ${client.status.transport || 'unknown'}\n`
+          + `Server: ${client.serverInfo ? `${client.serverInfo.name} ${client.serverInfo.version}` : 'identity not provided'}\n`
+          + `Tools: ${client.tools.length}${client.tools.length ? ` — ${client.tools.map(tool => tool.name).join(', ')}` : ''}`
+        );
+      }
+
       if (action) {
-        return fail(`Unknown mcp action "${action}". Try: add, remove, grant, revoke, or mcp on its own to list.`);
+        return fail(`Unknown mcp action "${action}". Try: add, remove, grant, revoke, connect, disconnect, test, refresh, or mcp on its own to list.`);
       }
 
       const servers = serverStatus();
@@ -719,12 +747,13 @@ export const COMMANDS = [
       }
       const lines = ['MCP servers', ''];
       for (const server of servers) {
-        lines.push(`  ${server.name}  [${server.transport}]  ${server.granted ? 'granted' : 'NOT granted'}${server.connected ? ', connected' : ''}`);
+        lines.push(`  ${server.name}  [${server.transport}]  ${server.granted ? 'granted' : 'NOT granted'}  ${server.status}`);
         lines.push(`    ${server.target}`);
         if (server.tools.length > 0) lines.push(`    tools: ${server.tools.join(', ')}`);
+        if (server.error) lines.push(`    error: ${server.error}`);
       }
       lines.push('');
-      lines.push('  mcp grant <name> to enable, mcp remove <name> to delete.');
+      lines.push('  mcp grant <name> to enable, mcp test <name> to diagnose, mcp remove <name> to delete.');
       return ok(lines.join('\n'), { effect: 'pick-mcp' });
     }
   },

package/src/config.d.ts

@@ -0,0 +1,2 @@
+export function loadConfig(): Record<string, unknown>;
+export function saveConfig(config: Record<string, unknown>): void;

package/src/decisionPolicy.js

@@ -0,0 +1,68 @@
+const ARCHITECTURE_TERMS = [
+    'architecture', 'arsitektur',
+    'framework', 'runtime', 'database', 'storage', 'authentication', 'authorization',
+    'deployment', 'hosting', 'protocol', 'plugin system', 'sandbox', 'license',
+    'typescript', 'javascript', 'python', 'rust', 'kotlin', 'swift'
+];
+const CHANGE_TERMS = [
+    'change', 'replace', 'switch', 'choose', 'decide', 'redesign', 'restructure',
+    'rewrite', 'rebuild', 'migration', 'migrate',
+    'ubah', 'ganti', 'pilih', 'tentukan', 'rombak', 'beralih', 'migrasi'
+];
+const EXPLICIT_CHOICE_PATTERNS = [
+    /\b(?:i|we)\s+(?:choose|chose|selected?|decided? (?:on|to use))\s+[a-z0-9@._+-]+/i,
+    /\b(?:must use|will use|switch to|rewrite (?:to|in)|migrate to)\s+[a-z0-9@._+-]+/i,
+    /\b(?:saya pilih|aku pilih|kita pilih|harus memakai|beralih ke|ubah ke|ganti ke)\s+[a-z0-9@._+-]+/i,
+    /^(?:please\s+)?(?:use|choose|gunakan|pilih)\s+[a-z0-9@._+-]+/i,
+    /\b(?:do not|don't|jangan)\s+(?:use|gunakan|pakai)\s+[a-z0-9@._+-]+/i
+];
+const MUTATING_TOOLS = new Set([
+    'fs_write', 'fs_edit', 'MultiEdit', 'fs_delete', 'fs_move', 'sysRun', 'sysRunBg',
+    'gitOp', 'manage_local_dependencies', 'plugin_manage', 'tool_forge', 'create_skill'
+]);
+function containsAny(text, terms) {
+    return terms.some(term => text.includes(term));
+}
+export function assessDecisionRequirement(prompt) {
+    const raw = String(prompt ?? '').trim();
+    const text = raw.toLowerCase();
+    const architectural = containsAny(text, ARCHITECTURE_TERMS);
+    const change = containsAny(text, CHANGE_TERMS);
+    const alternatives = /\b(?:or|versus|vs\.?|atau|dibanding(?:kan)? dengan)\b/i.test(raw);
+    const asksForChoice = /\b(?:which|what should|should we|mana|apakah sebaiknya|bagaimana sebaiknya)\b/i.test(raw);
+    const delegatesBroadRedesign = /\b(?:redesign|restructure|rombak)\s+(?:the\s+)?(?:architecture|system|runtime|database|arsitektur|sistem)\b/i.test(raw);
+    const explicit = EXPLICIT_CHOICE_PATTERNS.some(pattern => pattern.test(raw));
+    if (!architectural || explicit || (!alternatives && !asksForChoice && !(change && delegatesBroadRedesign))) {
+        return { required: false, kind: 'architecture', reason: '' };
+    }
+    return {
+        required: true,
+        kind: 'architecture',
+        reason: 'The request reaches a durable architecture boundary with more than one plausible implementation.'
+    };
+}
+export function requiresImplementationPlan(prompt, archetype = '', confidence = '') {
+    const text = String(prompt ?? '').toLowerCase();
+    if (archetype === 'build_app' || archetype === 'integrate')
+        return true;
+    if (confidence === 'high' && /\b(?:implement|build|create|migrate|rewrite|refactor|integrate|buat|bangun|ubah)\b/i.test(text)) {
+        return true;
+    }
+    return containsAny(text, ARCHITECTURE_TERMS) && containsAny(text, CHANGE_TERMS);
+}
+export function isMutatingToolCall(toolName, args = {}) {
+    if (MUTATING_TOOLS.has(toolName)) {
+        if (toolName === 'sysRun' || toolName === 'sysRunBg') {
+            const command = String(args.command ?? '');
+            return !/^\s*(?:pwd|ls|find|rg|grep|cat|sed|head|tail|git\s+(?:status|diff|log|show)|npm\s+(?:view|audit|test)|node\s+--check)\b/i.test(command);
+        }
+        if (toolName === 'gitOp') {
+            const action = String(args.action ?? args.command ?? args.operation ?? '');
+            return !/^(?:status|diff|log|show|branch|remote)$/i.test(action.trim());
+        }
+        return true;
+    }
+    if (toolName.startsWith('plugin__') || toolName.startsWith('mcp__'))
+        return false;
+    return false;
+}

package/src/decisionPolicy.ts

@@ -0,0 +1,106 @@
+export type DecisionKind = 'architecture' | 'product' | 'data' | 'security' | 'workflow' | 'other';
+
+export interface DecisionOption {
+  id: string;
+  label: string;
+  description: string;
+}
+
+export interface DecisionRequest {
+  id: string;
+  kind: DecisionKind;
+  header: string;
+  question: string;
+  reason: string;
+  options: DecisionOption[];
+  allowCustom: boolean;
+}
+
+export interface DecisionAnswer {
+  requestId: string;
+  optionId: string | null;
+  label: string;
+  custom: boolean;
+}
+
+export interface DecisionRequirement {
+  required: boolean;
+  kind: DecisionKind;
+  reason: string;
+}
+
+const ARCHITECTURE_TERMS = [
+  'architecture', 'arsitektur',
+  'framework', 'runtime', 'database', 'storage', 'authentication', 'authorization',
+  'deployment', 'hosting', 'protocol', 'plugin system', 'sandbox', 'license',
+  'typescript', 'javascript', 'python', 'rust', 'kotlin', 'swift'
+];
+
+const CHANGE_TERMS = [
+  'change', 'replace', 'switch', 'choose', 'decide', 'redesign', 'restructure',
+  'rewrite', 'rebuild', 'migration', 'migrate',
+  'ubah', 'ganti', 'pilih', 'tentukan', 'rombak', 'beralih', 'migrasi'
+];
+
+const EXPLICIT_CHOICE_PATTERNS = [
+  /\b(?:i|we)\s+(?:choose|chose|selected?|decided? (?:on|to use))\s+[a-z0-9@._+-]+/i,
+  /\b(?:must use|will use|switch to|rewrite (?:to|in)|migrate to)\s+[a-z0-9@._+-]+/i,
+  /\b(?:saya pilih|aku pilih|kita pilih|harus memakai|beralih ke|ubah ke|ganti ke)\s+[a-z0-9@._+-]+/i,
+  /^(?:please\s+)?(?:use|choose|gunakan|pilih)\s+[a-z0-9@._+-]+/i,
+  /\b(?:do not|don't|jangan)\s+(?:use|gunakan|pakai)\s+[a-z0-9@._+-]+/i
+];
+
+const MUTATING_TOOLS = new Set([
+  'fs_write', 'fs_edit', 'MultiEdit', 'fs_delete', 'fs_move', 'sysRun', 'sysRunBg',
+  'gitOp', 'manage_local_dependencies', 'plugin_manage', 'tool_forge', 'create_skill'
+]);
+
+function containsAny(text: string, terms: readonly string[]): boolean {
+  return terms.some(term => text.includes(term));
+}
+
+export function assessDecisionRequirement(prompt: string): DecisionRequirement {
+  const raw = String(prompt ?? '').trim();
+  const text = raw.toLowerCase();
+  const architectural = containsAny(text, ARCHITECTURE_TERMS);
+  const change = containsAny(text, CHANGE_TERMS);
+  const alternatives = /\b(?:or|versus|vs\.?|atau|dibanding(?:kan)? dengan)\b/i.test(raw);
+  const asksForChoice = /\b(?:which|what should|should we|mana|apakah sebaiknya|bagaimana sebaiknya)\b/i.test(raw);
+  const delegatesBroadRedesign = /\b(?:redesign|restructure|rombak)\s+(?:the\s+)?(?:architecture|system|runtime|database|arsitektur|sistem)\b/i.test(raw);
+  const explicit = EXPLICIT_CHOICE_PATTERNS.some(pattern => pattern.test(raw));
+
+  if (!architectural || explicit || (!alternatives && !asksForChoice && !(change && delegatesBroadRedesign))) {
+    return { required: false, kind: 'architecture', reason: '' };
+  }
+
+  return {
+    required: true,
+    kind: 'architecture',
+    reason: 'The request reaches a durable architecture boundary with more than one plausible implementation.'
+  };
+}
+
+export function requiresImplementationPlan(prompt: string, archetype = '', confidence = ''): boolean {
+  const text = String(prompt ?? '').toLowerCase();
+  if (archetype === 'build_app' || archetype === 'integrate') return true;
+  if (confidence === 'high' && /\b(?:implement|build|create|migrate|rewrite|refactor|integrate|buat|bangun|ubah)\b/i.test(text)) {
+    return true;
+  }
+  return containsAny(text, ARCHITECTURE_TERMS) && containsAny(text, CHANGE_TERMS);
+}
+
+export function isMutatingToolCall(toolName: string, args: Record<string, unknown> = {}): boolean {
+  if (MUTATING_TOOLS.has(toolName)) {
+    if (toolName === 'sysRun' || toolName === 'sysRunBg') {
+      const command = String(args.command ?? '');
+      return !/^\s*(?:pwd|ls|find|rg|grep|cat|sed|head|tail|git\s+(?:status|diff|log|show)|npm\s+(?:view|audit|test)|node\s+--check)\b/i.test(command);
+    }
+    if (toolName === 'gitOp') {
+      const action = String(args.action ?? args.command ?? args.operation ?? '');
+      return !/^(?:status|diff|log|show|branch|remote)$/i.test(action.trim());
+    }
+    return true;
+  }
+  if (toolName.startsWith('plugin__') || toolName.startsWith('mcp__')) return false;
+  return false;
+}

package/src/hooks.js

@@ -1,95 +1,108 @@
 import { spawn } from 'node:child_process';
 import path from 'node:path';
-
 const MAX_HOOKS_PER_EVENT = 32;
 const MAX_OUTPUT_BYTES = 32 * 1024;
 const DEFAULT_TIMEOUT_MS = 5_000;
-
 function safeObject(value) {
-  return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+    return value !== null && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : {};
 }
-
 function matchesTool(rule, toolName) {
-  const tools = Array.isArray(rule.tools)
-    ? rule.tools
-    : [rule.tool == null ? '*' : rule.tool];
-  return tools.some((candidate) => candidate === '*' || candidate === toolName);
+    const tools = Array.isArray(rule.tools)
+        ? rule.tools
+        : [rule.tool == null ? '*' : rule.tool];
+    return tools.some((candidate) => candidate === '*' || candidate === toolName);
 }
-
 function normalizeRule(rule, event, toolName) {
-  if (!rule || rule.enabled === false || rule.event !== event || !matchesTool(rule, toolName)) return null;
-  if (!Array.isArray(rule.command) || rule.command.length === 0) return null;
-  const command = rule.command.map((part) => String(part));
-  if (!command[0] || command.length > 64 || command.some((part) => part.length > 4096)) return null;
-  return {
-    name: String(rule.name || `${event}:${toolName}`).slice(0, 128),
-    command,
-    timeoutMs: Number.isInteger(rule.timeoutMs)
-      ? Math.max(100, Math.min(rule.timeoutMs, 10_000))
-      : DEFAULT_TIMEOUT_MS
-  };
+    if (rule === null || typeof rule !== 'object' || Array.isArray(rule))
+        return null;
+    const candidate = rule;
+    if (candidate.enabled === false || candidate.event !== event || !matchesTool(candidate, toolName))
+        return null;
+    if (!Array.isArray(candidate.command) || candidate.command.length === 0)
+        return null;
+    const command = candidate.command.map((part) => String(part));
+    const executable = command[0];
+    if (!executable || command.length > 64 || command.some((part) => part.length > 4096))
+        return null;
+    return {
+        name: String(candidate.name || `${event}:${toolName}`).slice(0, 128),
+        command: [executable, ...command.slice(1)],
+        timeoutMs: Number.isInteger(candidate.timeoutMs)
+            ? Math.max(100, Math.min(candidate.timeoutMs, 10_000))
+            : DEFAULT_TIMEOUT_MS
+    };
 }
-
 export function hasMatchingHook(hooks, event, toolName) {
-  return (Array.isArray(hooks) ? hooks : [])
-    .some((rule) => normalizeRule(rule, event, toolName) !== null);
+    return (Array.isArray(hooks) ? hooks : [])
+        .some((rule) => normalizeRule(rule, event, toolName) !== null);
 }
-
 function runOneHook(rule, payload, cwd) {
-  return new Promise((resolve) => {
-    const child = spawn(rule.command[0], rule.command.slice(1), {
-      cwd,
-      shell: false,
-      stdio: ['pipe', 'pipe', 'pipe'],
-      env: {
-        PATH: process.env.PATH || '',
-        LANG: process.env.LANG || 'C.UTF-8',
-        TMPDIR: process.env.TMPDIR || ''
-      }
+    return new Promise((resolve) => {
+        const child = spawn(rule.command[0], rule.command.slice(1), {
+            cwd,
+            shell: false,
+            stdio: ['pipe', 'pipe', 'pipe'],
+            env: {
+                PATH: process.env.PATH || '',
+                LANG: process.env.LANG || 'C.UTF-8',
+                TMPDIR: process.env.TMPDIR || ''
+            }
+        });
+        let stdout = '';
+        let stderr = '';
+        let settled = false;
+        const finish = (value) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            resolve(value);
+        };
+        const timer = setTimeout(() => {
+            child.kill('SIGTERM');
+            finish({ exitCode: null, timedOut: true, stdout, stderr });
+        }, rule.timeoutMs);
+        timer.unref();
+        const collect = (target, chunk) => {
+            const next = target + chunk.toString();
+            if (Buffer.byteLength(next, 'utf8') > MAX_OUTPUT_BYTES) {
+                child.kill('SIGTERM');
+                finish({ exitCode: null, overflow: true, stdout, stderr });
+                return target;
+            }
+            return next;
+        };
+        child.stdout.on('data', (chunk) => { stdout = collect(stdout, chunk); });
+        child.stderr.on('data', (chunk) => { stderr = collect(stderr, chunk); });
+        child.on('error', (error) => finish({ exitCode: null, spawnError: error.message, stdout, stderr }));
+        child.on('close', (code) => finish({ exitCode: code, stdout, stderr }));
+        child.stdin.end(JSON.stringify(payload));
     });
-    let stdout = '';
-    let stderr = '';
-    let settled = false;
-
-    const finish = (value) => {
-      if (settled) return;
-      settled = true;
-      clearTimeout(timer);
-      resolve(value);
-    };
-    const timer = setTimeout(() => {
-      child.kill('SIGTERM');
-      finish({ exitCode: null, timedOut: true, stdout, stderr });
-    }, rule.timeoutMs);
-    if (timer.unref) timer.unref();
-
-    const collect = (target, chunk) => {
-      const next = target + chunk;
-      if (Buffer.byteLength(next, 'utf8') > MAX_OUTPUT_BYTES) {
-        child.kill('SIGTERM');
-        finish({ exitCode: null, overflow: true, stdout, stderr });
-        return target;
-      }
-      return next;
-    };
-    child.stdout.on('data', (chunk) => { stdout = collect(stdout, chunk); });
-    child.stderr.on('data', (chunk) => { stderr = collect(stderr, chunk); });
-    child.on('error', (error) => finish({ exitCode: null, spawnError: error.message, stdout, stderr }));
-    child.on('close', (code) => finish({ exitCode: code, stdout, stderr }));
-    child.stdin.end(JSON.stringify(payload));
-  });
 }
-
 function feedbackFor(rule, result) {
-  const output = [result.stdout, result.stderr].filter(Boolean).join('\n').trim();
-  if (output) return `${rule.name}: ${output}`.slice(0, MAX_OUTPUT_BYTES);
-  if (result.timedOut) return `${rule.name}: timed out after ${rule.timeoutMs} ms`;
-  if (result.overflow) return `${rule.name}: output exceeded ${MAX_OUTPUT_BYTES} bytes`;
-  if (result.spawnError) return `${rule.name}: ${result.spawnError}`;
-  if (result.exitCode !== 0) return `${rule.name}: exited with code ${result.exitCode}`;
-  return '';
+    const output = [result.stdout, result.stderr].filter(Boolean).join('\n').trim();
+    if (output)
+        return `${rule.name}: ${output}`.slice(0, MAX_OUTPUT_BYTES);
+    if (result.timedOut)
+        return `${rule.name}: timed out after ${rule.timeoutMs} ms`;
+    if (result.overflow)
+        return `${rule.name}: output exceeded ${MAX_OUTPUT_BYTES} bytes`;
+    if (result.spawnError)
+        return `${rule.name}: ${result.spawnError}`;
+    if (result.exitCode !== 0)
+        return `${rule.name}: exited with code ${result.exitCode}`;
+    return '';
+}
+function resolveWorkspaceRoots(workspacePaths) {
+    if (!Array.isArray(workspacePaths))
+        return [process.cwd()];
+    const roots = workspacePaths
+        .filter((value) => typeof value === 'string' && value.length > 0)
+        .map((value) => path.resolve(value));
+    return roots.length > 0 ? roots : [process.cwd()];
 }
-
 /**
  * Run user-owned lifecycle hooks from ~/.causyne/config.json.
  *
@@ -98,39 +111,40 @@ function feedbackFor(rule, result) {
  * during startup before the user has trusted the workspace.
  */
 export async function runConfiguredHooks({ hooks, event, toolName, args, result, taskId, toolCallId, workspacePaths }) {
-  const source = Array.isArray(hooks) ? hooks : [];
-  const rules = source
-    .map((rule) => normalizeRule(rule, event, toolName))
-    .filter(Boolean)
-    .slice(0, MAX_HOOKS_PER_EVENT);
-  if (rules.length === 0) return { denied: false, messages: [] };
-
-  const roots = Array.isArray(workspacePaths) && workspacePaths.length > 0
-    ? workspacePaths.map((value) => path.resolve(value))
-    : [process.cwd()];
-  const payload = {
-    event,
-    tool: toolName,
-    args: safeObject(args),
-    result: result && typeof result === 'object' ? result : undefined,
-    taskId: String(taskId || ''),
-    toolCallId: String(toolCallId || ''),
-    workspacePaths: roots
-  };
-  const messages = [];
-
-  for (const rule of rules) {
-    const hookResult = await runOneHook(rule, payload, roots[0]);
-    const feedback = feedbackFor(rule, hookResult);
-    if (feedback) messages.push(feedback);
-
-    if (hookResult.exitCode === 2) return { denied: true, messages, reason: feedback };
-    if (event === 'PreToolUse' && hookResult.exitCode !== 0) {
-      return { denied: true, messages, reason: feedback || `${rule.name} failed closed` };
+    const source = Array.isArray(hooks) ? hooks : [];
+    const rules = source
+        .map((rule) => normalizeRule(rule, event, toolName))
+        .filter((rule) => rule !== null)
+        .slice(0, MAX_HOOKS_PER_EVENT);
+    if (rules.length === 0)
+        return { denied: false, messages: [] };
+    const roots = resolveWorkspaceRoots(workspacePaths);
+    const primaryRoot = roots[0] ?? process.cwd();
+    const payload = {
+        event,
+        tool: toolName,
+        args: safeObject(args),
+        taskId: String(taskId || ''),
+        toolCallId: String(toolCallId || ''),
+        workspacePaths: roots
+    };
+    if (result !== null && typeof result === 'object')
+        payload.result = result;
+    const messages = [];
+    for (const rule of rules) {
+        const hookResult = await runOneHook(rule, payload, primaryRoot);
+        const feedback = feedbackFor(rule, hookResult);
+        if (feedback)
+            messages.push(feedback);
+        if (hookResult.exitCode === 2) {
+            return feedback
+                ? { denied: true, messages, reason: feedback }
+                : { denied: true, messages };
+        }
+        if (event === 'PreToolUse' && hookResult.exitCode !== 0) {
+            return { denied: true, messages, reason: feedback || `${rule.name} failed closed` };
+        }
     }
-  }
-
-  return { denied: false, messages };
+    return { denied: false, messages };
 }
-
 export { MAX_HOOKS_PER_EVENT, MAX_OUTPUT_BYTES, DEFAULT_TIMEOUT_MS };