scalix 1.5.1 → 1.5.2

package/.env.example

@@ -1,8 +1,10 @@
 # Required — your Scalix API key
-SCALIX_API_KEY=sk-...
+SCALIX_API_KEY=scalix_sk_...
 
-# Optional — custom API base URL (defaults to Scalix cloud)
-# SCALIX_BASE_URL=https://api.scalix.world/v1
+# Optional — API base URL. This is the host root, NOT the /v1 endpoint: the
+# client appends /v1/ai/... itself. Point it at a self-hosted gateway if you
+# have one; the default is Scalix cloud.
+# SCALIX_BASE_URL=https://api.scalix.world
 
 # Optional — override the default model
 # SCALIX_MODEL=

package/LICENSE

@@ -2,7 +2,6 @@ SCALIX WORLD PRIVATE LIMITED
 END USER LICENSE AGREEMENT (EULA)
 
 Copyright (c) 2025-2026 Scalix World Pvt Ltd. All rights reserved.
-A subsidiary of Energy FW Ltd (UK Company No. 14600160)
 
 IMPORTANT — READ CAREFULLY BEFORE USING THIS SOFTWARE.
 

package/README.md

@@ -2,7 +2,7 @@
 
 AI-powered coding agent for the terminal and [VS Code](https://marketplace.visualstudio.com/items?itemName=scalix.scalix) — built by [Scalix World](https://scalix.world).
 
-![Version](https://img.shields.io/badge/version-1.4.0-blue)
+[![npm](https://img.shields.io/npm/v/scalix?color=blue)](https://www.npmjs.com/package/scalix)
 ![Node](https://img.shields.io/badge/node-%3E%3D18-green)
 ![License](https://img.shields.io/badge/license-EULA-orange)
 
@@ -61,12 +61,28 @@ Notes:
 
 ### Install
 
+```bash
+npm install -g scalix
+```
+
+Requires Node 18 or newer. If `npm install -g` needs `sudo` on your machine, that
+is a sign npm's global prefix points somewhere root-owned — point it at your home
+directory (`npm config set prefix ~/.npm-global`) rather than installing as root.
+
+<details>
+<summary>From source (contributors)</summary>
+
+The repository is private; you need access before this will clone.
+
 ```bash
 git clone https://github.com/scalixworld/scalix-coder.git && cd scalix-coder
 npm install
-sudo npm link
+npm run build
+npm link
 ```
 
+</details>
+
 ### Run
 
 ```bash
@@ -239,6 +255,35 @@ Config is stored in `~/.scalix-coder/config.json`.
 | `.scalix/rules/*.md`    | Scoped rules                  |
 | `mcp-services.json`     | MCP server config             |
 
+### MCP servers
+
+Servers listed in `mcp-services.json` (project root, or `.scalix/` as a
+fallback) are connected at startup and their tools are offered to the model as
+`mcp__<server>__<tool>`. Both transports are supported:
+
+```json
+{
+  "mcpServers": [
+    { "serverLabel": "github", "command": "npx", "args": ["-y", "@modelcontextprotocol/server-github"],
+      "env": { "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_…" } },
+    { "serverLabel": "docs", "serverUrl": "https://docs.example.com/mcp", "authorizationEnv": "DOCS_TOKEN" }
+  ]
+}
+```
+
+The Claude Desktop / VS Code object-map dialect (`"mcpServers": {"github": {…}}`)
+is accepted too, so an existing config can be dropped in unchanged.
+
+- `disabled: true` skips an entry without deleting it; `allowedTools.toolNames`
+  registers only the named tools from that server.
+- A server that fails to start is logged and skipped — it never takes the run
+  down with it. `/mcp` lists the status of each.
+- **Command (stdio) servers only start in a trusted workspace**, because
+  spawning one runs arbitrary local code. They get a clean environment, not the
+  agent's, so they cannot read its API keys.
+- MCP tools are external, so they require confirmation under the default
+  permission mode.
+
 ## VS Code Extension
 
 Install from the [VS Code Marketplace](https://marketplace.visualstudio.com/items?itemName=scalix.scalix) — or from [Open VSX](https://open-vsx.org/extension/scalix/scalix) if you use Cursor, Windsurf, or VSCodium:

package/dist/agent-presets.js

@@ -0,0 +1,33 @@
+export const AGENT_PRESETS = [
+    {
+        id: 'cloud-architect',
+        name: 'Cloud Architect',
+        description: 'Full Scalix Cloud tools access with architecture-first planning',
+        systemPromptAdditions: 'You are an expert Scalix Cloud Architect. Prioritize robust, scalable infrastructure. Plan changes carefully.',
+        permissionMode: 'default'
+    },
+    {
+        id: 'dba',
+        name: 'Database Administrator',
+        description: 'Focused on database migrations and SQL optimization',
+        systemPromptAdditions: 'You are a Senior DBA. Prioritize data integrity and query performance. Always verify schemas before altering.',
+        permissionMode: 'default'
+    },
+    {
+        id: 'devops',
+        name: 'DevOps Engineer',
+        description: 'CI/CD, deployments, and infrastructure management',
+        systemPromptAdditions: 'You are a DevOps engineer focused on CI/CD pipelines, containerization, and safe deployments.',
+        permissionMode: 'default'
+    },
+    {
+        id: 'full-access',
+        name: 'Full Access (Auto)',
+        description: 'All tools enabled, autonomous execution mode',
+        systemPromptAdditions: 'You are fully autonomous. Execute the required steps directly.',
+        permissionMode: 'auto'
+    }
+];
+export function getPreset(id) {
+    return AGENT_PRESETS.find(p => p.id === id);
+}

package/dist/agent.js

@@ -1,17 +1,19 @@
 import { ApiError } from './api-client.js';
 import { EventEmitter } from 'eventemitter3';
 import { randomUUID } from 'node:crypto';
-import { getToolPermissionWithArgs } from './sandbox.js';
+import { getToolPermissionWithArgs, getMaxImageSize } from './sandbox.js';
 import { logger } from './logger.js';
-import { DEFAULT_MODELS as FALLBACK_MODELS, DEFAULT_INSTRUCTIONS, DEFAULT_BASE_URL, AGENT_DEFAULTS, TOOL_DEFAULTS, BACKOFF_DEFAULTS, CONTEXT_DEFAULTS, SCALIX_PLATFORM_SECTION, SCALIX_CLOUD_RESOURCES_SECTION, SCALIX_NEUTRAL_POINTER, SCALIX_STEERING_ALWAYS_ON, modelSupportsVision, getModelSpec, maxOutputTokensForRequest, hasExplicitModelSpec } from './constants.js';
+import { DEFAULT_MODELS as FALLBACK_MODELS, DEFAULT_INSTRUCTIONS, DEFAULT_BASE_URL, AGENT_DEFAULTS, TOOL_DEFAULTS, BACKOFF_DEFAULTS, CONTEXT_DEFAULTS, SCALIX_PLATFORM_SECTION, SCALIX_CLOUD_RESOURCES_SECTION, SCALIX_DEPLOY_PLAYBOOK_SECTION, SCALIX_PLATFORM_PLAYBOOK_SECTION, SCALIX_NEUTRAL_POINTER, SCALIX_STEERING_ALWAYS_ON, modelSupportsVision, getModelSpec, maxOutputTokensForRequest, hasExplicitModelSpec } from './constants.js';
 import { estimateMessageTokens as estimateTokenCount, estimateTokens } from './token-counter.js';
 import { ContextManager } from './context-manager.js';
 import { zodToJsonSchema } from './tool-helper.js';
 import { ToolSelector } from './tool-selector.js';
 import { AgentReplay } from './agent-replay.js';
 import { loadHooks, runHooks } from './hooks.js';
+import { isWorkspaceTrusted } from './workspace-trust.js';
 import { setAgentToolConfig } from './tools-advanced.js';
 import { AgentRegistry, generateAgentId } from './agent-registry.js';
+import { getPreset } from './agent-presets.js';
 import { runVerification, VERIFY_DEFAULTS } from './auto-verify.js';
 import { ChangeTracker } from './change-tracker.js';
 import { detectPromptInjection, formatInjectionWarning } from './injection-detector.js';
@@ -21,6 +23,26 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 import { fetchCloudTools, callCloudTool, fetchMe, filterCatalogByScopes, buildCloudToolsPromptSection, cloudKeyRemedy } from './cloud.js';
 import { createChatClient, capabilitiesFor } from './providers/index.js';
+import { McpHub } from './mcp.js';
+import { BoardTurnRefresher } from './board-context.js';
+const SUPPORTED_PASTED_IMAGE_MIMES = new Set([
+    'image/png', 'image/jpeg', 'image/gif', 'image/webp', 'image/bmp', 'image/svg+xml',
+]);
+export function validatePastedImages(images) {
+    const maxSize = getMaxImageSize();
+    for (const image of images) {
+        const match = /^data:(image\/[a-z0-9.+-]+);base64,([a-z0-9+/=\s]+)$/i.exec(image);
+        if (!match || !SUPPORTED_PASTED_IMAGE_MIMES.has(match[1].toLowerCase())) {
+            throw new Error('Unsupported pasted image. Use PNG, JPEG, GIF, WebP, BMP, or SVG.');
+        }
+        const payload = match[2].replace(/\s/g, '');
+        const bytes = Math.floor(payload.length * 3 / 4)
+            - (payload.endsWith('==') ? 2 : payload.endsWith('=') ? 1 : 0);
+        if (bytes > maxSize) {
+            throw new Error(`Pasted image is too large (${Math.ceil(bytes / 1024 / 1024)}MB). Maximum is ${Math.floor(maxSize / 1024 / 1024)}MB.`);
+        }
+    }
+}
 /**
  * Marks an error that Agent has already announced through the 'error' event.
  * `send()` emits and then rethrows, so a caller that also prints from its catch
@@ -30,11 +52,10 @@ import { createChatClient, capabilitiesFor } from './providers/index.js';
 export const REPORTED_ERROR = Symbol.for('scalix.coder.reportedError');
 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'))
+        // Everything here is a function tool. Remotely-backed ones — Scalix Cloud
+        // platform tools and MCP tool proxies — carry a ready-made JSON Schema in
+        // `parameters` that passes through as-is; local tools carry a Zod
+        // `inputSchema` that gets converted below.
         .map((t) => {
         const local = t;
         const fn = local.function ?? local;
@@ -151,7 +172,10 @@ export class Agent extends EventEmitter {
     _aborted = false;
     _thinkingActive = false;
     replay;
+    boardRefresher;
+    boardPrimed;
     hooks = [];
+    hooksSkipped = 0;
     instructionLoader;
     _abortController = null;
     modelFailures = new Map();
@@ -175,6 +199,7 @@ export class Agent extends EventEmitter {
     outputFormatInstructionIndex = null;
     cloudProjectId;
     cloudStatus = { state: 'no-key', toolCount: 0 };
+    mcpHub = null;
     providerId;
     capabilities;
     cloudApiKey;
@@ -233,8 +258,28 @@ export class Agent extends EventEmitter {
             this.toolSelector = new ToolSelector();
             this.toolSelector.index(this.config.tools);
         }
+        // Crew board freshness (board-context.ts): baseline taken here, right
+        // after the system prompt embedded the board, so the first turnNote()
+        // only fires on real change. Fire-and-forget; send() awaits it.
+        this.boardRefresher = new BoardTurnRefresher(this.config.workspaceRoot ?? process.cwd());
+        this.boardPrimed = this.boardRefresher.prime().catch(() => { });
         this.replay = new AgentReplay(randomUUID().slice(0, 8), this.config.models[0]);
-        this.hooks = loadHooks();
+        // Hooks are shell commands read out of the project's own .scalix/hooks.json
+        // — exec surface, exactly like plugins and scoped rules, and named as such
+        // in workspace-trust.ts's own docstring. The gate existed; this call site
+        // just never asked. Parsing the file while untrusted is still fine and is
+        // what lets us say "3 hooks were skipped" instead of going quietly inert.
+        const projectHooks = loadHooks();
+        if (isWorkspaceTrusted()) {
+            this.hooks = projectHooks;
+        }
+        else {
+            this.hooks = [];
+            this.hooksSkipped = projectHooks.length;
+            if (projectHooks.length > 0) {
+                this.log.warn('Project hooks skipped — untrusted workspace', { count: projectHooks.length });
+            }
+        }
         this.instructionLoader = config.instructionLoader;
         if (config.autoVerify === true) {
             this.verifyConfig = { ...VERIFY_DEFAULTS };
@@ -354,6 +399,16 @@ export class Agent extends EventEmitter {
             message.includes('stream error') ||
             message.includes('try again'));
     }
+    setPreset(presetId) {
+        const preset = getPreset(presetId);
+        if (!preset)
+            throw new Error(`Unknown preset: ${presetId}`);
+        this.config.permissionMode = preset.permissionMode;
+        // We append the prompt to the base instructions
+        if (preset.systemPromptAdditions && !this.config.instructions.includes(preset.systemPromptAdditions)) {
+            this.config.instructions += '\n\n' + preset.systemPromptAdditions;
+        }
+    }
     isModelCircuitOpen(model) {
         const state = this.modelFailures.get(model);
         if (!state)
@@ -580,6 +635,64 @@ export class Agent extends EventEmitter {
         if (this.toolSelector)
             this.toolSelector.index(this.config.tools);
     }
+    // ─── MCP servers ───
+    isMcpTool(t) {
+        return 'source' in t && t.source === 'mcp';
+    }
+    /**
+     * Take ownership of a connected hub and register its tools. The entrypoint
+     * connects (so a slow server delays startup, not the first message) and hands
+     * the hub over; the agent needs it so `add_mcp_server` can connect at runtime
+     * and so `close()` can shut the child processes down.
+     */
+    attachMcpHub(hub) {
+        this.mcpHub = hub;
+        this.syncMcpTools();
+    }
+    /** Replace the registered MCP proxies with whatever the hub currently holds. */
+    syncMcpTools() {
+        this.config.tools = this.config.tools.filter((t) => !this.isMcpTool(t));
+        if (this.mcpHub) {
+            const taken = new Set(this.config.tools.map((t) => t.function?.name || t.name).filter(Boolean));
+            for (const t of this.mcpHub.tools()) {
+                // A namespaced mcp__ name colliding with a local tool means two servers
+                // share a label; keep the first and say so rather than shadowing.
+                if (taken.has(t.name)) {
+                    this.log.warn('MCP tool name already taken — skipping', { tool: t.name, server: t.serverLabel });
+                    continue;
+                }
+                taken.add(t.name);
+                this.config.tools.push(t);
+            }
+        }
+        if (this.toolSelector)
+            this.toolSelector.index(this.config.tools);
+    }
+    /**
+     * Connect one server and register its tools immediately. Creates the hub if
+     * the entrypoint never attached one, so a runtime `add_mcp_server` works even
+     * when no config file existed at startup.
+     */
+    async connectMcpServer(config) {
+        if (!this.mcpHub)
+            this.mcpHub = new McpHub();
+        const [status] = await this.mcpHub.connect([config]);
+        this.syncMcpTools();
+        return status;
+    }
+    getMcpStatus() {
+        return this.mcpHub?.status() ?? [];
+    }
+    getMcpTools() {
+        return this.config.tools.filter((t) => this.isMcpTool(t));
+    }
+    /** Disconnect every MCP server. Call on shutdown — stdio servers are children. */
+    async closeMcp() {
+        const hub = this.mcpHub;
+        this.mcpHub = null;
+        this.config.tools = this.config.tools.filter((t) => !this.isMcpTool(t));
+        await hub?.close();
+    }
     // ─── Scalix Cloud platform tools ───
     isCloudTool(t) {
         return 'source' in t && t.source === 'scalix-cloud';
@@ -731,6 +844,20 @@ export class Agent extends EventEmitter {
     getReplay() { return this.replay; }
     getChangeTracker() { return this.changeTracker; }
     getHooks() { return this.hooks; }
+    /** How many project hooks the trust gate withheld. 0 when trusted. */
+    getSkippedHookCount() { return this.hooksSkipped; }
+    /**
+     * Re-read project hooks after the user trusts the workspace, so /trust picks
+     * them up in the same session rather than only after a restart. Returns the
+     * number now active.
+     */
+    reloadHooks() {
+        if (!isWorkspaceTrusted())
+            return 0;
+        this.hooks = loadHooks();
+        this.hooksSkipped = 0;
+        return this.hooks.length;
+    }
     getApiKey() { return this.config.apiKey; }
     getBaseUrl() { return this.client.baseURL; }
     getAgentId() { return this.agentId; }
@@ -903,6 +1030,8 @@ export class Agent extends EventEmitter {
     async send(content, images) {
         this._aborted = false;
         this.groundingNudgeCount = 0;
+        if (images?.length)
+            validatePastedImages(images);
         const hasFileRefs = /@(?:[\w./-]+\/)?[\w.-]+\.\w+/.test(content);
         const expandedContent = hasFileRefs ? await this.expandFileReferences(content) : content;
         let finalContent = expandedContent;
@@ -925,6 +1054,24 @@ export class Agent extends EventEmitter {
         this.emit('thinking:start');
         this.truncateMessages();
         this.replay.record('user_message', { content });
+        // Crew board turn-refresh: the system prompt is assembled once per
+        // session, so a board that moved since then would go stale mid-thread.
+        // Runs AFTER the push — send()'s synchronous contract (user message in
+        // history and message:user emitted before the first await) is what the
+        // IDE paints on — with the note spliced in BEFORE the user message, so
+        // the member still reads the news before the ask. One file read per
+        // turn; a workspace with no BOARD.md never produces a note.
+        try {
+            await this.boardPrimed;
+            const boardNote = await this.boardRefresher.turnNote();
+            if (boardNote) {
+                const boardMessage = { role: 'system', content: boardNote };
+                const idx = this.messages.lastIndexOf(userMessage);
+                this.messages.splice(idx < 0 ? this.messages.length : idx, 0, boardMessage);
+                this.replay.record('board_refresh', { chars: boardNote.length });
+            }
+        }
+        catch { }
         const requestId = randomUUID().slice(0, 8);
         const reqLog = logger.child(requestId);
         reqLog.info('User message received', { length: content.length });
@@ -949,7 +1096,7 @@ export class Agent extends EventEmitter {
             // platform key is a dead end that doesn't touch the credential that failed.
             if (status === 401 && !error.message.includes('console.scalix.world') && !error.message.includes('/setup')) {
                 error.message += this.capabilities.platformTools
-                    ? ' — API key rejected. Create a new key at https://console.scalix.world/org/keys and update it via /setup.'
+                    ? ' — API key rejected. Create a new key at https://console.scalix.world/org/keys?utm_source=scalix-coder&utm_medium=cli and update it via /setup.'
                     : ` — API key rejected by ${this.client.baseURL}. Check the key for your provider and update it via /setup.`;
             }
             error.metadata = {
@@ -974,6 +1121,13 @@ export class Agent extends EventEmitter {
         let emptyTurnCount = 0;
         const MAX_EMPTY_TURNS = 5;
         let disableTools = false;
+        let _stepIndex = 0;
+        let _turnToolDurationMs = 0;
+        let _turnLlmStartMs = 0;
+        let _turnTtftMs = 0;
+        let _firstDeltaSeen = false;
+        let _turnInputTokens = 0;
+        let _turnOutputTokens = 0;
         let forceNonStreaming = false;
         while (turnCount < this.config.maxSteps) {
             if (this._aborted) {
@@ -1039,6 +1193,9 @@ export class Agent extends EventEmitter {
                     if (!SCALIX_STEERING_ALWAYS_ON) {
                         effectiveInstructions += '\n\n' + SCALIX_PLATFORM_SECTION + '\n\n' + SCALIX_CLOUD_RESOURCES_SECTION;
                     }
+                    // Deploy-path and platform facts ride with the connection too —
+                    // outside the ALWAYS_ON guard so flipping that flag never drops them.
+                    effectiveInstructions += '\n\n' + SCALIX_DEPLOY_PLAYBOOK_SECTION + '\n\n' + SCALIX_PLATFORM_PLAYBOOK_SECTION;
                     const liveCloudTools = this.getCloudTools();
                     if (liveCloudTools.length > 0) {
                         effectiveInstructions += '\n\n' + buildCloudToolsPromptSection(liveCloudTools);
@@ -1059,6 +1216,7 @@ export class Agent extends EventEmitter {
                     ? true
                     : (!apiTools || apiTools.length === 0) && !hasToolMessages);
                 if (useStreaming) {
+                    _turnLlmStartMs = Date.now();
                     const stream = await this.client.chatComplete({
                         model: currentModel,
                         messages: apiMessages,
@@ -1078,6 +1236,10 @@ export class Agent extends EventEmitter {
                         if (choice?.delta) {
                             const delta = choice.delta;
                             if (delta.content) {
+                                if (!_firstDeltaSeen) {
+                                    _turnTtftMs = Date.now() - _turnLlmStartMs;
+                                    _firstDeltaSeen = true;
+                                }
                                 fullText += delta.content;
                                 this.emit('stream:delta', delta.content, fullText);
                             }
@@ -1101,6 +1263,8 @@ export class Agent extends EventEmitter {
                             const inTok = chunk.usage.prompt_tokens ?? 0;
                             const outTok = chunk.usage.completion_tokens ?? 0;
                             const totalTok = chunk.usage.total_tokens ?? (inTok + outTok);
+                            _turnInputTokens = inTok;
+                            _turnOutputTokens = outTok;
                             const cost = chunk.usage.cost ?? 0;
                             this.emit('usage', {
                                 prompt_tokens: inTok,
@@ -1114,6 +1278,7 @@ export class Agent extends EventEmitter {
                     }
                 }
                 else {
+                    _turnLlmStartMs = Date.now();
                     this.emit('stream:start');
                     const result = await this.client.chatComplete({
                         model: currentModel,
@@ -1128,6 +1293,8 @@ export class Agent extends EventEmitter {
                     this.recordModelSuccess(currentModel);
                     const choice = result.choices?.[0];
                     if (choice?.message) {
+                        _turnTtftMs = Date.now() - _turnLlmStartMs;
+                        _firstDeltaSeen = true;
                         if (choice.message.content) {
                             fullText = choice.message.content;
                             this.emit('stream:delta', fullText, fullText);
@@ -1146,6 +1313,8 @@ export class Agent extends EventEmitter {
                         const inTok = result.usage.prompt_tokens ?? 0;
                         const outTok = result.usage.completion_tokens ?? 0;
                         const totalTok = result.usage.total_tokens ?? (inTok + outTok);
+                        _turnInputTokens = inTok;
+                        _turnOutputTokens = outTok;
                         const cost = result.usage.cost ?? 0;
                         this.emit('usage', {
                             prompt_tokens: inTok,
@@ -1320,10 +1489,13 @@ export class Agent extends EventEmitter {
                         const execFn = tool?.function?.execute ?? tool?.execute;
                         if (tool && typeof execFn === 'function') {
                             try {
-                                // 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'
+                                // Remotely-schema'd tools get the raw args: their JSON Schemas
+                                // are authoritative (snake_case) and the far side validates
+                                // them — injecting camelCase duplicates could fail that
+                                // validation. True for the Scalix Cloud gateway and equally for
+                                // any MCP server, which validates against its own inputSchema.
+                                const src = tool?.source;
+                                const args = (src === 'scalix-cloud' || src === 'mcp')
                                     ? parsedArgs
                                     : normalizeArgs(parsedArgs);
                                 // Validate against the very schema the model was shown. Nothing
@@ -1350,6 +1522,8 @@ export class Agent extends EventEmitter {
                                 const toolTimeout = (typeof args?.timeout === 'number' && args.timeout > 0)
                                     ? Math.min(args.timeout, TOOL_DEFAULTS.maxCommandTimeoutMs)
                                     : this.config.toolTimeoutMs;
+                                const toolStart = Date.now();
+                                this.emit('step:start', { stepIndex: _stepIndex, name: call.name, args: parsedArgs, startedAt: toolStart });
                                 result = await withTimeout(execFn(args, {
                                     context: {},
                                     workspaceRoot: this.config.workspaceRoot ?? process.cwd(),
@@ -1363,8 +1537,21 @@ export class Agent extends EventEmitter {
                                         confirmToolCall: this.config.confirmToolCall,
                                     },
                                 }), toolTimeout, call.name);
+                                const toolDurationMs = Date.now() - toolStart;
+                                _turnToolDurationMs += toolDurationMs;
+                                this.emit('step:done', { stepIndex: _stepIndex, name: call.name, durationMs: toolDurationMs, success: !result?.error });
+                                _stepIndex++;
+                                // The tool only persists the entry to mcp-services.json. Connect
+                                // it here too, so the server's tools are usable in this same
+                                // session instead of only after a restart — and report the
+                                // outcome back through the tool result, since a server that
+                                // won't answer is something the model needs to know now.
                                 if (call.name === 'add_mcp_server' && result?.success) {
-                                    this.addTool({ type: 'mcp', serverLabel: args.label, serverUrl: args.url });
+                                    const connected = await this.connectMcpServer({
+                                        serverLabel: args.label,
+                                        serverUrl: args.url,
+                                    });
+                                    result = { ...result, connected: connected.state === 'connected', tools: connected.toolCount, ...(connected.error ? { connectError: connected.error } : {}) };
                                 }
                             }
                             catch (e) {
@@ -1373,11 +1560,19 @@ export class Agent extends EventEmitter {
                             }
                         }
                         else {
-                            const availableNames = this.config.tools
+                            const allNames = this.config.tools
                                 .map((t) => t.function?.name || t.name)
-                                .filter(Boolean)
-                                .slice(0, 20);
-                            result = { error: `Tool "${call.name}" does not exist. Available tools: ${availableNames.join(', ')}. Do not invent tool names — only use tools from the list above, or respond with text directly.` };
+                                .filter(Boolean);
+                            // Near-matches first: an invented "scalix_build_list" must surface
+                            // the real scalix_* names. Blindly listing the first 20 registry
+                            // entries hid every platform tool and read as "those don't exist" —
+                            // the model then invented workarounds instead of correcting the name
+                            // (seen 2026-08-09: a deploy derailed into "make the repo public").
+                            const stem = call.name.toLowerCase().split(/[_-]/)[0];
+                            const near = stem.length >= 3 ? allNames.filter((n) => n.toLowerCase().includes(stem)) : [];
+                            const shown = [...new Set([...near, ...allNames])].slice(0, Math.max(20, Math.min(near.length, 40)));
+                            const omitted = allNames.length - shown.length;
+                            result = { error: `Tool "${call.name}" does not exist.${near.length ? ` Did you mean one of: ${near.slice(0, 40).join(', ')}?` : ''} Available tools: ${shown.join(', ')}${omitted > 0 ? `, plus ${omitted} more registered but not listed here` : ''}. Do not invent tool names — only use tools from the list above, or respond with text directly.` };
                         }
                         let resultStr;
                         try {
@@ -1483,6 +1678,16 @@ export class Agent extends EventEmitter {
                     }
                     if (this._aborted)
                         return '[interrupted]';
+                    this.emit('turn:summary', {
+                        turnIndex: turnCount,
+                        steps: _stepIndex,
+                        llmDurationMs: Date.now() - _turnLlmStartMs,
+                        toolDurationMs: _turnToolDurationMs,
+                        ttftMs: _turnTtftMs,
+                        tokensPerSec: (Date.now() - _turnLlmStartMs) > 0 ? _turnOutputTokens / ((Date.now() - _turnLlmStartMs) / 1000) : 0,
+                        inputTokens: _turnInputTokens,
+                        outputTokens: _turnOutputTokens,
+                    });
                     continue;
                 }
                 if (this.groundingConfig?.enabled && this.groundingNudgeCount < this.groundingConfig.maxNudges) {
@@ -1502,6 +1707,16 @@ export class Agent extends EventEmitter {
                         }
                     }
                 }
+                this.emit('turn:summary', {
+                    turnIndex: turnCount,
+                    steps: _stepIndex,
+                    llmDurationMs: Date.now() - _turnLlmStartMs,
+                    toolDurationMs: _turnToolDurationMs,
+                    ttftMs: _turnTtftMs,
+                    tokensPerSec: (Date.now() - _turnLlmStartMs) > 0 ? _turnOutputTokens / ((Date.now() - _turnLlmStartMs) / 1000) : 0,
+                    inputTokens: _turnInputTokens,
+                    outputTokens: _turnOutputTokens,
+                });
                 return fullText;
             }
             catch (err) {

package/dist/api-client.js

@@ -35,7 +35,7 @@ export function parseRetryAfter(value) {
 const DEFAULT_TIMEOUT_MS = (() => {
     const v = process.env.SCALIX_REQUEST_TIMEOUT_MS;
     const n = v ? parseInt(v, 10) : NaN;
-    return Number.isFinite(n) && n > 0 ? n : 300_000;
+    return Number.isFinite(n) ? n : 0;
 })();
 // The capability probe only decides whether a turn streams. It must never be
 // the reason a turn is slow to start, so it gives up quickly and falls back to
@@ -124,8 +124,8 @@ export class ScalixClient {
         for (;;) {
             const prepared = this.prepareRequest(req);
             const body = JSON.stringify(prepared);
-            const timeoutSignal = AbortSignal.timeout(this.timeoutMs);
-            const combined = signal ? AbortSignal.any([signal, timeoutSignal]) : timeoutSignal;
+            const timeoutSignal = this.timeoutMs > 0 ? AbortSignal.timeout(this.timeoutMs) : undefined;
+            const combined = signal && timeoutSignal ? AbortSignal.any([signal, timeoutSignal]) : (signal || timeoutSignal);
             const response = await fetch(url, {
                 method: 'POST',
                 headers: {
@@ -135,7 +135,7 @@ export class ScalixClient {
                     'x-client-type': 'cli',
                 },
                 body,
-                signal: combined,
+                signal: combined || undefined,
             });
             if (!response.ok) {
                 const text = await response.text().catch(() => '');