polydev-ai 1.9.24 → 1.9.26

package/lib/cliManager.js

@@ -208,7 +208,7 @@ class CLIManager {
           provider.command, 
           provider.subcommands.version,
           'args',
-          5000
+          400000
         );
         version = versionResult.stdout?.trim();
       } catch (versionError) {
@@ -244,7 +244,7 @@ class CLIManager {
             provider.command,
             provider.subcommands.auth_status,
             'args',
-            5000 // Reduced timeout to 5 seconds
+            400000 // Reduced timeout to 5 seconds
           );
           
           // If command succeeds, check output for authentication indicators
@@ -458,16 +458,16 @@ This is a known issue with @google/gemini-cli@0.3.4 and older Node.js versions.`
   }
 
   async sendCliPrompt(providerId, prompt, mode = 'args', timeoutMs = null, model = null) {
-    // Set default timeout for CLI responses (240 seconds / 4 minutes)
+    // Set default timeout for CLI responses (400 seconds)
     // CLI-within-CLI scenarios (Claude Code calling Claude Code) need generous timeouts
     if (timeoutMs === null) {
-      timeoutMs = 240000; // 240 seconds (4 minutes) default for CLI responses
+      timeoutMs = 400000; // 400 seconds default for CLI responses
     }
 
     // Ensure timeoutMs is valid (not undefined, null, Infinity, or negative)
     // Allow up to 600 seconds (10 minutes) for very complex operations
     if (!timeoutMs || timeoutMs === Infinity || timeoutMs < 1 || timeoutMs > 600000) {
-      timeoutMs = 240000 // Default to 240 seconds (4 minutes) for CLI responses
+      timeoutMs = 400000 // Default to 400 seconds for CLI responses
     }
     
     const startTime = Date.now();
@@ -806,11 +806,11 @@ This is a known issue with @google/gemini-cli@0.3.4 and older Node.js versions.`
     }
   }
 
-  async executeCliCommand(command, args, mode = 'args', timeoutMs = 240000, stdinInput) {
+  async executeCliCommand(command, args, mode = 'args', timeoutMs = 400000, stdinInput) {
     // Ensure timeoutMs is valid (not undefined, null, Infinity, or negative)
-    // 240 seconds (4 minutes) default for CLI responses
+    // 400 seconds default for CLI responses
     if (!timeoutMs || timeoutMs === Infinity || timeoutMs < 1 || timeoutMs > 600000) {
-      timeoutMs = 240000 // Default to 240 seconds (4 minutes)
+      timeoutMs = 400000 // Default to 400 seconds
     }
     
     return new Promise((resolve, reject) => {
@@ -1180,14 +1180,10 @@ This is a known issue with @google/gemini-cli@0.3.4 and older Node.js versions.`
       const parseCodexOutput = (output) => {
         if (!output || !output.trim()) return null;
         
-        // Strip ANSI escape codes first — Codex CLI wraps markers like 'codex' and
-        // 'tokens used' in bold/color codes which break regex matching
-        const cleanOutput = output.replace(/\x1b\[[0-9;]*m/g, '');
-        
         // First, try to extract the response between "codex" marker and "tokens used"
         // IMPORTANT: Use (?:^|\n) to match "codex" only at the start of a line
         // This prevents matching "codex" in model names like "gpt-5.2-codex"
-        const codexMarkerMatch = cleanOutput.match(/(?:^|\n)codex\s*\n([\s\S]*?)(?:\n\s*tokens used|\n\s*$)/i);
+        const codexMarkerMatch = output.match(/(?:^|\n)codex\s*\n([\s\S]*?)(?:\n\s*tokens used|\n\s*$)/i);
         if (codexMarkerMatch && codexMarkerMatch[1]) {
           const extracted = codexMarkerMatch[1].trim();
           if (extracted.length > 0 && !extracted.startsWith('ERROR')) {
@@ -1196,7 +1192,7 @@ This is a known issue with @google/gemini-cli@0.3.4 and older Node.js versions.`
         }
 
         // Fallback: Try to find bullet point responses
-        const bulletMatches = cleanOutput.match(/•\s*(.+)/g);
+        const bulletMatches = output.match(/•\s*(.+)/g);
         if (bulletMatches && bulletMatches.length > 0) {
           const bulletContent = bulletMatches
             .map(m => m.replace(/^•\s*/, '').trim())
@@ -1208,9 +1204,8 @@ This is a known issue with @google/gemini-cli@0.3.4 and older Node.js versions.`
         }
         
         // Last resort: Filter out known noise patterns line by line
-        const lines = cleanOutput.split('\n');
+        const lines = output.split('\n');
         const contentLines = [];
-        let seenTokensUsed = false;
         
         // Patterns to skip (Codex-specific noise)
         const noisePatterns = [
@@ -1230,6 +1225,7 @@ This is a known issue with @google/gemini-cli@0.3.4 and older Node.js versions.`
           /^thinking$/i,                                    // "thinking" marker
           /^codex$/i,                                       // "codex" marker
           /^tokens used$/i,                                 // Token count header
+          /^[\d,]+$/,                                       // Just numbers (token counts)
           /^ERROR:\s*MCP/i,                                 // MCP errors
           /MCP client for .* failed/i,                      // MCP client failures
           /handshake.*failed/i,                             // Handshake errors
@@ -1244,15 +1240,6 @@ This is a known issue with @google/gemini-cli@0.3.4 and older Node.js versions.`
         for (const line of lines) {
           const trimmedLine = line.trim();
           
-          // Track when we've passed the "tokens used" footer
-          if (/^tokens used$/i.test(trimmedLine)) {
-            seenTokensUsed = true;
-            continue;
-          }
-          
-          // After "tokens used", skip pure numbers (token counts like "22")
-          if (seenTokensUsed && /^[\d,]+$/.test(trimmedLine)) continue;
-          
           // Check if line matches any noise pattern
           const isNoise = noisePatterns.some(pattern => pattern.test(trimmedLine));
           if (isNoise) continue;

package/mcp/manifest.json

@@ -292,6 +292,251 @@
         }
       ]
     },
+    {
+      "name": "force_cli_detection",
+      "description": "Force detection and status update for CLI tools (Claude Code, Codex CLI, Gemini CLI). Updates local cache and reports status to MCP server via Supabase.",
+      "inputSchema": {
+        "type": "object",
+        "properties": {
+          "user_id": {
+            "type": "string",
+            "description": "User ID for database status updates (optional for stdio-wrapper)",
+            "minLength": 1
+          },
+          "provider_id": {
+            "type": "string",
+            "description": "Specific CLI provider to detect (optional, detects all if not provided)",
+            "enum": ["claude_code", "codex_cli", "gemini_cli"]
+          }
+        }
+      },
+      "outputSchema": {
+        "type": "object",
+        "properties": {
+          "success": {
+            "type": "boolean",
+            "description": "Whether detection was successful"
+          },
+          "results": {
+            "type": "object",
+            "description": "Detection results for each provider",
+            "additionalProperties": {
+              "type": "object",
+              "properties": {
+                "available": {
+                  "type": "boolean",
+                  "description": "Whether CLI is available"
+                },
+                "authenticated": {
+                  "type": "boolean",
+                  "description": "Whether CLI is authenticated"
+                },
+                "version": {
+                  "type": "string",
+                  "description": "CLI version if available"
+                },
+                "path": {
+                  "type": "string",
+                  "description": "Path to CLI executable"
+                },
+                "error": {
+                  "type": "string",
+                  "description": "Error message if detection failed"
+                }
+              }
+            }
+          },
+          "message": {
+            "type": "string",
+            "description": "Human-readable result message"
+          },
+          "timestamp": {
+            "type": "string",
+            "description": "Detection timestamp"
+          }
+        },
+        "required": ["success", "results", "message", "timestamp"]
+      },
+      "examples": [
+        {
+          "description": "Detect all CLI providers",
+          "input": {
+            "user_id": "user_123"
+          },
+          "output": {
+            "success": true,
+            "results": {
+              "claude_code": {
+                "available": true,
+                "authenticated": true,
+                "version": "claude-code v1.2.3",
+                "path": "/usr/local/bin/claude"
+              },
+              "codex_cli": {
+                "available": false,
+                "authenticated": false,
+                "error": "Codex CLI not found in PATH. Install Codex CLI from OpenAI"
+              }
+            },
+            "message": "CLI detection completed for all providers",
+            "timestamp": "2024-01-15T10:30:00Z"
+          }
+        }
+      ]
+    },
+    {
+      "name": "get_cli_status",
+      "description": "Get current CLI status with caching support. Returns cached results if available and fresh, otherwise performs new detection.",
+      "inputSchema": {
+        "type": "object",
+        "properties": {
+          "user_id": {
+            "type": "string",
+            "description": "User ID for database status retrieval (optional for stdio-wrapper)",
+            "minLength": 1
+          },
+          "provider_id": {
+            "type": "string",
+            "description": "Specific CLI provider status to get (optional, gets all if not provided)",
+            "enum": ["claude_code", "codex_cli", "gemini_cli"]
+          }
+        }
+      },
+      "outputSchema": {
+        "type": "object",
+        "properties": {
+          "success": {
+            "type": "boolean",
+            "description": "Whether status retrieval was successful"
+          },
+          "results": {
+            "type": "object",
+            "description": "Status results for each provider",
+            "additionalProperties": {
+              "type": "object",
+              "properties": {
+                "available": {
+                  "type": "boolean"
+                },
+                "authenticated": {
+                  "type": "boolean"
+                },
+                "version": {
+                  "type": "string"
+                },
+                "lastChecked": {
+                  "type": "string",
+                  "description": "Last status check timestamp"
+                }
+              }
+            }
+          },
+          "message": {
+            "type": "string"
+          },
+          "timestamp": {
+            "type": "string"
+          }
+        },
+        "required": ["success", "results"]
+      }
+    },
+    {
+      "name": "send_cli_prompt",
+      "description": "Send a prompt to a CLI provider and get response. Supports both stdin and argument modes for maximum compatibility.",
+      "inputSchema": {
+        "type": "object",
+        "properties": {
+          "provider_id": {
+            "type": "string",
+            "description": "CLI provider to send prompt to",
+            "enum": ["claude_code", "codex_cli", "gemini_cli"]
+          },
+          "prompt": {
+            "type": "string",
+            "description": "Prompt to send to the CLI",
+            "minLength": 1
+          },
+          "mode": {
+            "type": "string",
+            "description": "Prompt sending mode",
+            "enum": ["stdin", "args"],
+            "default": "args"
+          },
+          "timeout_ms": {
+            "type": "integer",
+            "description": "Timeout in milliseconds (90 seconds default for CLI-within-CLI scenarios)",
+            "minimum": 1000,
+            "maximum": 600000,
+            "default": 90000
+          },
+          "user_id": {
+            "type": "string",
+            "description": "User ID for usage tracking (optional)",
+            "minLength": 1
+          }
+        },
+        "required": ["prompt"]
+      },
+      "outputSchema": {
+        "type": "object",
+        "properties": {
+          "success": {
+            "type": "boolean",
+            "description": "Whether the prompt was sent successfully"
+          },
+          "content": {
+            "type": "string",
+            "description": "CLI response content"
+          },
+          "error": {
+            "type": "string",
+            "description": "Error message if prompt failed"
+          },
+          "tokens_used": {
+            "type": "integer",
+            "description": "Number of tokens used"
+          },
+          "latency_ms": {
+            "type": "integer",
+            "description": "Response latency in milliseconds"
+          },
+          "provider": {
+            "type": "string",
+            "description": "CLI provider used"
+          },
+          "mode": {
+            "type": "string",
+            "description": "Mode used for sending"
+          },
+          "timestamp": {
+            "type": "string",
+            "description": "Response timestamp"
+          }
+        },
+        "required": ["success", "provider", "timestamp"]
+      },
+      "examples": [
+        {
+          "description": "Send prompt to Claude Code",
+          "input": {
+            "provider_id": "claude_code",
+            "prompt": "Help me debug this TypeScript error: Property 'map' does not exist on type 'string'",
+            "mode": "args",
+            "user_id": "user_123"
+          },
+          "output": {
+            "success": true,
+            "content": "This error occurs when you're trying to use the .map() method on a string variable. The .map() method is an array method, not a string method...",
+            "tokens_used": 150,
+            "latency_ms": 1200,
+            "provider": "claude_code",
+            "mode": "args",
+            "timestamp": "2024-01-15T10:35:00Z"
+          }
+        }
+      ]
+    },
     {
       "name": "enable_status_reporting",
       "description": "Enable automatic CLI status reporting to polydev.ai server. Reports are sent when CLI detection runs and via periodic heartbeat. Requires a Polydev user token.",

package/mcp/stdio-wrapper.js

@@ -35,7 +35,7 @@ if (typeof globalThis.fetch === 'undefined') {
       });
 
       req.on('error', reject);
-      req.setTimeout(240000, () => { req.destroy(); reject(new Error('Request timed out')); });
+      req.setTimeout(400000, () => { req.destroy(); reject(new Error('Request timed out')); });
       if (options.body) req.write(options.body);
       req.end();
     });
@@ -308,7 +308,7 @@ class StdioMCPWrapper {
     this.clientInfo = null;
 
     // Adaptive timeout tracking: stores recent response times per CLI
-    // Used to set smarter timeouts instead of fixed 240s
+    // Used to set smarter timeouts instead of fixed 400s
     this.cliResponseTimes = {}; // { cliId: [latency_ms, ...] }
     this.CLI_RESPONSE_HISTORY_SIZE = 5; // Keep last 5 response times
     this.loadCliResponseTimes(); // Load from disk
@@ -453,11 +453,7 @@ Token will be saved automatically after login.`
           }
           
           // Handle get_perspectives with local CLIs + remote perspectives
-          // Also redirect send_cli_prompt → get_perspectives for backward compat
-          // (send_cli_prompt was removed from tool list to prevent AI models from choosing it
-          //  over get_perspectives, but old clients may still call it)
-          if (toolName === 'get_perspectives' || toolName === 'polydev.get_perspectives' ||
-              toolName === 'send_cli_prompt' || toolName === 'polydev.send_cli_prompt') {
+          if (toolName === 'get_perspectives' || toolName === 'polydev.get_perspectives') {
             return await this.handleGetPerspectivesWithCLIs(params, id);
           }
           
@@ -648,7 +644,7 @@ To authenticate, use one of these methods:
       // if this process dies, the new one can resume polling with same session)
       this.startLoginPolling(sessionId);
       
-      // Wait for authentication to complete (blocks up to 120s)
+      // Wait for authentication to complete (blocks up to 400s)
       console.error('[Polydev] Waiting for browser authentication to complete...');
       const authenticated = await this.waitForAuthCompletion();
       
@@ -725,10 +721,10 @@ Still waiting for login. Use /polydev:auth to check status after signing in.`
   /**
    * Wait for authentication to complete by polling this.isAuthenticated
    * Used to block tool calls until login is detected by startLoginPolling
-   * @param {number} timeoutMs - Max time to wait (default 120s)
+   * @param {number} timeoutMs - Max time to wait (default 400s)
    * @returns {boolean} true if authenticated, false if timed out
    */
-  async waitForAuthCompletion(timeoutMs = 120000) {
+  async waitForAuthCompletion(timeoutMs = 400000) {
     const pollInterval = 3000; // Check every 3 seconds
     const maxPolls = Math.floor(timeoutMs / pollInterval);
     
@@ -817,7 +813,7 @@ Dashboard: https://polydev.ai/dashboard`
 
   /**
    * Trigger re-authentication by opening browser and starting polling
-   * Waits for auth to complete inline (up to 120s) then returns full status
+   * Waits for auth to complete inline (up to 400s) then returns full status
    * Used when token is detected as invalid/expired
    * @param {*} id - JSON-RPC request id
    * @param {string} reason - Human-readable reason for re-auth
@@ -883,7 +879,7 @@ To authenticate, pass your token directly:
       this.savePendingSession(sessionId);
       this.startLoginPolling(sessionId);
 
-      // Wait for authentication to complete (blocks up to 120s)
+      // Wait for authentication to complete (blocks up to 400s)
       console.error('[Polydev] Waiting for browser authentication to complete...');
       const authenticated = await this.waitForAuthCompletion();
       
@@ -1100,10 +1096,11 @@ To authenticate, pass your token directly:
           perspectivesSection += ` (${perspectiveCount} active)`;
           
           // Show providers in order with their selected models
-          for (const p of modelPrefs.allProviders) {
+          for (let i = 0; i < modelPrefs.allProviders.length; i++) {
+            const p = modelPrefs.allProviders[i];
             const providerName = p.provider.charAt(0).toUpperCase() + p.provider.slice(1);
             const source = p.cliId ? 'CLI' : (p.tier ? `Credits/${p.tier}` : 'API');
-            perspectivesSection += `\n  ${providerName.padEnd(12)} ${p.model} [${source}]`;
+            perspectivesSection += `\n  ${i + 1}. ${providerName.padEnd(12)} ${p.model} [${source}]`;
           }
         } else {
           perspectivesSection += '\n  (none configured - using defaults)';
@@ -1575,7 +1572,7 @@ To re-login: /polydev:login`
     try {
       // Use AbortController for timeout if available, otherwise rely on fetch timeout
       const controller = typeof AbortController !== 'undefined' ? new AbortController() : null;
-      const timeoutId = controller ? setTimeout(() => controller.abort(), 240000) : null; // 240s timeout
+      const timeoutId = controller ? setTimeout(() => controller.abort(), 400000) : null; // 400s timeout
 
       const response = await fetch('https://www.polydev.ai/api/mcp', {
         method: 'POST',
@@ -1633,8 +1630,10 @@ To re-login: /polydev:login`
     const cliTools = [
       'force_cli_detection',
       'get_cli_status', 
+      'send_cli_prompt',
       'polydev.force_cli_detection',
-      'polydev.get_cli_status'
+      'polydev.get_cli_status', 
+      'polydev.send_cli_prompt'
     ];
     return cliTools.includes(toolName);
   }
@@ -1722,6 +1721,11 @@ To re-login: /polydev:login`
           result = await this.localGetCliStatus(args);
           break;
         
+        case 'send_cli_prompt':
+        case 'polydev.send_cli_prompt':
+          result = await this.localSendCliPrompt(args);
+          break;
+        
         default:
           throw new Error(`Unknown CLI tool: ${toolName}`);
       }
@@ -1885,19 +1889,19 @@ To re-login: /polydev:login`
     console.error(`[Stdio Wrapper] Local CLI prompt sending with perspectives`);
     
     try {
-      let { provider_id, prompt, mode = 'args', timeout_ms = 240000 } = args;
+      let { provider_id, prompt, mode = 'args', timeout_ms = 400000 } = args;
       
       // Ensure timeout_ms is valid (not undefined, null, Infinity, or negative)
-      // Default to 4 minutes (240 seconds) for complex CLI responses
+      // Default to 400 seconds for complex CLI responses
       if (!timeout_ms || timeout_ms === Infinity || timeout_ms < 1 || timeout_ms > 600000) {
-        timeout_ms = 240000; // Default to 4 minutes for CLI responses
+        timeout_ms = 400000; // Default to 400 seconds for CLI responses
       }
       
       if (!prompt) {
         throw new Error('prompt is required');
       }
 
-      // Use configured timeout but cap at 10 minutes max for safety
+      // Use configured timeout but cap at 400s max for safety
       const gracefulTimeout = Math.min(timeout_ms, 600000);
 
       // Fetch user's model preferences (cached, non-blocking on failure)
@@ -2046,7 +2050,7 @@ To re-login: /polydev:login`
               if (model) {
                 console.error(`[Stdio Wrapper] Using model for ${providerEntry.cliId}: ${model}`);
               }
-              // Use adaptive timeout based on historical response times (instead of fixed 240s)
+              // Use adaptive timeout based on historical response times (instead of fixed 400s)
               const cliTimeout = this.getAdaptiveTimeout(providerEntry.cliId, gracefulTimeout);
               let result = await this.cliManager.sendCliPrompt(providerEntry.cliId, prompt, mode, cliTimeout, model);
 
@@ -2458,7 +2462,7 @@ To re-login: /polydev:login`
             user_token: this.userToken,
             // Exclude providers that succeeded locally
             exclude_providers: excludeProviders,
-            // NEW: Specific providers to request (from API-only providers)
+            // NEW: Specific providers to request (from API-only list)
             request_providers: requestProviders.length > 0 ? requestProviders : undefined,
             // Pass CLI responses for dashboard logging
             cli_responses: cliResponses,
@@ -2520,6 +2524,9 @@ To re-login: /polydev:login`
     }
   }
 
+  /**
+   * Combine multiple CLI results and remote perspectives
+   */
   combineAllCliAndPerspectives(localResults, perspectivesResult, args) {
     // Ensure perspectivesResult is always an object to prevent undefined errors
     const safePersp = perspectivesResult || { success: false, error: 'No response from perspectives server' };
@@ -2565,8 +2572,8 @@ To re-login: /polydev:login`
       if (safePersp.raw) {
         // Raw content is already formatted - use as-is
         formatted += `${safePersp.content}\n\n`;
-      } else if (!safePersp.skipped) {
-        // Legacy formatting (only if not skipped — skipped means CLIs filled all slots)
+      } else {
+        // Legacy formatting
         const title = (successfulClis.length === 0) ? 'Perspectives Fallback' : 'Supplemental Multi-Model Perspectives';
         formatted += `${title}\n\n`;
         formatted += `${safePersp.content}\n\n`;
@@ -2576,10 +2583,6 @@ To re-login: /polydev:login`
       formatted += `❌ Perspectives request failed: ${safePersp.error || 'Unknown error'}\n\n`;
     }
 
-    // Strip "LOGIN SUCCESSFUL" banner that leaks from remote server responses
-    // It gets appended to perspective results and pollutes the output
-    formatted = formatted.replace(/\n*LOGIN SUCCESSFUL\n={4,}\n[\s\S]*?Dashboard:.*(\n|$)/g, '');
-
     return formatted.trim();
   }
 
@@ -2710,16 +2713,16 @@ To re-login: /polydev:login`
 
   /**
    * Get adaptive timeout for a CLI based on historical response times
-   * Returns timeout in ms (2.5x the average, with min 30s and max 240s)
+   * Returns timeout in ms (2.5x the average, with min 30s and max 400s)
    */
-  getAdaptiveTimeout(cliId, defaultTimeout = 240000) {
+  getAdaptiveTimeout(cliId, defaultTimeout = 400000) {
     const times = this.cliResponseTimes[cliId];
     if (!times || times.length === 0) {
       return defaultTimeout; // No history, use default
     }
     const avg = times.reduce((a, b) => a + b, 0) / times.length;
-    // 2.5x average, clamped between 30s and 240s
-    const adaptive = Math.min(240000, Math.max(30000, Math.round(avg * 2.5)));
+    // 2.5x average, clamped between 30s and 400s
+    const adaptive = Math.min(400000, Math.max(30000, Math.round(avg * 2.5)));
     console.error(`[Stdio Wrapper] Adaptive timeout for ${cliId}: ${adaptive}ms (avg: ${Math.round(avg)}ms from ${times.length} samples)`);
     return adaptive;
   }
@@ -2897,6 +2900,25 @@ To re-login: /polydev:login`
       } else {
         return `CLI Response (${result.provider || 'Unknown'} - ${result.mode || 'unknown'} mode)\n\n${result.content}\n\nLatency: ${result.latency_ms || 0}ms | Tokens: ${result.tokens_used || 0} | ${result.timestamp}`;
       }
+    } else {
+      // Status/detection response
+      let formatted = `CLI Operation Success\n\n`;
+      formatted += `${result.message}\n\n`;
+      
+      if (result.results) {
+        formatted += `Results:\n`;
+        for (const [providerId, status] of Object.entries(result.results)) {
+          const icon = status.available ? '[+]' : '[-]';
+          const authStatus = status.authenticated ? '[auth]' : '[no-auth]';
+          formatted += `- ${icon} ${authStatus} ${providerId}: ${status.available ? 'Available' : 'Not Available'}`;
+          if (status.version) formatted += ` (${status.version})`;
+          if (status.error) formatted += ` - ${status.error}`;
+          formatted += `\n`;
+        }
+      }
+      
+      formatted += `\n${result.local_only ? 'Local execution' : 'Remote execution'} | ${result.timestamp}`;
+      return formatted;
     }
   }
 
@@ -2941,7 +2963,7 @@ To re-login: /polydev:login`
         this.userModelPreferences = result.modelPreferences;
         this.modelPreferencesCacheTime = Date.now();
         
-        // Also cache perspectivesPerMessage setting (default 2)
+        // Also cache perspectives_per_message setting (default 2)
         this.perspectivesPerMessage = result.perspectivesPerMessage || 2;
         
         // Cache provider order from user's dashboard (respects display_order)
@@ -3119,7 +3141,6 @@ To re-login: /polydev:login`
         return this.localForceCliDetection({});
       }).then(() => {
         this._cliDetectionComplete = true;
-        // Display CLI status after detection
         return this.displayCliStatus();
       }).catch((error) => {
         console.error('[Polydev] Auto-login flow error:', error.message);
@@ -3395,6 +3416,37 @@ function createSandboxServer() {
           required: ['prompt']
         }
       },
+      {
+        name: 'get_cli_status',
+        description: 'Check status of local CLI tools (Claude Code, Codex CLI, Gemini CLI)',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            provider_id: {
+              type: 'string',
+              description: 'Optional specific provider to check'
+            }
+          }
+        }
+      },
+      {
+        name: 'force_cli_detection',
+        description: 'Force re-detection of installed local CLI tools',
+        inputSchema: { type: 'object', properties: {} }
+      },
+      {
+        name: 'send_cli_prompt',
+        description: 'Send prompt to local CLI with perspectives fallback',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            provider_id: { type: 'string', description: 'CLI provider ID' },
+            prompt: { type: 'string', description: 'Prompt to send' },
+            mode: { type: 'string', enum: ['args', 'stdin'], default: 'args' }
+          },
+          required: ['provider_id', 'prompt']
+        }
+      }
     ]
   };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "polydev-ai",
-  "version": "1.9.24",
+  "version": "1.9.26",
   "engines": {
     "node": ">=20.x <=22.x"
   },