scalix 1.2.0 → 1.4.0

package/CHANGELOG.md

@@ -2,6 +2,33 @@
 
 All notable changes to Scalix Coder will be documented in this file.
 
+## [1.4.0] - 2026-07-05
+
+### Added
+- Scalix Cloud platform tools in the agent — your account's MCP catalog (`GET /api/v1/mcp`, scope-filtered per key) is fetched on start and registered as first-class function tools, executed via `POST /api/v1/mcp/call` with your own API key. Deploys, database queries, storage, functions and more become plain agent prompts
+- `/cloud` command — `/cloud status` (identity, plan, limits, tool count), `/cloud tools` (available `scalix_*` tools grouped by platform area), `/cloud refresh` (re-fetch identity + catalog)
+- `/login` command — links your Scalix account through the setup wizard
+- Connected onboarding — the setup wizard validates the API key against `GET /v1/me` and shows a "Connected to Scalix Cloud" panel (org, project, plan, rate limit, platform tools unlocked) with a re-enter/skip choice on failure; a "Try:" block with real platform prompts appears after a successful connect
+- Welcome/status line reflects the real connection: `☁ Scalix Cloud · <plan> · <N> platform tools` when connected, `☁ not connected — /login to link your Scalix account` otherwise
+- `SCALIX_PROJECT` env var — sent as `x-scalix-project` on catalog/tool calls to scope an org-wide key to one project
+
+### Changed
+- When the catalog is unreachable or no key is configured, the agent states it once and runs with local tools only — availability is never fabricated and there is no retry loop. Tool counts in the status bar and headless banner include only tools that actually loaded
+
+## [1.3.3] - 2026-07-05
+
+### Fixed
+- API endpoints aligned to the Scalix gateway's `/v1/ai` nest: chat completions now POST to `/v1/ai/chat/completions` and the model list is fetched from `GET /v1/ai/models` (OpenAI-style `{data: [...]}`). The default base URL is now the host root `https://api.scalix.world`; a trailing `/v1` in existing configs is still accepted and normalized
+- Voice input calls the single canonical `/v1/ai/audio/transcriptions` path and reports plainly when transcription isn't available on the deployment, instead of probing two dead endpoints
+- Web search no longer calls a non-existent platform research endpoint; it states that web research isn't available via the Scalix API yet and uses the configured search providers (Brave/Tavily/DuckDuckGo)
+- Sandbox no longer falsely blocks file access when the working directory sits behind a symlink (e.g. macOS temp dirs): symlink containment now compares real paths on both sides
+- `User-Agent` header carries the real package version instead of a hardcoded `1.0`
+
+### Changed
+- Model examples and defaults use current Scalix model names (`scalix-lumio-*`); the retired `scalix-world-ai` id removed from UI text and defaults
+- Model list UI no longer shows tier/provider columns (the API does not expose them)
+- README version badge matches the released package version
+
 ## [3.1.0] - 2026-04-20
 
 ### Added

package/README.md

@@ -2,11 +2,19 @@
 
 AI-powered coding agent for the terminal and VS Code — built by [Scalix World](https://scalix.world).
 
-![Version](https://img.shields.io/badge/version-1.0.0-blue)
+![Version](https://img.shields.io/badge/version-1.4.0-blue)
 ![Node](https://img.shields.io/badge/node-%3E%3D18-green)
 ![License](https://img.shields.io/badge/license-EULA-orange)
 
-Scalix Coder is a full-featured AI coding assistant that runs in your terminal or as a VS Code extension. It connects to the Scalix API (or any OpenAI-compatible endpoint) and gives AI direct access to your codebase through 31 built-in tools — file editing, shell execution, search, git, web access, browser automation, vision, voice input, and more.
+Scalix Coder is a full-featured AI coding assistant that runs in your terminal or as a VS Code extension. It connects to the Scalix API (or your own compatible endpoint) and gives AI direct access to your codebase through 31 built-in tools — file editing, shell execution, search, git, web access, browser automation, vision, voice input, and more.
+
+## One agent for your whole cloud
+
+With a Scalix account, the agent is more than a coder: on start it fetches your account's platform tool catalog and registers every tool your API key's scopes unlock — databases, deployments (Scalix Run), storage, functions, cron, domains, and more. "Deploy this app", "create a table and seed it", "upload dist/ to a bucket" become plain prompts.
+
+- Tools reflect **your key's scopes** — the catalog is filtered server-side, and mutating tools are refused for read-only keys
+- `/cloud` shows your connection, plan, and available tools; `/cloud refresh` re-fetches the catalog
+- No account (or catalog unreachable)? The agent says so once and runs in **local-only mode** with the built-in tools — nothing is faked
 
 ## Features
 
@@ -55,6 +63,7 @@ First launch opens a setup wizard to configure your Scalix API key, endpoint, an
 | `SCALIX_API_KEY`  | API key (overrides saved config) |
 | `SCALIX_MODEL`    | Comma-separated model IDs        |
 | `SCALIX_BASE_URL` | API base URL                     |
+| `SCALIX_PROJECT`  | Project ID for org-wide keys (sent as `x-scalix-project` on platform tool calls) |
 | `BRAVE_API_KEY`   | Brave Search API key             |
 | `TAVILY_API_KEY`  | Tavily Search API key            |
 
@@ -90,6 +99,8 @@ scalix run "generate a migration" --output migration.sql --format patch
 | `/replay`          | Session timeline             |
 | `/plugins`         | Loaded plugins               |
 | `/settings`        | Configure limits             |
+| `/cloud`           | Scalix Cloud status, platform tools & refresh |
+| `/login`           | Link your Scalix account     |
 | `/setup`           | Reconfigure API key & models |
 | `/delegate <task>` | Run with sub-agent           |
 | `/checkpoint`      | Create git checkpoint        |

package/bin/scalix.js

@@ -8,6 +8,14 @@ const __dirname = dirname(fileURLToPath(import.meta.url));
 process.env.NODE_ENV = 'production';
 
 const args = process.argv.slice(2);
+
+if (args.includes('--version') || args.includes('-v')) {
+  const { readFileSync } = await import('node:fs');
+  const pkg = JSON.parse(readFileSync(resolve(__dirname, '..', 'package.json'), 'utf-8'));
+  console.log(pkg.version);
+  process.exit(0);
+}
+
 const needsHeadless =
   args.includes('run') ||
   args.includes('--pipe') || args.includes('-p') ||

package/dist/agent.js

@@ -1,9 +1,9 @@
-import { ScalixClient } from './api-client.js';
+import { ScalixClient, ApiError } from './api-client.js';
 import { EventEmitter } from 'eventemitter3';
 import { randomUUID } from 'node:crypto';
-import { getToolPermission } from './sandbox.js';
+import { getToolPermissionWithArgs } from './sandbox.js';
 import { logger } from './logger.js';
-import { DEFAULT_MODELS as FALLBACK_MODELS, DEFAULT_INSTRUCTIONS, AGENT_DEFAULTS, TOOL_DEFAULTS, BACKOFF_DEFAULTS, modelSupportsVision, getModelSpec } from './constants.js';
+import { DEFAULT_MODELS as FALLBACK_MODELS, DEFAULT_INSTRUCTIONS, DEFAULT_BASE_URL, AGENT_DEFAULTS, TOOL_DEFAULTS, BACKOFF_DEFAULTS, modelSupportsVision, getModelSpec } from './constants.js';
 import { estimateMessageTokens as estimateTokenCount } from './token-counter.js';
 import { ContextManager } from './context-manager.js';
 import { zodToJsonSchema } from './tool-helper.js';
@@ -19,8 +19,13 @@ import { extractCodeClaims, checkGrounding, formatGroundingNudge, GROUNDING_DEFA
 import { RETRIEVAL_DEFAULTS } from './context-retriever.js';
 import fs from 'node:fs/promises';
 import path from 'node:path';
+import { fetchCloudTools, callCloudTool } from './cloud.js';
 function transformToolsForApi(tools) {
     return tools
+        // type:'mcp' entries are decorative config for user-registered external
+        // MCP servers and never reach the API. Scalix Cloud platform tools bypass
+        // this path entirely: they are plain function tools (CloudPlatformTool,
+        // registered by refreshCloudTools) whose `parameters` pass through as-is.
         .filter((t) => !('type' in t && t.type === 'mcp'))
         .map((t) => {
         const local = t;
@@ -156,12 +161,16 @@ export class Agent extends EventEmitter {
     groundingConfig = null;
     groundingNudgeCount = 0;
     retrievalConfig = null;
+    _sending = false;
+    outputFormatInstructionIndex = null;
+    cloudProjectId;
+    cloudStatus = { state: 'no-key', toolCount: 0 };
     constructor(config) {
         super();
         this.agentId = config.agentId ?? generateAgentId();
         this.parentAgentId = config.parentAgentId ?? null;
         this.agentDescription = config.agentDescription ?? 'main';
-        this.client = new ScalixClient(config.baseUrl || 'https://api.scalix.world/v1', config.apiKey);
+        this.client = new ScalixClient(config.baseUrl || DEFAULT_BASE_URL, config.apiKey);
         this.log = logger.child();
         const resolvedModels = Array.isArray(config.model)
             ? (config.model.length > 0 ? config.model : FALLBACK_MODELS)
@@ -185,7 +194,9 @@ export class Agent extends EventEmitter {
             circuitBreakerResetMs: config.circuitBreakerResetMs ?? AGENT_DEFAULTS.circuitBreakerResetMs,
             fileRefTruncation: config.fileRefTruncation ?? TOOL_DEFAULTS.fileRefTruncation,
             thinkingMode: config.thinkingMode ?? 'off',
+            workspaceRoot: config.workspaceRoot ?? process.cwd(),
         };
+        this.cloudProjectId = config.cloudProjectId ?? process.env.SCALIX_PROJECT ?? undefined;
         this.contextManager = new ContextManager(config.contextManager);
         if (config.dynamicToolSelection) {
             this.toolSelector = new ToolSelector();
@@ -252,22 +263,22 @@ export class Agent extends EventEmitter {
     shouldFallbackToNext(err) {
         const e = err;
         const message = (e?.message || e?.error?.message || '').toLowerCase();
-        const statusCode = e?.status || e?.statusCode || e?.error?.code;
-        if (statusCode === 401 || statusCode === 403 || message.includes('unauthorized') || message.includes('forbidden') || message.includes('invalid api key')) {
+        // Prefer the structured status carried by ApiError; fall back to other shapes.
+        const status = err instanceof ApiError ? err.status : (e?.status ?? e?.statusCode ?? e?.error?.code);
+        if (status === 401 || status === 403 || message.includes('unauthorized') || message.includes('forbidden') || message.includes('invalid api key')) {
             return false;
         }
+        // Retry/fallback on transient upstream statuses.
+        if (status === 429 || status === 500 || status === 502 || status === 503 || status === 408 || status === 404) {
+            return true;
+        }
         return (message.includes('429') ||
             message.includes('rate limit') ||
             message.includes('provider returned error') ||
             message.includes('safety') ||
             message.includes('streaming failed') ||
             message.includes('stream error') ||
-            message.includes('try again') ||
-            statusCode === 429 ||
-            statusCode === 500 ||
-            statusCode === 502 ||
-            statusCode === 503 ||
-            statusCode === 404);
+            message.includes('try again'));
     }
     isModelCircuitOpen(model) {
         const state = this.modelFailures.get(model);
@@ -294,6 +305,10 @@ export class Agent extends EventEmitter {
         const keepCount = Math.floor(this.config.maxMessages * this.config.messageKeepRatio);
         const dropped = this.messages.length - keepCount;
         this.messages = this.messages.slice(dropped);
+        // Drop leading orphan tool messages — a tool result whose preceding
+        // assistant tool_call was sliced away would be rejected by the API.
+        while (this.messages[0]?.role === 'tool')
+            this.messages.shift();
         this.log.info(`Truncated ${dropped} oldest messages, keeping ${this.messages.length}`);
     }
     emitThinkingEnd() {
@@ -331,7 +346,7 @@ export class Agent extends EventEmitter {
                 model,
                 messages: apiMessages,
                 stream: false,
-            });
+            }, this._abortController?.signal);
             const summary = result.choices?.[0]?.message?.content?.trim() || '';
             if (!summary)
                 return 'Compaction failed: no summary generated.';
@@ -386,7 +401,7 @@ export class Agent extends EventEmitter {
                     { role: 'user', content: prompt },
                 ],
                 stream: false,
-            });
+            }, this._abortController?.signal);
             const summary = result.choices?.[0]?.message?.content?.trim() || '';
             if (summary) {
                 this.messages = [
@@ -415,6 +430,82 @@ export class Agent extends EventEmitter {
         if (this.toolSelector)
             this.toolSelector.index(this.config.tools);
     }
+    // ─── Scalix Cloud platform tools ───
+    isCloudTool(t) {
+        return 'source' in t && t.source === 'scalix-cloud';
+    }
+    /** Build a first-class function tool from a catalog entry. The server's JSON
+     *  Schema is passed to the model as-is via `parameters` (NOT `inputSchema`,
+     *  which transformToolsForApi would run through the Zod converter). */
+    makeCloudTool(ct) {
+        const baseUrl = this.client.baseURL;
+        const apiKey = this.config.apiKey;
+        const projectId = this.cloudProjectId;
+        return {
+            source: 'scalix-cloud',
+            name: ct.name,
+            description: ct.description,
+            parameters: ct.inputSchema,
+            execute: async (args) => {
+                const result = await callCloudTool(baseUrl, apiKey, ct.name, args ?? {}, projectId);
+                // Tool-level failures are tool results the model can react to, not
+                // exceptions — the "Error: " prefix is the model-facing signal.
+                return result.ok ? result.text : `Error: ${result.text}`;
+            },
+        };
+    }
+    /**
+     * Fetch the account's Scalix Cloud tool catalog and register every returned
+     * tool as a first-class function tool. Called on agent start and on demand
+     * (/cloud refresh). On failure the previously registered cloud tools are
+     * removed and the agent keeps running with local tools only — the returned
+     * status carries the real error for a single honest notice; no retries.
+     */
+    async refreshCloudTools() {
+        if (!this.config.apiKey) {
+            this.config.tools = this.config.tools.filter((t) => !this.isCloudTool(t));
+            this.cloudStatus = { state: 'no-key', toolCount: 0 };
+            return { ...this.cloudStatus };
+        }
+        try {
+            const catalog = await fetchCloudTools(this.client.baseURL, this.config.apiKey, this.cloudProjectId);
+            this.config.tools = this.config.tools.filter((t) => !this.isCloudTool(t));
+            const localNames = new Set(this.config.tools.map((t) => t.function?.name || t.name).filter(Boolean));
+            let registered = 0;
+            for (const ct of catalog.tools) {
+                if (localNames.has(ct.name)) {
+                    this.log.warn('Cloud tool name collides with a local tool — keeping the local tool', { tool: ct.name });
+                    continue;
+                }
+                this.config.tools.push(this.makeCloudTool(ct));
+                registered++;
+            }
+            if (this.toolSelector)
+                this.toolSelector.index(this.config.tools);
+            this.cloudStatus = {
+                state: 'connected',
+                toolCount: registered,
+                platformAvailable: catalog.platformAvailable,
+            };
+        }
+        catch (err) {
+            this.config.tools = this.config.tools.filter((t) => !this.isCloudTool(t));
+            if (this.toolSelector)
+                this.toolSelector.index(this.config.tools);
+            this.cloudStatus = { state: 'unavailable', toolCount: 0, error: err?.message || String(err) };
+            this.log.warn('Scalix Cloud tool catalog unavailable', { error: this.cloudStatus.error });
+        }
+        return { ...this.cloudStatus };
+    }
+    getCloudToolsStatus() {
+        return { ...this.cloudStatus };
+    }
+    getCloudTools() {
+        return this.config.tools.filter((t) => this.isCloudTool(t));
+    }
+    getCloudProjectId() {
+        return this.cloudProjectId;
+    }
     addModel(model) {
         if (!this.config.models.includes(model))
             this.config.models.push(model);
@@ -451,6 +542,9 @@ export class Agent extends EventEmitter {
     deregisterFromRegistry(status) {
         if (!this.registeredInRegistry)
             return;
+        // Reset so a fresh send() re-registers, and guard against double-deregister
+        // (e.g. an aborted turn followed by the send() catch/finally path).
+        this.registeredInRegistry = false;
         AgentRegistry.getInstance().deregister(this.agentId, status);
     }
     checkInbox() {
@@ -540,7 +634,15 @@ export class Agent extends EventEmitter {
         else {
             instruction = 'IMPORTANT: Your final response MUST be valid JSON. Do not include any text outside the JSON object. No markdown code fences, no explanation — only the raw JSON.';
         }
+        // Inject the format instruction only once per session — refresh the existing
+        // system message in place if it's still valid, otherwise append once.
+        const existing = this.outputFormatInstructionIndex;
+        if (existing !== null && this.messages[existing]?.role === 'system') {
+            this.messages[existing] = { role: 'system', content: instruction };
+            return;
+        }
         this.messages.push({ role: 'system', content: instruction });
+        this.outputFormatInstructionIndex = this.messages.length - 1;
     }
     extractJsonFromResponse(response) {
         const trimmed = response.trim();
@@ -868,7 +970,28 @@ export class Agent extends EventEmitter {
                                 continue;
                             }
                         }
-                        const permission = getToolPermission(call.name, this.config.permissionMode);
+                        // Parse tool arguments once, up front, so the permission decision,
+                        // the confirmation prompt, and execution all see the same values.
+                        let parsedArgs;
+                        const rawArgs = (call.arguments ?? '').trim();
+                        if (rawArgs === '') {
+                            parsedArgs = {};
+                        }
+                        else {
+                            try {
+                                parsedArgs = JSON.parse(call.arguments);
+                            }
+                            catch {
+                                result = { error: 'Malformed JSON arguments — resend the tool call with valid JSON' };
+                                reqLog.warn('Malformed tool arguments', { tool: call.name });
+                                this.emit('tool:blocked', call.name, 'Malformed arguments');
+                                this.messages.push({ role: 'tool', content: JSON.stringify(result), tool_call_id: call.id, name: call.name });
+                                this.emit('tool:result', call.name, result);
+                                continue;
+                            }
+                        }
+                        // Args-aware permission so scoped allow/deny rules are enforced.
+                        const permission = getToolPermissionWithArgs(call.name, this.config.permissionMode, parsedArgs);
                         if (permission === 'block') {
                             result = { denied: true, message: `Tool ${call.name} is blocked in ${this.config.permissionMode} mode` };
                             reqLog.info('Tool blocked by permission mode', { tool: call.name, mode: this.config.permissionMode });
@@ -884,8 +1007,8 @@ export class Agent extends EventEmitter {
                         }
                         if (permission === 'ask') {
                             if (!this.config.confirmToolCall) {
-                                if (this.config.permissionMode === 'auto') {
-                                    reqLog.info('Auto-approving tool (no confirmation handler in auto mode)', { tool: call.name });
+                                if (this.config.permissionMode === 'yolo') {
+                                    reqLog.info('Auto-approving tool (yolo mode, no confirmation handler)', { tool: call.name });
                                 }
                                 else {
                                     result = { denied: true, message: `Tool ${call.name} requires confirmation but no confirmation handler is available` };
@@ -902,13 +1025,7 @@ export class Agent extends EventEmitter {
                                 }
                             }
                             else {
-                                let args;
-                                try {
-                                    args = JSON.parse(call.arguments);
-                                }
-                                catch {
-                                    args = call.arguments;
-                                }
+                                const args = parsedArgs;
                                 const CONFIRM_TIMEOUT_MS = 300_000;
                                 const confirmed = await new Promise((resolve) => {
                                     const timer = setTimeout(() => resolve(false), CONFIRM_TIMEOUT_MS);
@@ -940,20 +1057,19 @@ export class Agent extends EventEmitter {
                         const execFn = tool?.function?.execute ?? tool?.execute;
                         if (tool && typeof execFn === 'function') {
                             try {
-                                let args;
-                                try {
-                                    args = normalizeArgs(JSON.parse(call.arguments));
-                                }
-                                catch {
-                                    args = {};
-                                }
+                                // Cloud platform tools get the raw args: their JSON Schemas are
+                                // authoritative (snake_case) and the gateway validates them —
+                                // injecting camelCase duplicates could fail server-side validation.
+                                const args = tool?.source === 'scalix-cloud'
+                                    ? parsedArgs
+                                    : normalizeArgs(parsedArgs);
                                 reqLog.debug('Executing tool', { tool: call.name });
                                 const toolTimeout = (typeof args?.timeout === 'number' && args.timeout > 0)
                                     ? Math.min(args.timeout, TOOL_DEFAULTS.maxCommandTimeoutMs)
                                     : this.config.toolTimeoutMs;
                                 result = await withTimeout(execFn(args, {
                                     context: {},
-                                    workspaceRoot: process.cwd(),
+                                    workspaceRoot: this.config.workspaceRoot ?? process.cwd(),
                                     permissionMode: this.config.permissionMode,
                                     agentId: this.agentId,
                                     agentConfig: {

package/dist/api-client.js

@@ -1,26 +1,44 @@
+import { USER_AGENT, aiEndpointUrl } from './constants.js';
+export class ApiError extends Error {
+    status;
+    body;
+    constructor(status, statusText, body) {
+        super(`API request failed: ${status} ${statusText}${body ? ` — ${body.slice(0, 200)}` : ''}`);
+        this.name = 'ApiError';
+        this.status = status;
+        this.body = body;
+    }
+}
+const DEFAULT_TIMEOUT_MS = 120_000;
 export class ScalixClient {
     baseURL;
     apiKey;
-    constructor(baseURL, apiKey) {
+    timeoutMs;
+    constructor(baseURL, apiKey, timeoutMs = DEFAULT_TIMEOUT_MS) {
         this.baseURL = baseURL.replace(/\/+$/, '');
         this.apiKey = apiKey;
+        this.timeoutMs = timeoutMs;
     }
     async chatComplete(req, signal) {
-        const url = `${this.baseURL}/chat/completions`;
+        // baseURL is the API host root; the gateway nests AI under /v1/ai.
+        // aiEndpointUrl() also tolerates a legacy base ending in /v1.
+        const url = aiEndpointUrl(this.baseURL, 'chat/completions');
         const body = JSON.stringify(req);
+        const timeoutSignal = AbortSignal.timeout(this.timeoutMs);
+        const combined = signal ? AbortSignal.any([signal, timeoutSignal]) : timeoutSignal;
         const response = await fetch(url, {
             method: 'POST',
             headers: {
                 'Content-Type': 'application/json',
                 'Authorization': `Bearer ${this.apiKey}`,
-                'User-Agent': 'Scalix-Coder/1.0',
+                'User-Agent': USER_AGENT,
             },
             body,
-            signal,
+            signal: combined,
         });
         if (!response.ok) {
             const text = await response.text().catch(() => '');
-            throw new Error(`API request failed: ${response.status} ${response.statusText}${text ? ` — ${text.slice(0, 200)}` : ''}`);
+            throw new ApiError(response.status, response.statusText, text);
         }
         if (req.stream) {
             return this.parseSSEStream(response);
@@ -45,32 +63,52 @@ export class ScalixClient {
                     const trimmed = line.trim();
                     if (!trimmed || trimmed.startsWith(':'))
                         continue;
-                    if (trimmed.startsWith('data: ')) {
-                        const data = trimmed.slice(6);
+                    if (trimmed.startsWith('data:')) {
+                        const data = trimmed.slice(5).replace(/^ /, '');
                         if (data === '[DONE]')
                             return;
+                        let parsed;
                         try {
-                            yield JSON.parse(data);
+                            parsed = JSON.parse(data);
                         }
                         catch {
                             // skip malformed chunks
+                            continue;
+                        }
+                        if (parsed && parsed.error) {
+                            const err = parsed.error;
+                            throw new Error(`Stream error: ${typeof err === 'string' ? err : (err?.message || JSON.stringify(err))}`);
                         }
+                        yield parsed;
                     }
                 }
             }
-            if (buffer.trim().startsWith('data: ')) {
-                const data = buffer.trim().slice(6);
+            const tail = buffer.trim();
+            if (tail.startsWith('data:')) {
+                const data = tail.slice(5).replace(/^ /, '');
                 if (data !== '[DONE]') {
+                    let parsed;
                     try {
-                        yield JSON.parse(data);
+                        parsed = JSON.parse(data);
                     }
                     catch {
                         // skip
                     }
+                    if (parsed) {
+                        if (parsed.error) {
+                            const err = parsed.error;
+                            throw new Error(`Stream error: ${typeof err === 'string' ? err : (err?.message || JSON.stringify(err))}`);
+                        }
+                        yield parsed;
+                    }
                 }
             }
         }
         finally {
+            try {
+                await reader.cancel();
+            }
+            catch { }
             reader.releaseLock();
         }
     }

package/dist/auto-verify.js

@@ -74,7 +74,8 @@ async function detectChecker(filePath, projectRoot) {
         }
         // Verify the tool is available
         try {
-            await execFileAsync('which', [checker.command[0]], { timeout: 3000 });
+            const probe = process.platform === 'win32' ? 'where' : 'which';
+            await execFileAsync(probe, [checker.command[0]], { timeout: 3000, shell: process.platform === 'win32' });
         }
         catch {
             // Tool not installed, skip
@@ -100,6 +101,7 @@ export async function runVerification(filePath, projectRoot, config = VERIFY_DEF
             cwd: projectRoot,
             timeout: config.timeoutMs,
             maxBuffer: 512 * 1024,
+            shell: process.platform === 'win32',
         });
         const output = (stderr || stdout).trim();
         return {