@dollhousemcp/mcp-server 2.0.17 → 2.0.18

package/dist/web/public/setup.js

@@ -18,13 +18,13 @@
   const PLATFORMS = [
     // Claude Desktop & Claude Code panels are handwritten in HTML (unique structure)
     { id: 'claude-desktop', rootKey: 'mcpServers' },
-    { id: 'claude-code',    rootKey: 'mcpServers', cli: 'claude', hookSupport: 'verified', hookCommand: `bash ${HOOK_BASE_SCRIPT_PATH}`, hookConfigPath: '<code>~/.claude/settings.json</code>' },
+    { id: 'claude-code',    rootKey: 'mcpServers', cli: 'claude', hookCommand: `bash ${HOOK_BASE_SCRIPT_PATH}`, hookConfigPath: '<code>~/.claude/settings.json</code>' },
     // These panels are generated from this data by renderGeneratedPanels()
-    { id: 'cursor',    rootKey: 'mcpServers', installClient: 'cursor',     openClient: 'cursor',     configPath: '<code>.cursor/mcp.json</code> in your project, or <code>~/.cursor/mcp.json</code> for all projects', hint: 'Or configure via Settings &gt; MCP Servers in the Cursor UI.', hookSupport: 'partial', hookCommand: `bash ${HOOKS_DIR}/pretooluse-cursor.sh`, hookConfigPath: '<code>.cursor/hooks.json</code> in your project, or <code>~/.cursor/hooks.json</code> for all projects' },
-    { id: 'vscode',    rootKey: 'servers',    installClient: 'vscode',     configPath: '<code>.vscode/mcp.json</code> in your workspace', hint: 'VS Code uses <code>"servers"</code>, not <code>"mcpServers"</code>.', hookSupport: 'partial', hookCommand: `bash ${HOOKS_DIR}/pretooluse-vscode.sh`, hookConfigPath: '<code>~/.copilot/hooks/dollhouse-permissions.json</code> plus <code>chat.hookFilesLocations</code> in VS Code user settings' },
-    { id: 'codex',     rootKey: 'mcpServers', installClient: 'codex',      openClient: 'codex',      cli: 'codex', toml: true, tomlPath: '<code>~/.codex/config.toml</code> (Codex uses TOML, not JSON)', hookSupport: 'partial', hookCommand: `bash ${HOOKS_DIR}/pretooluse-codex.sh`, hookConfigPath: '<code>~/.codex/hooks.json</code> and <code>~/.codex/config.toml</code>' },
-    { id: 'gemini',    rootKey: 'mcpServers', installClient: 'gemini-cli', openClient: 'gemini-cli', cli: 'gemini', configPath: '<code>~/.gemini/settings.json</code> or <code>.gemini/settings.json</code> in your project', hookSupport: 'partial', hookCommand: `bash ${HOOKS_DIR}/pretooluse-gemini.sh`, hookConfigPath: '<code>~/.gemini/settings.json</code> or <code>.gemini/settings.json</code> in your project' },
-    { id: 'windsurf',  rootKey: 'mcpServers', installClient: 'windsurf',   openClient: 'windsurf',   configPath: '<code>~/.codeium/windsurf/mcp_config.json</code>', hint: 'Or click the MCPs icon in the Cascade panel &gt; Configure.', hookSupport: 'partial', hookCommand: `bash ${HOOKS_DIR}/pretooluse-windsurf.sh`, hookConfigPath: '<code>~/.codeium/windsurf/hooks.json</code> or <code>.windsurf/hooks.json</code> in your project' },
+    { id: 'cursor',    rootKey: 'mcpServers', installClient: 'cursor',     openClient: 'cursor',     configPath: '<code>.cursor/mcp.json</code> in your project, or <code>~/.cursor/mcp.json</code> for all projects', hint: 'Or configure via Settings &gt; MCP Servers in the Cursor UI.', hookCommand: `bash ${HOOKS_DIR}/pretooluse-cursor.sh`, hookConfigPath: '<code>.cursor/hooks.json</code> in your project, or <code>~/.cursor/hooks.json</code> for all projects' },
+    { id: 'vscode',    rootKey: 'servers',    installClient: 'vscode',     configPath: '<code>.vscode/mcp.json</code> in your workspace', hint: 'VS Code uses <code>"servers"</code>, not <code>"mcpServers"</code>.', hookCommand: `bash ${HOOKS_DIR}/pretooluse-vscode.sh`, hookConfigPath: '<code>~/.copilot/hooks/dollhouse-permissions.json</code> plus <code>chat.hookFilesLocations</code> in VS Code user settings' },
+    { id: 'codex',     rootKey: 'mcpServers', installClient: 'codex',      openClient: 'codex',      cli: 'codex', toml: true, tomlPath: '<code>~/.codex/config.toml</code> (Codex uses TOML, not JSON)', hookCommand: `bash ${HOOKS_DIR}/pretooluse-codex.sh`, hookConfigPath: '<code>~/.codex/hooks.json</code> and <code>~/.codex/config.toml</code>' },
+    { id: 'gemini',    rootKey: 'mcpServers', installClient: 'gemini-cli', openClient: 'gemini-cli', cli: 'gemini', configPath: '<code>~/.gemini/settings.json</code> or <code>.gemini/settings.json</code> in your project', hookCommand: `bash ${HOOKS_DIR}/pretooluse-gemini.sh`, hookConfigPath: '<code>~/.gemini/settings.json</code> or <code>.gemini/settings.json</code> in your project' },
+    { id: 'windsurf',  rootKey: 'mcpServers', installClient: 'windsurf',   openClient: 'windsurf',   configPath: '<code>~/.codeium/windsurf/mcp_config.json</code>', hint: 'Or click the MCPs icon in the Cascade panel &gt; Configure.', hookCommand: `bash ${HOOKS_DIR}/pretooluse-windsurf.sh`, hookConfigPath: '<code>~/.codeium/windsurf/hooks.json</code> or <code>.windsurf/hooks.json</code> in your project' },
     { id: 'cline',     rootKey: 'mcpServers', installClient: 'cline',      openClient: 'cline',      configPath: 'Cline stores MCP servers in <code>cline_mcp_settings.json</code> inside its extension settings. Use Configure Now or open the file directly.' },
     { id: 'lmstudio',  rootKey: 'mcpServers', installClient: 'lmstudio',   openClient: 'lmstudio',   configPath: '<code>~/.lmstudio/mcp.json</code> (or open via Program tab &gt; Install &gt; Edit mcp.json)', hint: 'Restart LM Studio after saving.' },
   ];
@@ -888,6 +888,7 @@ codex_hooks = true`;
     'claude': 'claude-desktop',
     'claude-code': 'claude-code',
     'cursor': 'cursor',
+    'cline': 'cline',
     'windsurf': 'windsurf',
     'lmstudio': 'lmstudio',
     'gemini-cli': 'gemini',
@@ -965,32 +966,29 @@ codex_hooks = true`;
     }
   };
 
-  const PERMISSION_PLATFORM_LABELS = {
-    'claude-desktop': 'Claude Desktop',
-    'claude-code': 'Claude Code',
-    cursor: 'Cursor',
-    vscode: 'VS Code',
-    codex: 'Codex',
-    gemini: 'Gemini CLI',
-    windsurf: 'Windsurf',
-    cline: 'Cline',
-    lmstudio: 'LM Studio',
-  };
-
-  const VERIFIED_PERMISSION_PLATFORMS = {
+  const PERMISSION_SUPPORT_MATRIX = {
+    'claude-desktop': {
+      label: 'Claude Desktop',
+      supportLevel: 'unsupported',
+      statusTag: 'coming soon',
+      badgeClass: 'unsupported',
+      limitation: 'Claude Desktop can host DollhouseMCP, but this release does not ship a native permissions setup flow for it yet.',
+    },
     'claude-code': {
       label: 'Claude Code',
+      supportLevel: 'full_native',
       statusTag: 'claude code',
+      badgeClass: 'verified',
       configPath: '<code>~/.claude/settings.json</code>',
       scriptPath: HOOK_BASE_SCRIPT_PATH,
       settingsBlock: CLAUDE_CODE_HOOK_SETTINGS,
+      limitation: 'Claude Code has the full native permission-hook path in this release.',
     },
-  };
-
-  const PARTIAL_PERMISSION_PLATFORMS = {
     gemini: {
       label: 'Gemini CLI',
+      supportLevel: 'partial_native',
       statusTag: 'allow / deny',
+      badgeClass: 'manual',
       configPath: '<code>~/.gemini/settings.json</code> or <code>.gemini/settings.json</code> in your project',
       scriptPath: `${HOOKS_DIR}/pretooluse-gemini.sh`,
       settingsBlock: GEMINI_HOOK_SETTINGS,
@@ -998,7 +996,9 @@ codex_hooks = true`;
     },
     cursor: {
       label: 'Cursor',
+      supportLevel: 'partial_native',
       statusTag: 'native hooks',
+      badgeClass: 'manual',
       configPath: '<code>.cursor/hooks.json</code> in your project, or <code>~/.cursor/hooks.json</code> for all projects',
       scriptPath: `${HOOKS_DIR}/pretooluse-cursor.sh`,
       settingsBlock: CURSOR_HOOK_SETTINGS,
@@ -1006,7 +1006,9 @@ codex_hooks = true`;
     },
     vscode: {
       label: 'VS Code',
+      supportLevel: 'partial_native',
       statusTag: 'native hooks',
+      badgeClass: 'manual',
       configPath: '<code>~/.copilot/hooks/dollhouse-permissions.json</code> and VS Code user settings',
       scriptPath: `${HOOKS_DIR}/pretooluse-vscode.sh`,
       settingsBlock: VSCODE_HOOK_SETTINGS,
@@ -1017,7 +1019,9 @@ codex_hooks = true`;
     },
     windsurf: {
       label: 'Windsurf',
+      supportLevel: 'partial_native',
       statusTag: 'allow / deny',
+      badgeClass: 'manual',
       configPath: '<code>~/.codeium/windsurf/hooks.json</code> or <code>.windsurf/hooks.json</code> in your project',
       scriptPath: `${HOOKS_DIR}/pretooluse-windsurf.sh`,
       settingsBlock: WINDSURF_HOOK_SETTINGS,
@@ -1025,20 +1029,46 @@ codex_hooks = true`;
     },
     codex: {
       label: 'Codex',
+      supportLevel: 'partial_native',
       statusTag: 'bash only',
+      badgeClass: 'manual',
       configPath: '<code>~/.codex/hooks.json</code> and <code>~/.codex/config.toml</code>',
       scriptPath: `${HOOKS_DIR}/pretooluse-codex.sh`,
       settingsBlock: CODEX_HOOK_SETTINGS,
       featureBlock: CODEX_HOOK_FEATURES_TOML,
       limitation: 'Codex currently only supports native PreToolUse hooks for Bash, so this turns on Bash permission guardrails only.',
     },
+    cline: {
+      label: 'Cline',
+      supportLevel: 'mcp_only',
+      statusTag: 'mcp only',
+      badgeClass: 'manual',
+      limitation: 'Cline MCP setup is supported here, but native permission-hook automation is still incomplete in this release.',
+    },
+    lmstudio: {
+      label: 'LM Studio',
+      supportLevel: 'mcp_only',
+      statusTag: 'mcp only',
+      badgeClass: 'manual',
+      limitation: 'LM Studio MCP setup is supported here, but permission enforcement currently relies on LM Studio built-in confirmations or a future fallback adapter.',
+    },
+  };
+
+  const getPermissionSupport = (platformId, detected) => {
+    if (detected?.support) {
+      return {
+        ...PERMISSION_SUPPORT_MATRIX[platformId],
+        supportLevel: detected.support.level || PERMISSION_SUPPORT_MATRIX[platformId]?.supportLevel,
+      };
+    }
+    return PERMISSION_SUPPORT_MATRIX[platformId];
   };
 
-  const getVerifiedPermissionStatusCopy = (verified, detected) => {
+  const getFullNativePermissionStatusCopy = (support, detected) => {
     if (detected?.hookInstalled) {
       return {
         tone: 'info',
-        titleText: `${verified.label} permission enforcement is enabled.`,
+        titleText: `${support.label} permission enforcement is enabled.`,
         messageText: 'No further changes are needed here unless you want to reinstall the hook settings.',
       };
     }
@@ -1046,44 +1076,60 @@ codex_hooks = true`;
     if (detected?.installed) {
       return {
         tone: 'warning',
-        titleText: `${verified.label} is connected for this client.`,
-        messageText: `DollhouseMCP is configured as an MCP server. Use Configure Now below to also install the ${verified.label} permission hook.`,
+        titleText: `${support.label} is connected for this client.`,
+        messageText: `DollhouseMCP is configured as an MCP server. Use Configure Now below to also install the ${support.label} permission hook.`,
       };
     }
 
     return {
       tone: 'info',
-      titleText: `${verified.label} permissions are not configured yet.`,
-      messageText: `First connect DollhouseMCP using Auto-updating or Pinned version, then use Configure Now below to install the ${verified.label} permission hook.`,
+      titleText: `${support.label} permissions are not configured yet.`,
+      messageText: `First connect DollhouseMCP using Auto-updating or Pinned version, then use Configure Now below to install the ${support.label} permission hook.`,
     };
   };
 
-  const getPartialPermissionStatusCopy = (partial, detected) => {
-    const activationLabel = partial.label === 'Codex' ? 'Bash guardrails' : 'permission hooks';
+  const getPartialPermissionStatusCopy = (support, detected) => {
+    const activationLabel = support.label === 'Codex' ? 'Bash guardrails' : 'permission hooks';
     if (detected?.hookInstalled) {
       return {
         tone: 'info',
-        titleText: `${partial.label} ${activationLabel} are enabled.`,
-        messageText: partial.limitation,
+        titleText: `${support.label} ${activationLabel} are enabled.`,
+        messageText: support.limitation,
       };
     }
 
     if (detected?.installed) {
       return {
         tone: 'warning',
-        titleText: `${partial.label} is connected for this client.`,
-        messageText: `DollhouseMCP is configured as an MCP server. Use Configure Now below to turn on ${partial.label}'s native ${activationLabel}.`,
+        titleText: `${support.label} is connected for this client.`,
+        messageText: `DollhouseMCP is configured as an MCP server. Use Configure Now below to turn on ${support.label}'s native ${activationLabel}.`,
       };
     }
 
     return {
       tone: 'info',
-      titleText: `${partial.label} ${activationLabel} are not configured yet.`,
-      messageText: `First connect DollhouseMCP using Auto-updating or Pinned version, then use Configure Now below to install ${partial.label}'s native ${activationLabel}.`,
+      titleText: `${support.label} ${activationLabel} are not configured yet.`,
+      messageText: `First connect DollhouseMCP using Auto-updating or Pinned version, then use Configure Now below to install ${support.label}'s native ${activationLabel}.`,
     };
   };
 
-  const getManualPermissionStatusCopy = (detected) => {
+  const getMcpOnlyPermissionStatusCopy = (support, detected) => {
+    if (detected?.installed) {
+      return {
+        tone: 'warning',
+        titleText: `${support.label} is connected for this client.`,
+        messageText: `${support.limitation} This release keeps that client in the MCP and fallback lane for now.`,
+      };
+    }
+
+    return {
+      tone: 'info',
+      titleText: `${support.label} supports MCP setup in this release.`,
+      messageText: `${support.limitation} Use Auto-updating or Pinned version above to connect DollhouseMCP first.`,
+    };
+  };
+
+  const getManualPermissionStatusCopy = (support, detected) => {
     if (detected?.hookAssetsPrepared) {
       return {
         tone: 'info',
@@ -1106,32 +1152,40 @@ codex_hooks = true`;
     };
   };
 
-  const getUnsupportedPermissionStatusCopy = (platformLabel, detected) => ({
+  const getUnsupportedPermissionStatusCopy = (support, detected) => ({
     tone: detected?.installed ? 'warning' : 'neutral',
-    titleText: `Permissions & security tools are unavailable for ${platformLabel} right now.`,
+    titleText: `Permissions & security tools are unavailable for ${support.label} right now.`,
     messageText: detected?.installed
       ? 'DollhouseMCP is connected for this client, but this release does not include a supported permissions setup flow here yet.'
-      : 'This release does not include a supported permissions setup flow for this client yet.',
+      : support.limitation,
   });
 
   const getPermissionStatusCopy = (platformId, detected) => {
-    const verified = VERIFIED_PERMISSION_PLATFORMS[platformId];
-    if (verified) {
-      return getVerifiedPermissionStatusCopy(verified, detected);
+    const support = getPermissionSupport(platformId, detected);
+    if (!support) {
+      return getUnsupportedPermissionStatusCopy({
+        label: 'this client',
+        limitation: 'This release does not include a supported permissions setup flow for this client yet.',
+      }, detected);
     }
 
-    const partial = PARTIAL_PERMISSION_PLATFORMS[platformId];
-    if (partial) {
-      return getPartialPermissionStatusCopy(partial, detected);
+    if (support.supportLevel === 'full_native') {
+      return getFullNativePermissionStatusCopy(support, detected);
     }
 
-    const support = PLATFORMS.find((platform) => platform.id === platformId)?.hookSupport || 'unsupported';
-    if (support === 'manual') {
-      return getManualPermissionStatusCopy(detected);
+    if (support.supportLevel === 'partial_native') {
+      return getPartialPermissionStatusCopy(support, detected);
     }
 
-    const platformLabel = PERMISSION_PLATFORM_LABELS[platformId] || 'this client';
-    return getUnsupportedPermissionStatusCopy(platformLabel, detected);
+    if (support.supportLevel === 'mcp_only') {
+      return getMcpOnlyPermissionStatusCopy(support, detected);
+    }
+
+    if (support.supportLevel === 'manual') {
+      return getManualPermissionStatusCopy(support, detected);
+    }
+
+    return getUnsupportedPermissionStatusCopy(support, detected);
   };
 
   const updatePermissionStatus = (panel, platformId, detected) => {
@@ -1418,24 +1472,41 @@ codex_hooks = true`;
     </div>`;
   };
 
+  const renderMcpOnlyPermissionSection = (support) => `<div class="setup-method setup-security-mode" data-setup-modes="permissions" hidden>
+      <h3>Permissions &amp; Security <span class="setup-support-badge setup-support-badge--${support.badgeClass}">${support.statusTag}</span></h3>
+      <div class="setup-permission-status" data-state="info">
+        <strong class="setup-permission-status-title"></strong>
+        <p class="setup-permission-status-msg"></p>
+      </div>
+      <p class="setup-hint">${support.limitation}</p>
+    </div>`;
+
   const renderPermissionSection = (p) => {
-    const hookSupport = p.hookSupport || 'unsupported';
+    const support = getPermissionSupport(p.id);
     const configPath = p.hookConfigPath || p.configPath || p.tomlPath || 'this client’s user configuration';
 
-    if (hookSupport === 'verified' && VERIFIED_PERMISSION_PLATFORMS[p.id]) {
-      return renderVerifiedPermissionSection(p, VERIFIED_PERMISSION_PLATFORMS[p.id]);
+    if (!support) {
+      return '';
+    }
+
+    if (support.supportLevel === 'full_native') {
+      return renderVerifiedPermissionSection(p, support);
+    }
+
+    if (support.supportLevel === 'partial_native') {
+      return renderPartialPermissionSection(p, support);
     }
 
-    if (hookSupport === 'partial' && PARTIAL_PERMISSION_PLATFORMS[p.id]) {
-      return renderPartialPermissionSection(p, PARTIAL_PERMISSION_PLATFORMS[p.id]);
+    if (support.supportLevel === 'mcp_only') {
+      return renderMcpOnlyPermissionSection(support);
     }
 
-    if (hookSupport === 'manual') {
+    if (support.supportLevel === 'manual') {
       const platformName = p.id === 'gemini' ? 'gemini' : p.id;
       const wrapperFilename = `pretooluse-${platformName}.sh`;
       const wrapperScript = buildHookWrapperScript(platformName);
       return `<div class="setup-method setup-security-mode" data-setup-modes="permissions" hidden>
-        <h3>Permissions &amp; Security <span class="setup-support-badge setup-support-badge--manual">manual setup</span></h3>
+        <h3>Permissions &amp; Security <span class="setup-support-badge setup-support-badge--${support.badgeClass}">${support.statusTag}</span></h3>
         <div class="setup-permission-status" data-state="info">
           <strong class="setup-permission-status-title"></strong>
           <p class="setup-permission-status-msg"></p>
@@ -1453,7 +1524,7 @@ codex_hooks = true`;
     }
 
     return `<div class="setup-method setup-security-mode" data-setup-modes="permissions" hidden>
-      <h3>Permissions &amp; Security <span class="setup-support-badge setup-support-badge--unsupported">coming soon</span></h3>
+      <h3>Permissions &amp; Security <span class="setup-support-badge setup-support-badge--${support.badgeClass}">${support.statusTag}</span></h3>
       <div class="setup-permission-status" data-state="neutral">
         <strong class="setup-permission-status-title"></strong>
         <p class="setup-permission-status-msg"></p>
@@ -1467,7 +1538,7 @@ codex_hooks = true`;
 
     intro.innerHTML = `<div class="setup-permissions-note">
         <strong>Permissions &amp; Security</strong>
-        <p>Use this mode to turn on permission enforcement for supported clients. Claude Code is fully guided in this release, and Gemini CLI, Cursor, VS Code, Windsurf, plus Codex have native partial support. Where we have workable manual steps for other clients, they are shown here. Otherwise, the client will be marked as coming soon.</p>
+        <p>Use this mode to turn on permission enforcement for supported clients. Claude Code is fully guided in this release. Gemini CLI, Cursor, VS Code, Windsurf, and Codex have native partial support, while Cline and LM Studio stay in the MCP and fallback lane for now. Other clients will be marked as coming soon.</p>
       </div>`;
   };
 

package/dist/web/routes/permissionRoutes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"permissionRoutes.d.ts","sourceRoot":"","sources":["../../../src/web/routes/permissionRoutes.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAgB,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AAE1C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,yCAAyC,CAAC;AAsJ7E;;;GAGG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,aAAa,GAAG,IAAI,CAkIrF"}
+{"version":3,"file":"permissionRoutes.d.ts","sourceRoot":"","sources":["../../../src/web/routes/permissionRoutes.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAgB,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AAE1C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,yCAAyC,CAAC;AA+Q7E;;;GAGG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,aAAa,GAAG,IAAI,CA0IrF"}

package/dist/web/routes/permissionRoutes.js

@@ -13,6 +13,8 @@ import { SlidingWindowRateLimiter } from '../../utils/SlidingWindowRateLimiter.j
 const PERMISSION_ROUTE_RATE_LIMIT_REQUESTS = 120;
 const PERMISSION_ROUTE_RATE_LIMIT_WINDOW_MS = 60_000;
 const DECISION_BUFFER_SIZE = 200;
+const CLAUDE_COMPATIBLE_HOOK_PLATFORMS = new Set(['claude_code', 'vscode']);
+const NORMALIZABLE_PERMISSION_DECISIONS = new Set(['allow', 'deny', 'ask']);
 /** Extract a string field from a record, trying multiple keys in order */
 function extractString(obj, keys, fallback) {
     for (const key of keys) {
@@ -48,11 +50,71 @@ function extractReason(result) {
     }
     return extractString(result, ['reason', 'message'], '');
 }
+function shouldNormalizeClaudeHook(platform) {
+    return platform !== undefined && CLAUDE_COMPATIBLE_HOOK_PLATFORMS.has(platform);
+}
+function normalizePermissionResponseForPlatform(platform, input, result) {
+    if (!shouldNormalizeClaudeHook(platform)) {
+        return result;
+    }
+    const nested = result.hookSpecificOutput;
+    if (nested && typeof nested === 'object' && !Array.isArray(nested)) {
+        const nestedDecision = nested.permissionDecision;
+        if (typeof nestedDecision === 'string') {
+            return result;
+        }
+    }
+    const decision = extractDecision(result);
+    if (NORMALIZABLE_PERMISSION_DECISIONS.has(decision)) {
+        return formatPermissionResponse(decision, platform, input, extractReason(result));
+    }
+    return formatPermissionResponse('allow', platform, input);
+}
+function buildDecisionDetails(toolName, input, result, platform) {
+    const details = [];
+    if (platform) {
+        details.push({ label: 'Platform', value: platform, monospace: true });
+    }
+    if (toolName === 'Bash' && typeof input.command === 'string' && input.command !== '') {
+        details.push({ label: 'Command', value: input.command, monospace: true });
+    }
+    const targetDescriptors = [
+        { key: 'file_path', label: 'File', monospace: true },
+        { key: 'path', label: 'Path', monospace: true },
+        { key: 'url', label: 'URL' },
+        { key: 'pattern', label: 'Pattern', monospace: true },
+        { key: 'query', label: 'Query' },
+        { key: 'element_name', label: 'Element', monospace: true },
+        { key: 'request_id', label: 'Request', monospace: true },
+    ];
+    let target;
+    let targetLabel;
+    for (const descriptor of targetDescriptors) {
+        const value = input[descriptor.key];
+        if (typeof value !== 'string' || value === '') {
+            continue;
+        }
+        target = value;
+        targetLabel = descriptor.label;
+        details.push({ label: descriptor.label, value, monospace: descriptor.monospace });
+        break;
+    }
+    const matchedPattern = extractString(result, ['matched_pattern', 'matchedPattern'], '');
+    if (matchedPattern !== '') {
+        details.push({ label: 'Matched Pattern', value: matchedPattern, monospace: true });
+    }
+    const policySource = extractString(result, ['policy_source', 'policySource'], '');
+    if (policySource !== '') {
+        details.push({ label: 'Policy Source', value: policySource, monospace: true });
+    }
+    return { target, targetLabel, details };
+}
 function createPermissionDecisionTracker(bufferSize = DECISION_BUFFER_SIZE) {
     const recentDecisions = [];
     let decisionCounter = 0;
     return {
-        trackDecision(sessionId, toolName, input, result) {
+        trackDecision(sessionId, toolName, input, result, platform) {
+            const detailState = buildDecisionDetails(toolName, input, result, platform);
             const entry = {
                 id: `d-${++decisionCounter}`,
                 timestamp: new Date().toISOString(),
@@ -61,6 +123,10 @@ function createPermissionDecisionTracker(bufferSize = DECISION_BUFFER_SIZE) {
                 command: toolName === 'Bash' && typeof input?.command === 'string' ? input.command : undefined,
                 decision: extractDecision(result),
                 reason: extractReason(result),
+                platform,
+                target: detailState.target,
+                targetLabel: detailState.targetLabel,
+                details: detailState.details,
             };
             recentDecisions.unshift(entry);
             if (recentDecisions.length > bufferSize) {
@@ -92,6 +158,8 @@ function normalizePolicyElements(elements) {
         allowRules: mergeRuleArrays(element.allowPatterns, element.allowOperations),
         confirmRules: mergeRuleArrays(element.confirmPatterns, element.confirmOperations),
         denyRules: mergeRuleArrays(element.denyPatterns, element.denyOperations),
+        invalidGatekeeperPolicy: !!element.invalidGatekeeperPolicy,
+        invalidGatekeeperMessage: typeof element.invalidGatekeeperMessage === 'string' ? element.invalidGatekeeperMessage : undefined,
     }));
 }
 function resolveElementName(element) {
@@ -171,11 +239,14 @@ export function registerPermissionRoutes(router, handler) {
                 res.json(formatPermissionResponse('allow', platform, input || {})); // fail open
                 return;
             }
-            const decision = extractDecision(opResult.data);
+            const rawResult = opResult.data;
+            const responseData = normalizePermissionResponseForPlatform(platform, input || {}, rawResult);
+            const trackedResult = { ...rawResult, ...responseData };
+            const decision = extractDecision(responseData);
             logger.debug(`[WebUI/Gateway] evaluate_permission: ${tool_name} → ${decision} (${elapsedMs}ms)`);
             // Track decision for live dashboard feed
-            decisionTracker.trackDecision(session_id, tool_name, input || {}, opResult.data);
-            res.json(opResult.data);
+            decisionTracker.trackDecision(session_id, tool_name, input || {}, trackedResult, platform);
+            res.json(responseData);
         }
         catch (err) {
             const elapsedMs = Date.now() - startMs;
@@ -231,6 +302,7 @@ export function registerPermissionRoutes(router, handler) {
                 hookInstalled: data.hookInstalled,
                 hookHost: data.hookHost,
                 enforcementReady: data.enforcementReady,
+                invalidPolicyElementCount: data.invalidPolicyElementCount ?? 0,
                 advisory: data.advisory,
                 recentDecisions: decisionTracker.getRecentDecisions(),
             });
@@ -241,4 +313,4 @@ export function registerPermissionRoutes(router, handler) {
         }
     });
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"permissionRoutes.js","sourceRoot":"","sources":["../../../src/web/routes/permissionRoutes.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Permission evaluation HTTP routes and decision tracking.\n *\n * Provides:\n * - POST /evaluate_permission — evaluates tool permissions via MCP-AQL\n * - GET /permissions/status — returns current policies and recent decisions\n * - Decision tracking ring buffer for the live dashboard feed\n */\n\nimport express, { Router } from 'express';\nimport { logger } from '../../utils/logger.js';\nimport type { MCPAQLHandler } from '../../handlers/mcp-aql/MCPAQLHandler.js';\nimport { formatPermissionResponse } from '../../handlers/mcp-aql/evaluatePermission.js';\n\nimport { SlidingWindowRateLimiter } from '../../utils/SlidingWindowRateLimiter.js';\n\n// ── Permission Decision Tracking ─────────────────────────────────────────────\n// Ring buffer of recent permission decisions for the live dashboard feed.\n\ninterface PermissionDecision {\n  id: string;\n  timestamp: string;\n  session_id?: string;\n  tool_name: string;\n  command?: string;\n  decision: string;\n  reason?: string;\n}\n\ninterface KnownPolicySession {\n  sessionId: string;\n  displayName: string;\n  source: 'policy';\n}\n\nconst PERMISSION_ROUTE_RATE_LIMIT_REQUESTS = 120;\nconst PERMISSION_ROUTE_RATE_LIMIT_WINDOW_MS = 60_000;\nconst DECISION_BUFFER_SIZE = 200;\n\ninterface PermissionDecisionTracker {\n  trackDecision(sessionId: string | undefined, toolName: string, input: Record<string, unknown>, result: Record<string, unknown>): void;\n  getRecentDecisions(): PermissionDecision[];\n}\n\n/** Extract a string field from a record, trying multiple keys in order */\nfunction extractString(obj: Record<string, unknown>, keys: string[], fallback: string): string {\n  for (const key of keys) {\n    const val = obj?.[key];\n    if (typeof val === 'string') return val;\n  }\n  return fallback;\n}\n\nfunction extractDecision(result: Record<string, unknown>): string {\n  const nested = result.hookSpecificOutput;\n  if (nested && typeof nested === 'object' && !Array.isArray(nested)) {\n    const nestedDecision = (nested as Record<string, unknown>).permissionDecision;\n    if (typeof nestedDecision === 'string') return nestedDecision;\n  }\n\n  if (typeof result.permission === 'string') return result.permission;\n  if (typeof result.decision === 'string') return result.decision;\n  if (typeof result.behavior === 'string') return result.behavior;\n  if (typeof result.allowed === 'boolean') return result.allowed ? 'allow' : 'deny';\n  return 'unknown';\n}\n\nfunction extractReason(result: Record<string, unknown>): string {\n  const nested = result.hookSpecificOutput;\n  if (nested && typeof nested === 'object' && !Array.isArray(nested)) {\n    const nestedReason = (nested as Record<string, unknown>).permissionDecisionReason;\n    if (typeof nestedReason === 'string') return nestedReason;\n  }\n\n  return extractString(result, ['reason', 'message'], '');\n}\n\nfunction createPermissionDecisionTracker(bufferSize = DECISION_BUFFER_SIZE): PermissionDecisionTracker {\n  const recentDecisions: PermissionDecision[] = [];\n  let decisionCounter = 0;\n\n  return {\n    trackDecision(sessionId: string | undefined, toolName: string, input: Record<string, unknown>, result: Record<string, unknown>): void {\n      const entry: PermissionDecision = {\n        id: `d-${++decisionCounter}`,\n        timestamp: new Date().toISOString(),\n        ...(sessionId ? { session_id: sessionId } : {}),\n        tool_name: toolName,\n        command: toolName === 'Bash' && typeof input?.command === 'string' ? input.command : undefined,\n        decision: extractDecision(result),\n        reason: extractReason(result),\n      };\n      recentDecisions.unshift(entry);\n      if (recentDecisions.length > bufferSize) {\n        recentDecisions.length = bufferSize;\n      }\n    },\n    getRecentDecisions(): PermissionDecision[] {\n      return recentDecisions;\n    },\n  };\n}\n\nfunction mergeRuleArrays(...sources: unknown[]): string[] {\n  const merged = new Set<string>();\n  for (const source of sources) {\n    if (!Array.isArray(source)) continue;\n    for (const entry of source) {\n      if (typeof entry === 'string' && entry !== '') {\n        merged.add(entry);\n      }\n    }\n  }\n  return Array.from(merged);\n}\n\nfunction normalizePolicyElements(elements: Array<Record<string, unknown>>): Array<Record<string, unknown>> {\n  return elements.map((element) => ({\n    ...element,\n    element_name: resolveElementName(element),\n    allowRules: mergeRuleArrays(element.allowPatterns, element.allowOperations),\n    confirmRules: mergeRuleArrays(element.confirmPatterns, element.confirmOperations),\n    denyRules: mergeRuleArrays(element.denyPatterns, element.denyOperations),\n  }));\n}\n\nfunction resolveElementName(element: Record<string, unknown>): string {\n  if (typeof element.element_name === 'string') return element.element_name;\n  if (typeof element.name === 'string') return element.name;\n  return '';\n}\n\n/** Helper to extract single result from MCP-AQL batch response */\nfunction asSingleResult(results: unknown): { success: boolean; data?: unknown; error?: string } {\n  if (Array.isArray(results)) return results[0] || { success: false, error: 'Empty result' };\n  return results as { success: boolean; data?: unknown; error?: string };\n}\n\nfunction extractKnownPolicySessions(elements: Array<Record<string, unknown>>): KnownPolicySession[] {\n  const seen = new Set<string>();\n  const knownSessions: KnownPolicySession[] = [];\n\n  for (const element of elements) {\n    const sessionIds = Array.isArray(element.sessionIds) ? element.sessionIds : [];\n    for (const sessionId of sessionIds) {\n      if (typeof sessionId !== 'string' || sessionId === '' || seen.has(sessionId)) {\n        continue;\n      }\n\n      seen.add(sessionId);\n      knownSessions.push({\n        sessionId,\n        displayName: sessionId,\n        source: 'policy',\n      });\n    }\n  }\n\n  return knownSessions.sort((a, b) => a.sessionId.localeCompare(b.sessionId));\n}\n\n/**\n * Register permission-related routes on a gateway router.\n * Must be called with the MCP-AQL handler for policy evaluation.\n */\nexport function registerPermissionRoutes(router: Router, handler: MCPAQLHandler): void {\n  const decisionTracker = createPermissionDecisionTracker();\n  /**\n   * POST /api/evaluate_permission\n   * Permission evaluation endpoint for PreToolUse hooks.\n   * Routes through evaluate_permission MCP-AQL READ operation.\n   * Fail-open: returns allow on any error to avoid blocking the user.\n   */\n  const permissionLimiter = new SlidingWindowRateLimiter(\n    PERMISSION_ROUTE_RATE_LIMIT_REQUESTS,\n    PERMISSION_ROUTE_RATE_LIMIT_WINDOW_MS,\n  );\n  router.post('/evaluate_permission', express.json(), async (req, res) => {\n    const body = req.body as {\n      tool_name?: string;\n      input?: Record<string, unknown>;\n      platform?: string;\n      session_id?: string;\n    };\n    const platform = typeof body.platform === 'string' ? body.platform.normalize('NFC') : 'claude_code';\n\n    if (!permissionLimiter.tryAcquire()) {\n      res.json(formatPermissionResponse('allow', platform, {})); // fail open on rate limit\n      return;\n    }\n\n    // Unicode normalization (NFC) on string inputs to prevent homograph attacks\n    const tool_name = typeof body.tool_name === 'string' ? body.tool_name.normalize('NFC') : undefined;\n    const session_id = typeof body.session_id === 'string' ? body.session_id.normalize('NFC') : undefined;\n    const input = body.input;\n\n    if (!tool_name) {\n      res.json(formatPermissionResponse('allow', platform, input || {})); // fail open on bad input\n      return;\n    }\n\n    const startMs = Date.now();\n    try {\n      const opResult = asSingleResult(await handler.handleRead({\n        operation: 'evaluate_permission',\n        params: {\n          tool_name,\n          input: input || {},\n          platform,\n          ...(session_id ? { session_id } : {}),\n        },\n      }));\n      const elapsedMs = Date.now() - startMs;\n\n      if (!opResult.success) {\n        logger.warn(`[WebUI/Gateway] evaluate_permission failed (${elapsedMs}ms): ${opResult.error}`);\n        res.json(formatPermissionResponse('allow', platform, input || {})); // fail open\n        return;\n      }\n\n      const decision = extractDecision(opResult.data as Record<string, unknown>);\n      logger.debug(`[WebUI/Gateway] evaluate_permission: ${tool_name} → ${decision} (${elapsedMs}ms)`);\n\n      // Track decision for live dashboard feed\n      decisionTracker.trackDecision(session_id, tool_name, input || {}, opResult.data as Record<string, unknown>);\n\n      res.json(opResult.data);\n    } catch (err) {\n      const elapsedMs = Date.now() - startMs;\n      logger.error(`[WebUI/Gateway] evaluate_permission error (${elapsedMs}ms):`, err);\n      res.json(formatPermissionResponse('allow', platform, input || {})); // fail open\n    }\n  });\n\n  /**\n   * GET /api/permissions/status\n   * Returns current permission policies and recent decisions\n   * for the live permissions dashboard.\n   */\n  router.get('/permissions/status', async (req, res) => {\n    try {\n      const sessionId = typeof req.query['sessionId'] === 'string' && req.query['sessionId']\n        ? req.query['sessionId']\n        : undefined;\n\n      const opResult = asSingleResult(await handler.handleRead({\n        operation: 'get_effective_cli_policies',\n        params: {\n          reporting_scope: 'dashboard',\n          ...(sessionId ? { session_id: sessionId } : {}),\n        },\n      }));\n\n      if (!opResult.success) {\n        res.status(500).json({ error: opResult.error || 'Failed to get policies' });\n        return;\n      }\n\n      const data = opResult.data as Record<string, unknown>;\n      const elements = normalizePolicyElements((data.elements || []) as Array<Record<string, unknown>>);\n\n      const denyPatterns = (data.combinedDenyPatterns as string[] | undefined) ?? [];\n      const allowPatterns = (data.combinedAllowPatterns as string[] | undefined) ?? [];\n      const confirmPatterns = (data.combinedConfirmPatterns as string[] | undefined) ?? [];\n      const denyOperations = (data.combinedDenyOperations as string[] | undefined) ?? [];\n      const allowOperations = (data.combinedAllowOperations as string[] | undefined) ?? [];\n      const confirmOperations = (data.combinedConfirmOperations as string[] | undefined) ?? [];\n\n      res.json({\n        ...(sessionId ? { sessionId } : {}),\n        activeElementCount: data.activeElementCount,\n        hasAllowlist: data.hasAllowlist,\n        denyPatterns,\n        allowPatterns,\n        confirmPatterns,\n        denyOperations,\n        allowOperations,\n        confirmOperations,\n        denyRules: mergeRuleArrays(denyPatterns, denyOperations),\n        allowRules: mergeRuleArrays(allowPatterns, allowOperations),\n        confirmRules: mergeRuleArrays(confirmPatterns, confirmOperations),\n        elements,\n        knownSessions: extractKnownPolicySessions(elements),\n        permissionPromptActive: data.permissionPromptActive,\n        hookInstalled: data.hookInstalled,\n        hookHost: data.hookHost,\n        enforcementReady: data.enforcementReady,\n        advisory: data.advisory,\n        recentDecisions: decisionTracker.getRecentDecisions(),\n      });\n    } catch (err) {\n      logger.error('[WebUI/Gateway] permissions/status error:', err);\n      res.status(500).json({ error: 'Failed to get permission status' });\n    }\n  });\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"permissionRoutes.js","sourceRoot":"","sources":["../../../src/web/routes/permissionRoutes.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Permission evaluation HTTP routes and decision tracking.\n *\n * Provides:\n * - POST /evaluate_permission — evaluates tool permissions via MCP-AQL\n * - GET /permissions/status — returns current policies and recent decisions\n * - Decision tracking ring buffer for the live dashboard feed\n */\n\nimport express, { Router } from 'express';\nimport { logger } from '../../utils/logger.js';\nimport type { MCPAQLHandler } from '../../handlers/mcp-aql/MCPAQLHandler.js';\nimport { formatPermissionResponse } from '../../handlers/mcp-aql/evaluatePermission.js';\n\nimport { SlidingWindowRateLimiter } from '../../utils/SlidingWindowRateLimiter.js';\n\n// ── Permission Decision Tracking ─────────────────────────────────────────────\n// Ring buffer of recent permission decisions for the live dashboard feed.\n\ninterface PermissionDecision {\n  id: string;\n  timestamp: string;\n  session_id?: string;\n  tool_name: string;\n  command?: string;\n  decision: string;\n  reason?: string;\n  platform?: string;\n  target?: string;\n  targetLabel?: string;\n  details?: PermissionDecisionDetail[];\n}\n\ninterface PermissionDecisionDetail {\n  label: string;\n  value: string;\n  monospace?: boolean;\n}\n\ninterface KnownPolicySession {\n  sessionId: string;\n  displayName: string;\n  source: 'policy';\n}\n\nconst PERMISSION_ROUTE_RATE_LIMIT_REQUESTS = 120;\nconst PERMISSION_ROUTE_RATE_LIMIT_WINDOW_MS = 60_000;\nconst DECISION_BUFFER_SIZE = 200;\n\ninterface PermissionDecisionTracker {\n  trackDecision(\n    sessionId: string | undefined,\n    toolName: string,\n    input: Record<string, unknown>,\n    result: Record<string, unknown>,\n    platform: string,\n  ): void;\n  getRecentDecisions(): PermissionDecision[];\n}\n\nconst CLAUDE_COMPATIBLE_HOOK_PLATFORMS = new Set(['claude_code', 'vscode']);\nconst NORMALIZABLE_PERMISSION_DECISIONS = new Set(['allow', 'deny', 'ask']);\ntype NormalizablePermissionDecision = 'allow' | 'deny' | 'ask';\n\n/** Extract a string field from a record, trying multiple keys in order */\nfunction extractString(obj: Record<string, unknown>, keys: string[], fallback: string): string {\n  for (const key of keys) {\n    const val = obj?.[key];\n    if (typeof val === 'string') return val;\n  }\n  return fallback;\n}\n\nfunction extractDecision(result: Record<string, unknown>): string {\n  const nested = result.hookSpecificOutput;\n  if (nested && typeof nested === 'object' && !Array.isArray(nested)) {\n    const nestedDecision = (nested as Record<string, unknown>).permissionDecision;\n    if (typeof nestedDecision === 'string') return nestedDecision;\n  }\n\n  if (typeof result.permission === 'string') return result.permission;\n  if (typeof result.decision === 'string') return result.decision;\n  if (typeof result.behavior === 'string') return result.behavior;\n  if (typeof result.allowed === 'boolean') return result.allowed ? 'allow' : 'deny';\n  return 'unknown';\n}\n\nfunction extractReason(result: Record<string, unknown>): string {\n  const nested = result.hookSpecificOutput;\n  if (nested && typeof nested === 'object' && !Array.isArray(nested)) {\n    const nestedReason = (nested as Record<string, unknown>).permissionDecisionReason;\n    if (typeof nestedReason === 'string') return nestedReason;\n  }\n\n  return extractString(result, ['reason', 'message'], '');\n}\n\nfunction shouldNormalizeClaudeHook(platform: string | undefined): boolean {\n  return platform !== undefined && CLAUDE_COMPATIBLE_HOOK_PLATFORMS.has(platform);\n}\n\nfunction normalizePermissionResponseForPlatform(\n  platform: string,\n  input: Record<string, unknown>,\n  result: Record<string, unknown>,\n): Record<string, unknown> {\n  if (!shouldNormalizeClaudeHook(platform)) {\n    return result;\n  }\n\n  const nested = result.hookSpecificOutput;\n  if (nested && typeof nested === 'object' && !Array.isArray(nested)) {\n    const nestedDecision = (nested as Record<string, unknown>).permissionDecision;\n    if (typeof nestedDecision === 'string') {\n      return result;\n    }\n  }\n\n  const decision = extractDecision(result);\n  if (NORMALIZABLE_PERMISSION_DECISIONS.has(decision)) {\n    return formatPermissionResponse(\n      decision as NormalizablePermissionDecision,\n      platform,\n      input,\n      extractReason(result),\n    );\n  }\n\n  return formatPermissionResponse('allow', platform, input);\n}\n\nfunction buildDecisionDetails(\n  toolName: string,\n  input: Record<string, unknown>,\n  result: Record<string, unknown>,\n  platform: string,\n): { target?: string; targetLabel?: string; details: PermissionDecisionDetail[] } {\n  const details: PermissionDecisionDetail[] = [];\n\n  if (platform) {\n    details.push({ label: 'Platform', value: platform, monospace: true });\n  }\n\n  if (toolName === 'Bash' && typeof input.command === 'string' && input.command !== '') {\n    details.push({ label: 'Command', value: input.command, monospace: true });\n  }\n\n  const targetDescriptors: Array<{ key: string; label: string; monospace?: boolean }> = [\n    { key: 'file_path', label: 'File', monospace: true },\n    { key: 'path', label: 'Path', monospace: true },\n    { key: 'url', label: 'URL' },\n    { key: 'pattern', label: 'Pattern', monospace: true },\n    { key: 'query', label: 'Query' },\n    { key: 'element_name', label: 'Element', monospace: true },\n    { key: 'request_id', label: 'Request', monospace: true },\n  ];\n\n  let target: string | undefined;\n  let targetLabel: string | undefined;\n\n  for (const descriptor of targetDescriptors) {\n    const value = input[descriptor.key];\n    if (typeof value !== 'string' || value === '') {\n      continue;\n    }\n\n    target = value;\n    targetLabel = descriptor.label;\n    details.push({ label: descriptor.label, value, monospace: descriptor.monospace });\n    break;\n  }\n\n  const matchedPattern = extractString(result, ['matched_pattern', 'matchedPattern'], '');\n  if (matchedPattern !== '') {\n    details.push({ label: 'Matched Pattern', value: matchedPattern, monospace: true });\n  }\n\n  const policySource = extractString(result, ['policy_source', 'policySource'], '');\n  if (policySource !== '') {\n    details.push({ label: 'Policy Source', value: policySource, monospace: true });\n  }\n\n  return { target, targetLabel, details };\n}\n\nfunction createPermissionDecisionTracker(bufferSize = DECISION_BUFFER_SIZE): PermissionDecisionTracker {\n  const recentDecisions: PermissionDecision[] = [];\n  let decisionCounter = 0;\n\n  return {\n    trackDecision(\n      sessionId: string | undefined,\n      toolName: string,\n      input: Record<string, unknown>,\n      result: Record<string, unknown>,\n      platform: string,\n    ): void {\n      const detailState = buildDecisionDetails(toolName, input, result, platform);\n      const entry: PermissionDecision = {\n        id: `d-${++decisionCounter}`,\n        timestamp: new Date().toISOString(),\n        ...(sessionId ? { session_id: sessionId } : {}),\n        tool_name: toolName,\n        command: toolName === 'Bash' && typeof input?.command === 'string' ? input.command : undefined,\n        decision: extractDecision(result),\n        reason: extractReason(result),\n        platform,\n        target: detailState.target,\n        targetLabel: detailState.targetLabel,\n        details: detailState.details,\n      };\n      recentDecisions.unshift(entry);\n      if (recentDecisions.length > bufferSize) {\n        recentDecisions.length = bufferSize;\n      }\n    },\n    getRecentDecisions(): PermissionDecision[] {\n      return recentDecisions;\n    },\n  };\n}\n\nfunction mergeRuleArrays(...sources: unknown[]): string[] {\n  const merged = new Set<string>();\n  for (const source of sources) {\n    if (!Array.isArray(source)) continue;\n    for (const entry of source) {\n      if (typeof entry === 'string' && entry !== '') {\n        merged.add(entry);\n      }\n    }\n  }\n  return Array.from(merged);\n}\n\nfunction normalizePolicyElements(elements: Array<Record<string, unknown>>): Array<Record<string, unknown>> {\n  return elements.map((element) => ({\n    ...element,\n    element_name: resolveElementName(element),\n    allowRules: mergeRuleArrays(element.allowPatterns, element.allowOperations),\n    confirmRules: mergeRuleArrays(element.confirmPatterns, element.confirmOperations),\n    denyRules: mergeRuleArrays(element.denyPatterns, element.denyOperations),\n    invalidGatekeeperPolicy: !!element.invalidGatekeeperPolicy,\n    invalidGatekeeperMessage: typeof element.invalidGatekeeperMessage === 'string' ? element.invalidGatekeeperMessage : undefined,\n  }));\n}\n\nfunction resolveElementName(element: Record<string, unknown>): string {\n  if (typeof element.element_name === 'string') return element.element_name;\n  if (typeof element.name === 'string') return element.name;\n  return '';\n}\n\n/** Helper to extract single result from MCP-AQL batch response */\nfunction asSingleResult(results: unknown): { success: boolean; data?: unknown; error?: string } {\n  if (Array.isArray(results)) return results[0] || { success: false, error: 'Empty result' };\n  return results as { success: boolean; data?: unknown; error?: string };\n}\n\nfunction extractKnownPolicySessions(elements: Array<Record<string, unknown>>): KnownPolicySession[] {\n  const seen = new Set<string>();\n  const knownSessions: KnownPolicySession[] = [];\n\n  for (const element of elements) {\n    const sessionIds = Array.isArray(element.sessionIds) ? element.sessionIds : [];\n    for (const sessionId of sessionIds) {\n      if (typeof sessionId !== 'string' || sessionId === '' || seen.has(sessionId)) {\n        continue;\n      }\n\n      seen.add(sessionId);\n      knownSessions.push({\n        sessionId,\n        displayName: sessionId,\n        source: 'policy',\n      });\n    }\n  }\n\n  return knownSessions.sort((a, b) => a.sessionId.localeCompare(b.sessionId));\n}\n\n/**\n * Register permission-related routes on a gateway router.\n * Must be called with the MCP-AQL handler for policy evaluation.\n */\nexport function registerPermissionRoutes(router: Router, handler: MCPAQLHandler): void {\n  const decisionTracker = createPermissionDecisionTracker();\n  /**\n   * POST /api/evaluate_permission\n   * Permission evaluation endpoint for PreToolUse hooks.\n   * Routes through evaluate_permission MCP-AQL READ operation.\n   * Fail-open: returns allow on any error to avoid blocking the user.\n   */\n  const permissionLimiter = new SlidingWindowRateLimiter(\n    PERMISSION_ROUTE_RATE_LIMIT_REQUESTS,\n    PERMISSION_ROUTE_RATE_LIMIT_WINDOW_MS,\n  );\n  router.post('/evaluate_permission', express.json(), async (req, res) => {\n    const body = req.body as {\n      tool_name?: string;\n      input?: Record<string, unknown>;\n      platform?: string;\n      session_id?: string;\n    };\n    const platform = typeof body.platform === 'string' ? body.platform.normalize('NFC') : 'claude_code';\n\n    if (!permissionLimiter.tryAcquire()) {\n      res.json(formatPermissionResponse('allow', platform, {})); // fail open on rate limit\n      return;\n    }\n\n    // Unicode normalization (NFC) on string inputs to prevent homograph attacks\n    const tool_name = typeof body.tool_name === 'string' ? body.tool_name.normalize('NFC') : undefined;\n    const session_id = typeof body.session_id === 'string' ? body.session_id.normalize('NFC') : undefined;\n    const input = body.input;\n\n    if (!tool_name) {\n      res.json(formatPermissionResponse('allow', platform, input || {})); // fail open on bad input\n      return;\n    }\n\n    const startMs = Date.now();\n    try {\n      const opResult = asSingleResult(await handler.handleRead({\n        operation: 'evaluate_permission',\n        params: {\n          tool_name,\n          input: input || {},\n          platform,\n          ...(session_id ? { session_id } : {}),\n        },\n      }));\n      const elapsedMs = Date.now() - startMs;\n\n      if (!opResult.success) {\n        logger.warn(`[WebUI/Gateway] evaluate_permission failed (${elapsedMs}ms): ${opResult.error}`);\n        res.json(formatPermissionResponse('allow', platform, input || {})); // fail open\n        return;\n      }\n\n      const rawResult = opResult.data as Record<string, unknown>;\n      const responseData = normalizePermissionResponseForPlatform(\n        platform,\n        input || {},\n        rawResult,\n      );\n      const trackedResult = { ...rawResult, ...responseData };\n      const decision = extractDecision(responseData);\n      logger.debug(`[WebUI/Gateway] evaluate_permission: ${tool_name} → ${decision} (${elapsedMs}ms)`);\n\n      // Track decision for live dashboard feed\n      decisionTracker.trackDecision(session_id, tool_name, input || {}, trackedResult, platform);\n\n      res.json(responseData);\n    } catch (err) {\n      const elapsedMs = Date.now() - startMs;\n      logger.error(`[WebUI/Gateway] evaluate_permission error (${elapsedMs}ms):`, err);\n      res.json(formatPermissionResponse('allow', platform, input || {})); // fail open\n    }\n  });\n\n  /**\n   * GET /api/permissions/status\n   * Returns current permission policies and recent decisions\n   * for the live permissions dashboard.\n   */\n  router.get('/permissions/status', async (req, res) => {\n    try {\n      const sessionId = typeof req.query['sessionId'] === 'string' && req.query['sessionId']\n        ? req.query['sessionId']\n        : undefined;\n\n      const opResult = asSingleResult(await handler.handleRead({\n        operation: 'get_effective_cli_policies',\n        params: {\n          reporting_scope: 'dashboard',\n          ...(sessionId ? { session_id: sessionId } : {}),\n        },\n      }));\n\n      if (!opResult.success) {\n        res.status(500).json({ error: opResult.error || 'Failed to get policies' });\n        return;\n      }\n\n      const data = opResult.data as Record<string, unknown>;\n      const elements = normalizePolicyElements((data.elements || []) as Array<Record<string, unknown>>);\n\n      const denyPatterns = (data.combinedDenyPatterns as string[] | undefined) ?? [];\n      const allowPatterns = (data.combinedAllowPatterns as string[] | undefined) ?? [];\n      const confirmPatterns = (data.combinedConfirmPatterns as string[] | undefined) ?? [];\n      const denyOperations = (data.combinedDenyOperations as string[] | undefined) ?? [];\n      const allowOperations = (data.combinedAllowOperations as string[] | undefined) ?? [];\n      const confirmOperations = (data.combinedConfirmOperations as string[] | undefined) ?? [];\n\n      res.json({\n        ...(sessionId ? { sessionId } : {}),\n        activeElementCount: data.activeElementCount,\n        hasAllowlist: data.hasAllowlist,\n        denyPatterns,\n        allowPatterns,\n        confirmPatterns,\n        denyOperations,\n        allowOperations,\n        confirmOperations,\n        denyRules: mergeRuleArrays(denyPatterns, denyOperations),\n        allowRules: mergeRuleArrays(allowPatterns, allowOperations),\n        confirmRules: mergeRuleArrays(confirmPatterns, confirmOperations),\n        elements,\n        knownSessions: extractKnownPolicySessions(elements),\n        permissionPromptActive: data.permissionPromptActive,\n        hookInstalled: data.hookInstalled,\n        hookHost: data.hookHost,\n        enforcementReady: data.enforcementReady,\n        invalidPolicyElementCount: data.invalidPolicyElementCount ?? 0,\n        advisory: data.advisory,\n        recentDecisions: decisionTracker.getRecentDecisions(),\n      });\n    } catch (err) {\n      logger.error('[WebUI/Gateway] permissions/status error:', err);\n      res.status(500).json({ error: 'Failed to get permission status' });\n    }\n  });\n}\n"]}