scalix 1.2.0 → 1.4.0

package/dist/cli.js

@@ -1,11 +1,12 @@
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 import { useState, useEffect, useCallback, useRef, useMemo, memo } from 'react';
-import { render, Box, Text, useInput, useApp, useStdout } from 'ink';
+import { render, Box, Text, useInput, useApp } from 'ink';
 import Spinner from 'ink-spinner';
 import TextInput from 'ink-text-input';
 import Gradient from 'ink-gradient';
 import BigText from 'ink-big-text';
-import { execSync, execFileSync } from 'node:child_process';
+import { execSync, execFileSync, execFile, spawn } from 'node:child_process';
+import { promisify } from 'node:util';
 import os from 'node:os';
 import fs from 'node:fs/promises';
 import { existsSync, readFileSync } from 'node:fs';
@@ -42,7 +43,43 @@ import { loadSkills, skillsSummary, getSkillByTrigger, getSkillContent } from '.
 import { AgentRegistry } from './agent-registry.js';
 import { createWorktree, listWorktrees, removeWorktree, cleanupStaleWorktrees } from './worktree.js';
 import { sendNotification, getTerminalType } from './terminal-notify.js';
+import { stringWidth, truncateText } from './text-utils.js';
+import { isWorkspaceTrusted, trustWorkspace, hasProjectExecSurface } from './workspace-trust.js';
+import { fetchMe, fetchCloudTools, groupCloudTools, CONSOLE_KEYS_URL } from './cloud.js';
 logger.setLevel('silent');
+// Promisified async child_process helpers (keep the TUI responsive vs execSync).
+const execFileAsync = promisify(execFile);
+// Run a shell command asynchronously, resolving with stdout/stderr like execSync's
+// error shape (so callers can read err.stdout / err.stderr). Never blocks the event loop.
+function runShellAsync(command, opts = {}) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, {
+            shell: true,
+            cwd: opts.cwd ?? process.cwd(),
+            timeout: opts.timeout,
+        });
+        let stdout = '';
+        let stderr = '';
+        child.stdout?.on('data', (d) => { stdout += d.toString(); });
+        child.stderr?.on('data', (d) => { stderr += d.toString(); });
+        child.on('error', (err) => { err.stdout = stdout; err.stderr = stderr; reject(err); });
+        child.on('close', (code) => {
+            if (code === 0)
+                resolve({ stdout, stderr });
+            else {
+                const err = new Error(`Command failed: ${command}`);
+                err.code = code;
+                err.stdout = stdout;
+                err.stderr = stderr;
+                reject(err);
+            }
+        });
+        if (opts.input !== undefined) {
+            child.stdin?.write(opts.input);
+            child.stdin?.end();
+        }
+    });
+}
 setSandboxRoot(process.cwd());
 // Suppress noisy React 19 development-mode reconciler warnings that leak to stderr
 const _origConsoleError = console.error;
@@ -51,28 +88,47 @@ console.error = (...args) => {
         return;
     _origConsoleError(...args);
 };
-// Disable bracketed paste mode — terminals (via zsh) may leave it enabled,
-// which wraps pasted text in escape sequences that corrupt TextInput values.
-process.stdout.write('\x1b[?2004l');
+// Enable bracketed paste mode so multi-line pastes arrive as a single chunk
+// wrapped in \x1b[200~ … \x1b[201~ markers. We strip those markers (see
+// sanitizeInput) and buffer the pasted content into the input value instead of
+// treating each embedded newline as a separate Enter (which caused many submits).
+process.stdout.write('\x1b[?2004h');
+// User-registered external MCP servers (mcp-services.json). These are
+// decorative config entries only — they are filtered out of API requests by
+// transformToolsForApi. Scalix Cloud platform tools do NOT use this path: they
+// are fetched from the account's catalog and registered as first-class
+// function tools via agent.refreshCloudTools() (see connectCloud below).
 const mcpTools = loadMcpServices();
 let pluginTools = [];
 const allTools = [...defaultTools, ...extraTools, ...webTools, ...advancedTools, ...visionTools, ...voiceTools, ...browserTools, ...mcpTools];
 // ─── Confirmation bridge (event-driven) ───
 import { EventEmitter } from 'node:events';
 const confirmEmitter = new EventEmitter();
-let pendingConfirm = null;
+// FIFO queue of pending confirmations. Using a queue (instead of a single slot)
+// ensures a second concurrent confirm can't overwrite/hang the first — each
+// resolves in order and the next one is surfaced to the UI when the prior clears.
+const confirmQueue = [];
+// Resolve every queued confirmation (as denied) — used on abort / clear so no
+// tool call is left hanging waiting for a decision that will never come.
+function drainConfirmQueue(value = false) {
+    while (confirmQueue.length > 0) {
+        confirmQueue.shift().resolve(value);
+    }
+}
 const alwaysAllowedTools = new Set();
 const recentDenials = [];
 const confirmToolCall = async (toolName, args) => {
+    // Evaluate scoped permissions BEFORE consulting the session "Always allow" set,
+    // so a scoped `deny` still blocks even after the user pressed "Always".
+    const scoped = checkScopedPermission(toolName, args);
+    if (scoped === 'deny')
+        return false;
     if (alwaysAllowedTools.has(toolName))
         return true;
-    const scoped = checkScopedPermission(toolName, args);
     if (scoped === 'allow')
         return true;
-    if (scoped === 'deny')
-        return false;
     return new Promise((resolve) => {
-        pendingConfirm = { resolve, toolName, args };
+        confirmQueue.push({ resolve, toolName, args });
         confirmEmitter.emit('pending');
     });
 };
@@ -85,6 +141,68 @@ let loadedPlugins = [];
 let projectMemory = null;
 let customCommands = [];
 let loadedSkills = [];
+// Set during initAgent when the workspace is untrusted but has project-local
+// exec surface (plugins/hooks/rules/settings) that we skipped loading. The App
+// reads this on mount to inform the user they can run /trust to enable them.
+let workspaceUntrustedNotice = false;
+let cloudConnection = { connected: false, identity: null, toolCount: 0 };
+// Set by the setup wizard when its Scalix Cloud validation step succeeded, so
+// the App shows the "Try:" teach-in exactly once after a wizard or /login
+// connect (not on every ordinary startup reconnect).
+let cloudTeachInPending = false;
+// Validate the key against /v1/me, then fetch the account's tool catalog and
+// register it on the agent. One attempt, no retry loop: failure leaves the
+// agent with local tools only and carries the server's own error message.
+async function connectCloud(targetAgent) {
+    if (!targetAgent.getApiKey()) {
+        cloudConnection = { connected: false, identity: null, toolCount: 0, error: 'no API key configured' };
+        return cloudConnection;
+    }
+    try {
+        const identity = await fetchMe(targetAgent.getBaseUrl() || DEFAULT_BASE_URL, targetAgent.getApiKey());
+        const status = await targetAgent.refreshCloudTools();
+        if (status.state === 'connected') {
+            cloudConnection = { connected: true, identity, toolCount: status.toolCount };
+        }
+        else {
+            cloudConnection = { connected: false, identity, toolCount: 0, error: status.error };
+        }
+    }
+    catch (err) {
+        // /v1/me failed. Run the catalog fetch anyway: on failure it clears any
+        // stale platform tools from a previous connect; in the rare case it
+        // succeeds, the tools genuinely work and we say so (identity unavailable).
+        const status = await targetAgent.refreshCloudTools().catch(() => null);
+        if (status?.state === 'connected') {
+            cloudConnection = { connected: true, identity: null, toolCount: status.toolCount, error: err?.message || String(err) };
+        }
+        else {
+            cloudConnection = { connected: false, identity: null, toolCount: 0, error: err?.message || String(err) };
+        }
+    }
+    return cloudConnection;
+}
+const CLOUD_TRY_PROMPTS = [
+    'deploy this app to Scalix Run',
+    'create a table in my Scalix database and insert seed data',
+    'list my storage buckets and upload dist/ to one',
+];
+// Discover and register project-local plugin tools for the given agent.
+// Gated on workspace trust; reused by initAgent and the /trust command.
+function discoverPluginsForAgent(targetAgent) {
+    loadedPlugins = [];
+    if (!isWorkspaceTrusted(process.cwd()))
+        return Promise.resolve();
+    return discoverPlugins(process.cwd()).then((plugins) => {
+        loadedPlugins = plugins;
+        const pTools = getPluginTools(plugins);
+        pluginTools = pTools;
+        for (const pt of pTools)
+            targetAgent.addTool(pt);
+    }).catch((err) => {
+        logger.warn('Plugin discovery failed', { error: err.message });
+    });
+}
 async function buildEnhancedInstructions() {
     let instructions = baseInstructions;
     const cwd = process.cwd();
@@ -114,13 +232,17 @@ async function buildEnhancedInstructions() {
         instructions += '\n\n' + indexToContext(projectIndex);
     }
     catch { }
-    try {
-        const rules = await loadScopedRules(cwd);
-        const rulesCtx = rulesToContext(rules);
-        if (rulesCtx)
-            instructions += '\n\n' + rulesCtx;
+    // Scoped rules are project-local content injected into the model context —
+    // only load them from a trusted workspace.
+    if (isWorkspaceTrusted(cwd)) {
+        try {
+            const rules = await loadScopedRules(cwd);
+            const rulesCtx = rulesToContext(rules);
+            if (rulesCtx)
+                instructions += '\n\n' + rulesCtx;
+        }
+        catch { }
     }
-    catch { }
     return instructions;
 }
 function initAgent(config) {
@@ -152,16 +274,11 @@ function initAgent(config) {
         thinkingMode: config.thinkingMode || 'off',
     });
     const currentAgent = agent;
-    loadedPlugins = [];
-    discoverPlugins(process.cwd()).then((plugins) => {
-        loadedPlugins = plugins;
-        const pTools = getPluginTools(plugins);
-        pluginTools = pTools;
-        for (const pt of pTools)
-            currentAgent.addTool(pt);
-    }).catch((err) => {
-        logger.warn('Plugin discovery failed', { error: err.message });
-    });
+    // Project-local plugins/hooks/rules are exec surface — only load from a
+    // trusted workspace. When skipped but present, flag it so the App can nudge
+    // the user toward /trust.
+    workspaceUntrustedNotice = !isWorkspaceTrusted(process.cwd()) && hasProjectExecSurface(process.cwd());
+    discoverPluginsForAgent(currentAgent);
     buildEnhancedInstructions().then((enhanced) => {
         currentAgent.setInstructions(enhanced);
     }).catch((err) => {
@@ -179,22 +296,36 @@ function initAgent(config) {
 function shortModel(m) {
     return m.split('/').pop().replace(/:free$/, '').replace(/-instruct$/, '');
 }
+const termSizeSubscribers = new Set();
+let termSize = {
+    cols: process.stdout?.columns ?? 80,
+    rows: process.stdout?.rows ?? 24,
+};
+let termResizeListenerAttached = false;
+function onTermResize() {
+    const cols = process.stdout?.columns ?? 80;
+    const rows = process.stdout?.rows ?? 24;
+    if (cols === termSize.cols && rows === termSize.rows)
+        return;
+    termSize = { cols, rows };
+    for (const notify of termSizeSubscribers)
+        notify();
+}
+function subscribeTermSize(cb) {
+    termSizeSubscribers.add(cb);
+    if (!termResizeListenerAttached) {
+        process.stdout?.on('resize', onTermResize);
+        termResizeListenerAttached = true;
+    }
+    return () => { termSizeSubscribers.delete(cb); };
+}
 function useTermSize() {
-    const { stdout } = useStdout();
-    const [size, setSize] = useState({ cols: stdout?.columns ?? 80, rows: stdout?.rows ?? 24 });
+    const [size, setSize] = useState(termSize);
     useEffect(() => {
-        const fn = () => {
-            const newCols = stdout?.columns ?? 80;
-            const newRows = stdout?.rows ?? 24;
-            setSize((prev) => {
-                if (prev.cols === newCols && prev.rows === newRows)
-                    return prev;
-                return { cols: newCols, rows: newRows };
-            });
-        };
-        stdout?.on('resize', fn);
-        return () => { stdout?.off('resize', fn); };
-    }, [stdout]);
+        // Sync any change that happened between initial render and subscribe.
+        setSize(termSize);
+        return subscribeTermSize(() => setSize(termSize));
+    }, []);
     return size;
 }
 function elapsed(start) {
@@ -219,17 +350,27 @@ function formatTokens(n) {
 const Banner = memo(function Banner() {
     return (_jsx(Box, { flexDirection: "column", alignItems: "center", marginBottom: 0, children: _jsx(Gradient, { name: "teen", children: _jsx(BigText, { text: PRODUCT_NAME.toLowerCase(), font: "tiny" }) }) }));
 });
-// Strip bracketed paste markers and control chars that leak through ink's parser
+// Strip bracketed paste markers and control chars that leak through ink's parser.
+// Keeps newlines (\x0a) and tabs (\x09) so pasted multi-line content is preserved
+// and buffered into the input value rather than being submitted line-by-line.
 function sanitizeInput(v) {
-    return v.replace(/\[20[01]~/g, '').replace(/[\x00-\x08\x0b\x0c\x0e-\x1f]/g, '');
+    return v
+        // Full bracketed-paste markers (ESC [ 200~ / 201~) and the leftover form
+        // after ink strips the ESC byte ([200~ / [201~).
+        .replace(/\x1b?\[20[01]~/g, '')
+        // Strip control chars but preserve \t (\x09) and \n (\x0a).
+        .replace(/[\x00-\x08\x0b\x0c\x0e-\x1f]/g, '');
 }
 async function tryPasteImage() {
     const platform = os.platform();
     const tmpFile = path.join(os.tmpdir(), `scalix-paste-${Date.now()}.png`);
+    // Quote the temp path so directories with spaces (e.g. "C:\Users\First Last")
+    // don't break the shell commands below.
+    const q = `"${tmpFile}"`;
     try {
         if (platform === 'darwin') {
             try {
-                execSync(`pngpaste ${tmpFile}`, { stdio: 'pipe', timeout: 3000 });
+                execSync(`pngpaste ${q}`, { stdio: 'pipe', timeout: 3000 });
             }
             catch {
                 const hasImage = execSync(`osascript -e 'clipboard info' 2>/dev/null | grep -q 'TIFF\\|PNG\\|JPEG' && echo yes || echo no`, { encoding: 'utf-8', timeout: 3000 }).trim();
@@ -238,8 +379,15 @@ async function tryPasteImage() {
                 execSync(`osascript -e 'set imgData to (the clipboard as «class PNGf»)' -e 'set fp to open for access POSIX file "${tmpFile}" with write permission' -e 'write imgData to fp' -e 'close access fp'`, { stdio: 'pipe', timeout: 5000 });
             }
         }
+        else if (platform === 'win32') {
+            // Save the clipboard image via PowerShell. Get-Clipboard -Format Image
+            // returns a System.Drawing.Bitmap; Save() writes PNG to the temp path.
+            const psScript = `$img = Get-Clipboard -Format Image; ` +
+                `if ($img -ne $null) { $img.Save('${tmpFile.replace(/'/g, "''")}'); }`;
+            execFileSync('powershell', ['-NoProfile', '-NonInteractive', '-Command', psScript], { stdio: 'pipe', timeout: 5000 });
+        }
         else {
-            execSync(`xclip -selection clipboard -t image/png -o > ${tmpFile}`, { stdio: 'pipe', timeout: 3000 });
+            execSync(`xclip -selection clipboard -t image/png -o > ${q}`, { stdio: 'pipe', timeout: 3000 });
         }
         const { readFileSync, unlinkSync } = await import('node:fs');
         const data = readFileSync(tmpFile);
@@ -303,7 +451,7 @@ function formatContextSize(tokens) {
     return String(tokens);
 }
 function SetupScreen({ onComplete, existingConfig }) {
-    const STEPS = ['api-key', 'base-url', 'models', 'context-window'];
+    const STEPS = ['api-key', 'base-url', 'cloud', 'models', 'context-window'];
     const [step, setStep] = useState('api-key');
     const [apiKey, setApiKey] = useState(existingConfig?.apiKey || process.env[ENV_API_KEY] || '');
     const [baseUrl, setBaseUrl] = useState(existingConfig?.baseUrl || DEFAULT_BASE_URL);
@@ -314,7 +462,33 @@ function SetupScreen({ onComplete, existingConfig }) {
     const [apiKeyError, setApiKeyError] = useState(false);
     const [fetchedModels, setFetchedModels] = useState([]);
     const [fetchingModels, setFetchingModels] = useState(false);
+    const [cloudCheck, setCloudCheck] = useState({ phase: 'checking' });
     const { exit } = useApp();
+    // Validate the key against Scalix Cloud when the cloud step is entered:
+    // /v1/me for identity/plan, then the tool catalog for the unlocked count.
+    useEffect(() => {
+        if (step !== 'cloud')
+            return;
+        let cancelled = false;
+        setCloudCheck({ phase: 'checking' });
+        (async () => {
+            const identity = await fetchMe(baseUrl, apiKey);
+            const catalog = await fetchCloudTools(baseUrl, apiKey, process.env.SCALIX_PROJECT);
+            return { identity, toolCount: catalog.tools.length };
+        })().then((result) => {
+            if (cancelled)
+                return;
+            cloudTeachInPending = true;
+            setCloudCheck({ phase: 'ok', identity: result.identity, toolCount: result.toolCount });
+        }).catch((err) => {
+            if (cancelled)
+                return;
+            setCloudCheck({ phase: 'fail', error: err?.message || String(err) });
+        });
+        return () => { cancelled = true; };
+        // apiKey/baseUrl are intentionally not deps: they are frozen once the user
+        // advances past base-url, and the step transition is the trigger.
+    }, [step]);
     const totalSteps = STEPS.length;
     const stepNumber = STEPS.indexOf(step) + 1;
     const goBack = useCallback(() => {
@@ -353,6 +527,8 @@ function SetupScreen({ onComplete, existingConfig }) {
                                         }, placeholder: "sk-or-v1-..." })] }), apiKeyError && (_jsx(Box, { marginTop: 0, paddingLeft: 2, children: _jsx(Text, { color: "yellow", dimColor: true, children: "API key is required." }) }))] })), step === 'base-url' && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, color: "white", children: "Base URL" }), _jsx(Text, { dimColor: true, children: "Scalix API endpoint (or any compatible URL)" }), _jsxs(Box, { marginTop: 1, children: [_jsxs(Text, { color: "#20a0a0", bold: true, children: ['\u276F', " "] }), _jsx(TextInput, { value: baseUrl, onChange: (v) => setBaseUrl(sanitizeInput(v)), onSubmit: (v) => {
                                             const url = sanitizeInput(v).trim() || baseUrl;
                                             setBaseUrl(url);
+                                            // Model list loads in the background while the cloud step
+                                            // validates the key via /v1/me + the tool catalog.
                                             setFetchingModels(true);
                                             fetchModelSpecs(url, apiKey).then((result) => {
                                                 if (result.length > 0) {
@@ -360,9 +536,19 @@ function SetupScreen({ onComplete, existingConfig }) {
                                                 }
                                             }).catch((err) => { logger.warn('Failed to fetch model specs', { error: err.message }); }).finally(() => {
                                                 setFetchingModels(false);
-                                                setStep('models');
                                             });
-                                        }, placeholder: DEFAULT_BASE_URL })] }), fetchingModels && (_jsx(Box, { paddingLeft: 2, marginTop: 1, children: _jsx(Text, { color: "#20a0a0", dimColor: true, children: "Fetching available models..." }) }))] })), step === 'models' && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, color: "white", children: "Models" }), fetchedModels.length > 0 && modelsMode === 'custom' && models.length === 0 ? (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { dimColor: true, children: "Select models from your API or type a custom model ID." }), _jsx(Box, { flexDirection: "column", marginTop: 1, children: _jsx(SelectInput, { items: [
+                                            setStep('cloud');
+                                        }, placeholder: DEFAULT_BASE_URL })] }), fetchingModels && (_jsx(Box, { paddingLeft: 2, marginTop: 1, children: _jsx(Text, { color: "#20a0a0", dimColor: true, children: "Fetching available models..." }) }))] })), step === 'cloud' && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, color: "white", children: "Scalix Cloud" }), cloudCheck.phase === 'checking' && (_jsxs(Box, { marginTop: 1, gap: 1, children: [_jsx(Text, { color: "#20a0a0", children: _jsx(Spinner, { type: "dots" }) }), _jsx(Text, { dimColor: true, children: "Validating your API key with Scalix Cloud..." })] })), cloudCheck.phase === 'ok' && (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "#30c090", paddingX: 2, marginTop: 1, alignSelf: "flex-start", children: [_jsxs(Text, { color: "#30c090", bold: true, children: ['✓', " Connected to Scalix Cloud"] }), _jsxs(Text, { children: ["Org:        ", _jsx(Text, { color: "#20a0a0", children: cloudCheck.identity.identity.orgId })] }), _jsxs(Text, { children: ["Project:    ", _jsx(Text, { color: "#20a0a0", children: cloudCheck.identity.identity.projectId || 'org-wide' })] }), _jsxs(Text, { children: ["Plan:       ", _jsx(Text, { color: "#20a0a0", children: cloudCheck.identity.limits.plan })] }), _jsxs(Text, { children: ["Rate limit: ", _jsxs(Text, { color: "#20a0a0", children: [cloudCheck.identity.limits.rateLimitRps, " req/s"] })] }), _jsxs(Text, { color: "#30c090", bold: true, children: ['●', " ", cloudCheck.toolCount, " platform tools unlocked"] })] }), _jsx(Box, { marginTop: 1, children: _jsx(SelectInput, { items: [{ label: '→ Continue', value: '__continue__' }], onSelect: () => setStep('models') }) })] })), cloudCheck.phase === 'fail' && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: "red", children: ['✘', " ", cloudCheck.error] }) }), _jsxs(Text, { dimColor: true, children: ["Create or check your key at ", CONSOLE_KEYS_URL] }), _jsx(Box, { marginTop: 1, children: _jsx(SelectInput, { items: [
+                                                { label: 'Re-enter API key', value: '__reenter__' },
+                                                { label: 'Skip — continue without Scalix Cloud (local tools only)', value: '__skip__' },
+                                            ], onSelect: (item) => {
+                                                if (item.value === '__reenter__') {
+                                                    setStep('api-key');
+                                                }
+                                                else {
+                                                    setStep('models');
+                                                }
+                                            } }) })] }))] })), step === 'models' && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, color: "white", children: "Models" }), fetchedModels.length > 0 && modelsMode === 'custom' && models.length === 0 ? (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { dimColor: true, children: "Select models from your API or type a custom model ID." }), _jsx(Box, { flexDirection: "column", marginTop: 1, children: _jsx(SelectInput, { items: [
                                                 ...fetchedModels.filter((fm) => !models.includes(fm.id)).map((fm) => ({
                                                     label: `  ${fm.name || fm.id}`,
                                                     value: fm.id,
@@ -458,7 +644,20 @@ const StatusBar = memo(function StatusBar({ status, model, toolCount, thinkStart
     const modeColor = mode === 'yolo' ? 'red' : mode === 'auto' ? 'yellow' : mode === 'plan' ? 'blue' : 'green';
     const statusIcon = status === 'thinking' ? '\u25D4' : status === 'error' ? '\u2718' : '\u25CF';
     const statusColor = status === 'thinking' ? 'yellow' : status === 'error' ? 'red' : 'green';
-    const activeAgents = AgentRegistry.getInstance().listActive().length;
+    // Subscribe to registry changes so this memoized component re-renders when
+    // agents spawn/complete, instead of reading a stale count during render only.
+    const [activeAgents, setActiveAgents] = useState(() => AgentRegistry.getInstance().listActive().length);
+    useEffect(() => {
+        const registry = AgentRegistry.getInstance();
+        const refresh = () => setActiveAgents(registry.listActive().length);
+        refresh();
+        registry.on('agent:spawned', refresh);
+        registry.on('agent:completed', refresh);
+        return () => {
+            registry.off('agent:spawned', refresh);
+            registry.off('agent:completed', refresh);
+        };
+    }, []);
     const leftParts = [];
     leftParts.push(shortModel(model));
     if (tokens > 0)
@@ -474,8 +673,8 @@ const StatusBar = memo(function StatusBar({ status, model, toolCount, thinkStart
     const gap = Math.max(cols - leftText.length - rightLen - 8, 2);
     return (_jsxs(Box, { paddingX: 2, children: [_jsxs(Box, { gap: 1, children: [_jsx(Text, { color: statusColor, children: statusIcon }), _jsx(Text, { dimColor: true, children: leftText })] }), _jsx(Text, { children: ' '.repeat(gap) }), _jsxs(Box, { gap: 1, children: [rateLimitWarn && _jsxs(Text, { color: "red", bold: true, children: ['\u26A0', " Rate limited"] }), _jsx(Text, { color: modeColor, bold: true, children: mode }), elapsedStr ? _jsxs(Text, { dimColor: true, children: ['\u00B7', " ", elapsedStr] }) : null, _jsxs(Text, { dimColor: true, children: ['\u00B7', " v", VERSION] })] })] }));
 });
-const WelcomeScreen = memo(function WelcomeScreen() {
-    return (_jsxs(Box, { flexDirection: "column", paddingX: 2, paddingY: 0, children: [_jsx(Text, { dimColor: true, children: "  Type a message or use /help for commands. Press Esc to exit." }), _jsxs(Box, { marginTop: 0, paddingLeft: 2, gap: 1, flexWrap: "wrap", children: [_jsx(Text, { dimColor: true, children: "Tools:" }), ['shell', 'read', 'write', 'edit', 'search', 'find', 'git', 'web', 'tree'].map((t) => (_jsx(Text, { dimColor: true, bold: true, children: t }, t)))] })] }));
+const WelcomeScreen = memo(function WelcomeScreen({ cloud }) {
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 2, paddingY: 0, children: [_jsx(Text, { dimColor: true, children: "  Type a message or use /help for commands. Press Esc to exit." }), _jsxs(Box, { marginTop: 0, paddingLeft: 2, gap: 1, flexWrap: "wrap", children: [_jsx(Text, { dimColor: true, children: "Tools:" }), ['shell', 'read', 'write', 'edit', 'search', 'find', 'git', 'web', 'tree'].map((t) => (_jsx(Text, { dimColor: true, bold: true, children: t }, t)))] }), _jsx(Box, { paddingLeft: 2, children: cloud.connected ? (_jsxs(Text, { color: "#20a0a0", children: ['☁', " Scalix Cloud ", '·', " ", cloud.identity ? `${cloud.identity.limits.plan} ${'·'} ` : '', cloud.toolCount, " platform tools"] })) : (_jsxs(Text, { dimColor: true, children: ['☁', " not connected ", '—', " /login to link your Scalix account"] })) })] }));
 });
 const UserMessage = memo(function UserMessage({ text }) {
     return (_jsxs(Box, { paddingX: 2, marginTop: 1, gap: 1, children: [_jsx(Text, { color: "magentaBright", bold: true, children: '\u276F' }), _jsx(Text, { wrap: "wrap", bold: true, children: text })] }));
@@ -610,15 +809,28 @@ function ConfirmPrompt({ toolName, args, onRespond, onScrollUp, onScrollDown })
     const isCommand = toolName === 'run_command';
     const isWrite = toolName === 'write_file' || toolName === 'edit_file' || toolName === 'notebook_edit';
     const isGit = toolName === 'git_commit';
+    // Flatten newlines to a single-line glyph so multi-line values (e.g. write_file
+    // content, edit_file old/new strings) can't shatter the box border.
+    const flatten = (s) => s.replace(/\r?\n/g, '\u23CE');
     const highlight = parsed.command ?? parsed.filePath ?? parsed.file_path ?? parsed.notebook_path ?? parsed.message ?? null;
     const highlightLabel = isCommand ? 'Command' : isGit ? 'Message' : isWrite ? 'File' : 'Args';
-    const highlightStr = highlight ? String(highlight) : null;
-    const extraFields = Object.entries(parsed).filter(([k]) => !['command', 'filePath', 'file_path', 'notebook_path', 'message', 'content'].includes(k));
+    const highlightStr = highlight ? flatten(String(highlight)) : null;
+    // Exclude large multi-line payloads (content + edit old/new strings) from the
+    // extra-field rows \u2014 showing them here just corrupts the box layout.
+    const extraFields = Object.entries(parsed).filter(([k]) => !['command', 'filePath', 'file_path', 'notebook_path', 'message', 'content',
+        'oldString', 'newString', 'old_string', 'new_string'].includes(k));
     const boxWidth = Math.min(cols - 2, 80);
     const border = '\u2500'.repeat(boxWidth - 2);
-    return (_jsxs(Box, { flexDirection: "column", paddingX: 1, children: [_jsxs(Text, { color: "yellow", children: ['\u250C', border, '\u2510'] }), _jsxs(Text, { color: "yellow", children: ['\u2502', " ", _jsxs(Text, { color: "yellow", bold: true, children: ['\u26A0', " Permission Required"] }), _jsx(Text, { children: ' '.repeat(Math.max(0, boxWidth - 24)) }), '\u2502'] }), _jsxs(Text, { color: "yellow", children: ['\u2502', " ", _jsx(Text, { dimColor: true, children: "Tool:" }), " ", _jsx(Text, { color: "cyan", bold: true, children: toolName }), _jsx(Text, { children: ' '.repeat(Math.max(0, boxWidth - 9 - toolName.length)) }), '\u2502'] }), highlightStr && (_jsxs(Text, { color: "yellow", children: ['\u2502', " ", _jsxs(Text, { dimColor: true, children: [highlightLabel, ":"] }), " ", _jsx(Text, { color: "white", bold: true, children: truncate(highlightStr, boxWidth - highlightLabel.length - 6) }), _jsx(Text, { children: ' '.repeat(Math.max(0, boxWidth - highlightLabel.length - 4 - Math.min(highlightStr.length, boxWidth - highlightLabel.length - 6))) }), '\u2502'] })), extraFields.slice(0, 3).map(([k, v]) => {
-                const val = truncate(String(v), boxWidth - k.length - 6);
-                return (_jsxs(Text, { color: "yellow", children: ['\u2502', " ", _jsxs(Text, { dimColor: true, children: [k, ":"] }), " ", _jsx(Text, { children: val }), _jsx(Text, { children: ' '.repeat(Math.max(0, boxWidth - k.length - 4 - val.length)) }), '\u2502'] }, k));
+    // Pad the interior of a box row to (boxWidth - 2) columns using display width
+    // (stringWidth), so wide/CJK chars keep the right border aligned. `used` is the
+    // display width already emitted between the two \u2502 borders.
+    const pad = (used) => ' '.repeat(Math.max(0, boxWidth - 2 - used));
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 1, children: [_jsxs(Text, { color: "yellow", children: ['\u250C', border, '\u2510'] }), _jsxs(Text, { color: "yellow", children: ['\u2502', " ", _jsxs(Text, { color: "yellow", bold: true, children: ['\u26A0', " Permission Required"] }), _jsx(Text, { children: ' '.repeat(Math.max(0, boxWidth - 24)) }), '\u2502'] }), _jsxs(Text, { color: "yellow", children: ['\u2502', " ", _jsx(Text, { dimColor: true, children: "Tool:" }), " ", _jsx(Text, { color: "cyan", bold: true, children: toolName }), _jsx(Text, { children: pad(7 + stringWidth(toolName)) }), '\u2502'] }), highlightStr && (() => {
+                const shown = truncateText(highlightStr, boxWidth - highlightLabel.length - 6);
+                return (_jsxs(Text, { color: "yellow", children: ['\u2502', " ", _jsxs(Text, { dimColor: true, children: [highlightLabel, ":"] }), " ", _jsx(Text, { color: "white", bold: true, children: shown }), _jsx(Text, { children: pad(highlightLabel.length + 3 + stringWidth(shown)) }), '\u2502'] }));
+            })(), extraFields.slice(0, 3).map(([k, v]) => {
+                const val = truncateText(flatten(String(v)), boxWidth - k.length - 6);
+                return (_jsxs(Text, { color: "yellow", children: ['\u2502', " ", _jsxs(Text, { dimColor: true, children: [k, ":"] }), " ", _jsx(Text, { children: val }), _jsx(Text, { children: pad(k.length + 3 + stringWidth(val)) }), '\u2502'] }, k));
             }), _jsxs(Text, { color: "yellow", children: ['\u251C', border, '\u2524'] }), _jsxs(Text, { color: "yellow", children: ['\u2502', " ", _jsx(Text, { color: "green", bold: true, children: "[Y]" }), _jsx(Text, { children: " Allow  " }), _jsx(Text, { color: "cyan", bold: true, children: "[A]" }), _jsx(Text, { children: " Always  " }), _jsx(Text, { color: "red", bold: true, children: "[N]" }), _jsx(Text, { children: " Deny  " }), _jsx(Text, { dimColor: true, children: "ESC deny" }), _jsx(Text, { children: ' '.repeat(Math.max(0, boxWidth - 42)) }), '\u2502'] }), _jsxs(Text, { color: "yellow", children: ['\u2514', border, '\u2518'] })] }));
 }
 function ModelPicker({ currentModels, onSelect, onCancel }) {
@@ -805,7 +1017,7 @@ function SettingsEditor({ onSave, onClose }) {
                     }
                 } })] }));
 }
-const InputSection = memo(function InputSection({ onSubmit, disabled, onAbort, onClear, onScrollUp, onScrollDown, onHeightChange, onToggleToolGroups, onImagePaste }) {
+const InputSection = memo(function InputSection({ onSubmit, disabled, onAbort, onClear, onScrollUp, onScrollDown, onHeightChange, onToggleToolGroups, onImagePaste, onExit }) {
     const { exit } = useApp();
     const { cols } = useTermSize();
     const line = useMemo(() => '\u2500'.repeat(Math.max(cols - 6, 20)), [cols]);
@@ -837,6 +1049,9 @@ const InputSection = memo(function InputSection({ onSubmit, disabled, onAbort, o
         setHistoryIndex(-1);
         setValue('');
         valueRef.current = '';
+        // Clear image chips: pending images were consumed by this submit, so the
+        // indicators shouldn't linger and imply they'll attach to the next message.
+        setImageChips([]);
         onSubmit(trimmed);
     }, [onSubmit]);
     useInput((ch, key) => {
@@ -851,16 +1066,20 @@ const InputSection = memo(function InputSection({ onSubmit, disabled, onAbort, o
                 onChange('');
                 return;
             }
-            setCtrlCCount((prev) => {
-                if (prev >= 1) {
-                    exit();
-                    return 0;
-                }
+            // Keep the state updater pure — decide whether to exit outside of it,
+            // so StrictMode's double-invoke can't trigger exit() on the first press.
+            if (ctrlCCount >= 1) {
+                if (ctrlCTimer.current)
+                    clearTimeout(ctrlCTimer.current);
+                setCtrlCCount(0);
+                exit();
+            }
+            else {
                 if (ctrlCTimer.current)
                     clearTimeout(ctrlCTimer.current);
                 ctrlCTimer.current = setTimeout(() => setCtrlCCount(0), 3000);
-                return prev + 1;
-            });
+                setCtrlCCount(1);
+            }
             return;
         }
         // ── Ctrl+D: exit when input is empty ──
@@ -1002,13 +1221,34 @@ const InputSection = memo(function InputSection({ onSubmit, disabled, onAbort, o
                 onChange(matches[0]);
             return;
         }
-        // ── Escape: close command picker or exit ──
+        // ── Escape: close picker → clear input → abort task → exit ──
         if (key.escape) {
+            // 1. @-file picker open → close it by removing the trailing @query.
+            const atOpen = !!projectIndex && /@(\S*)$/.test(val);
+            if (atOpen) {
+                onChange(val.replace(/@\S*$/, ''));
+                return;
+            }
+            // 2. Command picker open → close it.
             if (val.startsWith('/') && !val.includes(' ')) {
                 onChange('');
                 return;
             }
-            exit();
+            // 3. Typed input present → clear it (don't lose work by exiting).
+            if (val.length > 0) {
+                onChange('');
+                return;
+            }
+            // 4. A task is running → abort it rather than exit.
+            if (disabled) {
+                onAbort();
+                return;
+            }
+            // 5. Nothing typed and idle → save session and exit (like /exit).
+            if (onExit)
+                onExit();
+            else
+                exit();
             return;
         }
         // ── When command picker is open, handle input manually since TextInput is unfocused ──
@@ -1092,10 +1332,13 @@ const InputSection = memo(function InputSection({ onSubmit, disabled, onAbort, o
         { cmd: '/remember', desc: 'Save a note about this project' },
         { cmd: '/replay', desc: 'Show session timeline' },
         { cmd: '/plugins', desc: 'Show loaded plugins' },
+        { cmd: '/trust', desc: 'Trust this workspace (load project plugins/hooks/rules)' },
         { cmd: '/router', desc: 'Show model routing status' },
         { cmd: '/status', desc: 'Version, model & connection info' },
         { cmd: '/doctor', desc: 'Diagnose installation' },
         { cmd: '/mcp', desc: 'Add MCP server' },
+        { cmd: '/cloud', desc: 'Scalix Cloud status, platform tools & refresh' },
+        { cmd: '/login', desc: 'Link your Scalix account (API key)' },
         { cmd: '/setup', desc: 'Reconfigure API key, URL & models' },
         { cmd: '/settings', desc: 'View & configure limits' },
         { cmd: '/permissions', desc: 'View permission rules & recent denials' },
@@ -1179,10 +1422,11 @@ function estimateLines(item, cols) {
     // Account for paddingLeft=3 + paddingRight=2 used by most message components
     const textWidth = Math.max(cols - 7, 20);
     const lines = item.text.split('\n');
-    // Count wrapped lines per actual line
+    // Count wrapped lines per actual line using display width (wide/CJK chars
+    // occupy two columns), so scrollback estimates don't overflow.
     let totalLines = 0;
     for (const line of lines) {
-        totalLines += Math.max(1, Math.ceil((line.length || 1) / textWidth));
+        totalLines += Math.max(1, Math.ceil((stringWidth(line) || 1) / textWidth));
     }
     switch (item.kind) {
         case 'user': return totalLines + 2; // marginTop=1 + prompt icon row
@@ -1272,6 +1516,7 @@ function App({ config }) {
     const [selectingMode, setSelectingMode] = useState(false);
     const [editingSettings, setEditingSettings] = useState(false);
     const [agentVersion, setAgentVersion] = useState(0);
+    const [cloudInfo, setCloudInfo] = useState(cloudConnection);
     const counter = useRef(0);
     const showBannerRef = useRef(true);
     const modelsRef = useRef(models);
@@ -1388,9 +1633,13 @@ function App({ config }) {
             }
         };
         const onToolCall = (name, args) => {
+            // A tool running is progress, not a stall — reset the timer so long
+            // builds/tests don't trip the "Stream appears stalled" warning.
+            resetStallTimer();
             add('tool-call', typeof args === 'string' ? args : JSON.stringify(args), name);
         };
         const onToolResult = (name, result) => {
+            resetStallTimer();
             // Extract diff from write_file / edit_file results and show separately
             let parsed = null;
             if (typeof result === 'object' && result !== null) {
@@ -1521,6 +1770,40 @@ function App({ config }) {
             }
         }).catch(() => { });
     }, [add]);
+    // Untrusted-workspace notice: project-local plugins/hooks/rules were skipped.
+    useEffect(() => {
+        if (workspaceUntrustedNotice) {
+            add('system', 'This workspace has project plugins/hooks/rules that were skipped because the workspace is not trusted. Run /trust to load them.');
+        }
+    }, [add]);
+    // Scalix Cloud: on agent start (and after /setup or /login re-init), fetch
+    // the account's tool catalog and register it. Failure or no key → local
+    // tools only, with exactly one honest notice. No retry loop.
+    useEffect(() => {
+        if (!agent)
+            return;
+        const hasKey = !!agent.getApiKey();
+        let cancelled = false;
+        connectCloud(agent).then((state) => {
+            if (cancelled)
+                return;
+            setCloudInfo({ ...state });
+            if (state.connected) {
+                // Teach-in: only right after a wizard or /login connect, and only
+                // when tools actually loaded.
+                if (cloudTeachInPending && state.toolCount > 0) {
+                    cloudTeachInPending = false;
+                    const plan = state.identity ? ` ${'·'} ${state.identity.limits.plan}` : '';
+                    add('system', `☁ Connected to Scalix Cloud${plan} ${'·'} ${state.toolCount} platform tools`);
+                    add('system', `Try:\n${CLOUD_TRY_PROMPTS.map((p) => `  ❯ ${p}`).join('\n')}`);
+                }
+            }
+            else if (hasKey) {
+                add('system', `☁ Scalix Cloud unavailable — running with local tools only. ${state.error ?? ''}`.trimEnd());
+            }
+        });
+        return () => { cancelled = true; };
+    }, [add, agentVersion]);
     // Idle session nudge: suggest /clear after 75+ minutes of inactivity
     const lastActivityRef = useRef(Date.now());
     const idleNudgedRef = useRef(false);
@@ -1539,19 +1822,28 @@ function App({ config }) {
     useEffect(() => {
         if (!agent)
             return;
+        // Capture the agent for cleanup so .off() detaches from the same instance
+        // even after the agent is re-initialized (e.g. /setup).
+        const currentAgent = agent;
         const onStreamEnd = () => {
-            if (!document.hasFocus?.() || process.env.SCALIX_NOTIFY !== '0') {
+            // `document` doesn't exist in Node (referencing it threw a ReferenceError
+            // on every stream:end). Gate purely on the env var; only consult a focus
+            // check when running somewhere that actually has `document`.
+            const doc = globalThis.document;
+            const hasFocus = doc ? doc.hasFocus?.() : false;
+            if (process.env.SCALIX_NOTIFY !== '0' && !hasFocus) {
                 sendNotification('Scalix', 'Task complete');
             }
         };
-        agent.on('stream:end', onStreamEnd);
-        return () => { agent.off('stream:end', onStreamEnd); };
+        currentAgent.on('stream:end', onStreamEnd);
+        return () => { currentAgent.off('stream:end', onStreamEnd); };
     }, [agentVersion]);
-    // Confirmation bridge (event-driven)
+    // Confirmation bridge (event-driven). Surfaces the head of the FIFO queue.
     useEffect(() => {
         const onPending = () => {
-            if (pendingConfirm && !confirmInfo) {
-                setConfirmInfo({ toolName: pendingConfirm.toolName, args: pendingConfirm.args });
+            if (confirmQueue.length > 0 && !confirmInfo) {
+                const head = confirmQueue[0];
+                setConfirmInfo({ toolName: head.toolName, args: head.args });
             }
         };
         confirmEmitter.on('pending', onPending);
@@ -1563,22 +1855,24 @@ function App({ config }) {
             add('system', banner);
     }, [add]);
     const handleConfirm = useCallback((ok, always) => {
-        if (pendingConfirm) {
+        const current = confirmQueue.shift();
+        if (current) {
             if (ok && always)
-                alwaysAllowedTools.add(pendingConfirm.toolName);
+                alwaysAllowedTools.add(current.toolName);
             if (!ok) {
                 recentDenials.push({
-                    toolName: pendingConfirm.toolName,
-                    args: JSON.stringify(pendingConfirm.args).slice(0, 100),
+                    toolName: current.toolName,
+                    args: JSON.stringify(current.args).slice(0, 100),
                     timestamp: Date.now(),
                 });
                 if (recentDenials.length > 20)
                     recentDenials.shift();
             }
-            pendingConfirm.resolve(ok);
-            pendingConfirm = null;
+            current.resolve(ok);
         }
-        setConfirmInfo(null);
+        // Surface the next queued confirmation, if any.
+        const next = confirmQueue[0];
+        setConfirmInfo(next ? { toolName: next.toolName, args: next.args } : null);
     }, []);
     const handleCommand = useCallback((text) => {
         const cmd = text.split(' ')[0].toLowerCase();
@@ -1627,6 +1921,8 @@ function App({ config }) {
                 '',
                 'Tools & Config:',
                 '  /copy         \u2014 copy last response to clipboard',
+                '  /cloud        \u2014 Scalix Cloud status (/cloud tools, /cloud refresh)',
+                '  /login        \u2014 link your Scalix account (API key)',
                 '  /status       \u2014 show version, model & connection info',
                 '  /update       \u2014 check for and install updates',
                 '  /doctor       \u2014 diagnose installation',
@@ -1635,6 +1931,7 @@ function App({ config }) {
                 '  /mcp <l> <u>  \u2014 add MCP server',
                 '  /plugins      \u2014 show loaded plugins',
                 '  /plugin       \u2014 install/enable/disable/uninstall plugins',
+                '  /trust        \u2014 trust workspace (load project plugins/hooks/rules)',
                 '  /notify       \u2014 test terminal notification',
                 '  /router       \u2014 show model routing status',
                 '  /replay       \u2014 show session timeline',
@@ -1655,10 +1952,7 @@ function App({ config }) {
         }
         if (cmd === '/clear') {
             agent.abort();
-            if (pendingConfirm) {
-                pendingConfirm.resolve(false);
-                pendingConfirm = null;
-            }
+            drainConfirmQueue(false);
             const msgs = agent.getMessages();
             if (msgs.length > 0) {
                 saveSession(sessionId, msgs, models[0] || 'unknown', undefined, costTracker.getState()).then((meta) => {
@@ -1852,6 +2146,68 @@ function App({ config }) {
             setShowSetup(true);
             return true;
         }
+        if (cmd === '/login') {
+            // Key (re-)entry runs through the setup wizard, whose cloud step
+            // performs the same fetchMe + catalog validation as first-run setup.
+            setShowSetup(true);
+            return true;
+        }
+        if (cmd === '/cloud') {
+            const sub = text.split(' ')[1]?.toLowerCase() || 'status';
+            if (sub === 'status') {
+                const s = cloudConnection;
+                if (s.connected) {
+                    add('system', `☁ Scalix Cloud ${'—'} connected`);
+                    if (s.identity) {
+                        add('system', `Org: ${s.identity.identity.orgId}`);
+                        add('system', `Project: ${s.identity.identity.projectId || agent.getCloudProjectId() || 'org-wide'}`);
+                        add('system', `Key: ${s.identity.identity.keyId} (${s.identity.permissions.role})`);
+                        add('system', `Plan: ${s.identity.limits.plan} ${'·'} ${s.identity.limits.rateLimitRps} req/s ${'·'} ${s.identity.limits.apiKeysMax} API keys max`);
+                        add('system', `Scopes: ${s.identity.permissions.scopes.join(', ') || 'none'}`);
+                    }
+                    else {
+                        add('system', `Identity unavailable: ${s.error ?? 'unknown error'}`);
+                    }
+                    add('system', `Platform tools: ${s.toolCount} registered ${'—'} /cloud tools to list them`);
+                }
+                else {
+                    add('system', `☁ not connected ${'—'} /login to link your Scalix account`);
+                    if (s.error)
+                        add('system', `Last error: ${s.error}`);
+                }
+                return true;
+            }
+            if (sub === 'tools') {
+                const tools = agent.getCloudTools();
+                if (tools.length === 0) {
+                    add('system', cloudConnection.connected
+                        ? 'No platform tools are registered for this key (its scopes unlock none).'
+                        : `☁ not connected ${'—'} /login to link your Scalix account`);
+                    return true;
+                }
+                add('system', `Platform tools (${tools.length}):`);
+                for (const [group, groupTools] of groupCloudTools(tools)) {
+                    add('system', `  ${group} (${groupTools.length}): ${groupTools.map((t) => t.name).join(', ')}`);
+                }
+                return true;
+            }
+            if (sub === 'refresh') {
+                add('system', 'Refreshing Scalix Cloud connection...');
+                connectCloud(agent).then((state) => {
+                    setCloudInfo({ ...state });
+                    if (state.connected) {
+                        const plan = state.identity ? `${state.identity.limits.plan} plan ${'·'} ` : '';
+                        add('system', `☁ Connected ${'—'} ${plan}${state.toolCount} platform tools`);
+                    }
+                    else {
+                        add('error', `☁ Scalix Cloud unavailable: ${state.error ?? 'unknown error'}`);
+                    }
+                });
+                return true;
+            }
+            add('system', 'Usage: /cloud [status|tools|refresh]');
+            return true;
+        }
         if (cmd === '/mode') {
             const arg = text.split(' ')[1]?.toLowerCase();
             if (arg && PERMISSION_MODES.includes(arg)) {
@@ -1936,6 +2292,27 @@ function App({ config }) {
             add('system', pluginsSummary(loadedPlugins));
             return true;
         }
+        if (cmd === '/trust') {
+            const cwd = process.cwd();
+            if (isWorkspaceTrusted(cwd)) {
+                add('system', 'Workspace is already trusted.');
+                return true;
+            }
+            trustWorkspace(cwd);
+            workspaceUntrustedNotice = false;
+            add('system', `Workspace trusted: ${cwd}`);
+            // Re-run project-local discovery now that the workspace is trusted.
+            discoverPluginsForAgent(agent).then(() => {
+                add('system', `Loaded ${loadedPlugins.length} plugin(s).`);
+            }).catch(() => { });
+            buildEnhancedInstructions().then((enhanced) => {
+                agent.setInstructions(enhanced);
+                add('system', 'Reloaded project rules into context.');
+            }).catch(() => { });
+            loadCustomCommands(cwd).then((cmds) => { customCommands = cmds; }).catch(() => { });
+            loadSkills(cwd).then((skills) => { loadedSkills = skills; }).catch(() => { });
+            return true;
+        }
         if (cmd === '/replay') {
             const replay = agent.getReplay();
             const timeline = replay.getTimeline();
@@ -2188,17 +2565,18 @@ function App({ config }) {
             add('system', 'Generating commit...');
             (async () => {
                 try {
+                    const gitOpts = { timeout: TOOL_DEFAULTS.gitTimeoutMs, cwd: process.cwd() };
                     // Check for staged changes
                     let diff = '';
                     try {
-                        diff = execSync('git diff --staged', { encoding: 'utf-8', timeout: TOOL_DEFAULTS.gitTimeoutMs, cwd: process.cwd() }).trim();
+                        diff = (await execFileAsync('git', ['diff', '--staged'], gitOpts)).stdout.trim();
                     }
                     catch { }
                     if (!diff) {
                         // Nothing staged — stage tracked files only (safer than -A)
                         try {
-                            execSync('git add -u', { encoding: 'utf-8', timeout: TOOL_DEFAULTS.gitTimeoutMs, cwd: process.cwd() });
-                            diff = execSync('git diff --staged', { encoding: 'utf-8', timeout: TOOL_DEFAULTS.gitTimeoutMs, cwd: process.cwd() }).trim();
+                            await execFileAsync('git', ['add', '-u'], gitOpts);
+                            diff = (await execFileAsync('git', ['diff', '--staged'], gitOpts)).stdout.trim();
                         }
                         catch (e) {
                             add('error', `Failed to stage files: ${e.message}`);
@@ -2220,7 +2598,7 @@ function App({ config }) {
                     add('system', `Commit message: ${cleanMsg}`);
                     try {
                         const fullMsg = cleanMsg + `\n\nCo-Authored-By: ${GIT_BOT_IDENTITY.name} <${GIT_BOT_IDENTITY.email}>`;
-                        const result = execFileSync('git', ['commit', '-m', fullMsg], { encoding: 'utf-8', timeout: TOOL_DEFAULTS.gitTimeoutMs, cwd: process.cwd() }).trim();
+                        const result = (await execFileAsync('git', ['commit', '-m', fullMsg], gitOpts)).stdout.trim();
                         add('system', result);
                     }
                     catch (e) {
@@ -2245,26 +2623,27 @@ function App({ config }) {
             add('system', 'Running code review...');
             (async () => {
                 try {
+                    const gitOpts = { timeout: TOOL_DEFAULTS.gitTimeoutMs, cwd: process.cwd() };
                     let diff = '';
                     let baseBranch = 'main';
                     try {
-                        baseBranch = execSync('git symbolic-ref refs/remotes/origin/HEAD', { encoding: 'utf-8', timeout: TOOL_DEFAULTS.gitTimeoutMs, cwd: process.cwd() }).trim().replace('refs/remotes/origin/', '');
+                        baseBranch = (await execFileAsync('git', ['symbolic-ref', 'refs/remotes/origin/HEAD'], gitOpts)).stdout.trim().replace('refs/remotes/origin/', '');
                     }
                     catch {
                         try {
-                            const branches = execSync('git branch --list main master', { encoding: 'utf-8', timeout: TOOL_DEFAULTS.gitTimeoutMs, cwd: process.cwd() }).trim();
+                            const branches = (await execFileAsync('git', ['branch', '--list', 'main', 'master'], gitOpts)).stdout.trim();
                             if (branches.includes('master'))
                                 baseBranch = 'master';
                         }
                         catch { }
                     }
                     try {
-                        diff = execSync(`git diff ${baseBranch}...HEAD`, { encoding: 'utf-8', timeout: TOOL_DEFAULTS.gitTimeoutMs, cwd: process.cwd() }).trim();
+                        diff = (await execFileAsync('git', ['diff', `${baseBranch}...HEAD`], gitOpts)).stdout.trim();
                     }
                     catch { }
                     if (!diff) {
                         try {
-                            diff = execSync('git diff', { encoding: 'utf-8', timeout: TOOL_DEFAULTS.gitTimeoutMs, cwd: process.cwd() }).trim();
+                            diff = (await execFileAsync('git', ['diff'], gitOpts)).stdout.trim();
                         }
                         catch { }
                     }
@@ -2300,7 +2679,8 @@ function App({ config }) {
                 const MAX_RETRIES = 5;
                 for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
                     try {
-                        const output = execSync(watchCmd, { encoding: 'utf-8', timeout: TOOL_DEFAULTS.maxCommandTimeoutMs, cwd: process.cwd() }).trim();
+                        const { stdout } = await runShellAsync(watchCmd, { timeout: TOOL_DEFAULTS.maxCommandTimeoutMs, cwd: process.cwd() });
+                        const output = stdout.trim();
                         if (output)
                             add('system', output.length > 2000 ? output.slice(0, 2000) + '\n... (truncated)' : output);
                         add('system', `Watch: command succeeded on attempt ${attempt}.`);
@@ -2351,30 +2731,33 @@ function App({ config }) {
             return true;
         }
         if (cmd === '/diff') {
-            try {
-                let diff = '';
-                try {
-                    diff = execSync('git diff', { encoding: 'utf-8', timeout: TOOL_DEFAULTS.gitTimeoutMs, cwd: process.cwd() }).trim();
-                }
-                catch { }
-                let staged = '';
+            (async () => {
                 try {
-                    staged = execSync('git diff --staged', { encoding: 'utf-8', timeout: TOOL_DEFAULTS.gitTimeoutMs, cwd: process.cwd() }).trim();
-                }
-                catch { }
-                if (staged)
-                    diff = (diff ? diff + '\n' : '') + '--- Staged changes ---\n' + staged;
-                if (!diff) {
-                    add('system', 'No uncommitted changes.');
+                    const gitOpts = { timeout: TOOL_DEFAULTS.gitTimeoutMs, cwd: process.cwd() };
+                    let diff = '';
+                    try {
+                        diff = (await execFileAsync('git', ['diff'], gitOpts)).stdout.trim();
+                    }
+                    catch { }
+                    let staged = '';
+                    try {
+                        staged = (await execFileAsync('git', ['diff', '--staged'], gitOpts)).stdout.trim();
+                    }
+                    catch { }
+                    if (staged)
+                        diff = (diff ? diff + '\n' : '') + '--- Staged changes ---\n' + staged;
+                    if (!diff) {
+                        add('system', 'No uncommitted changes.');
+                    }
+                    else {
+                        const truncated = diff.length > 5000 ? diff.slice(0, 5000) + '\n... (truncated, full diff is ' + diff.length + ' chars)' : diff;
+                        truncated.split('\n').forEach((l) => add('system', l));
+                    }
                 }
-                else {
-                    const truncated = diff.length > 5000 ? diff.slice(0, 5000) + '\n... (truncated, full diff is ' + diff.length + ' chars)' : diff;
-                    truncated.split('\n').forEach((l) => add('system', l));
+                catch (e) {
+                    add('error', `Failed to get diff: ${e.message}`);
                 }
-            }
-            catch (e) {
-                add('error', `Failed to get diff: ${e.message}`);
-            }
+            })();
             return true;
         }
         if (cmd === '/copy') {
@@ -2424,6 +2807,9 @@ function App({ config }) {
             add('system', `${PRODUCT_NAME} v${VERSION}`);
             add('system', `Model: ${modelsStr}`);
             add('system', `API: ${baseUrl}`);
+            add('system', cloudConnection.connected
+                ? `Cloud: ☁ Scalix Cloud ${'·'} ${cloudConnection.identity ? `${cloudConnection.identity.limits.plan} ${'·'} ` : ''}${cloudConnection.toolCount} platform tools`
+                : `Cloud: ☁ not connected ${'—'} /login to link your Scalix account`);
             add('system', `Mode: ${mode}`);
             add('system', `Context: ${ctx.percentage}% (${formatTokens(ctx.tokens)} / ${formatTokens(ctx.maxTokens)})`);
             add('system', `Messages: ${msgCount}`);
@@ -2602,43 +2988,13 @@ function App({ config }) {
     const multilineRef = useRef([]);
     const messageQueueRef = useRef([]);
     const pendingImagesRef = useRef([]);
-    const handleSubmit = useCallback(async (text) => {
-        const trimmed = text.trim();
-        if (!trimmed)
-            return;
-        // Reset idle nudge on any user activity
-        lastActivityRef.current = Date.now();
-        idleNudgedRef.current = false;
-        // Allow /mode even while the agent is working
-        if (isLoadingRef.current && trimmed.startsWith('/mode')) {
-            handleCommand(trimmed);
-            return;
-        }
-        // Queue messages while agent is working
-        if (isLoadingRef.current) {
-            messageQueueRef.current.push(trimmed);
-            add('system', `Queued (${messageQueueRef.current.length}): ${truncate(trimmed, 60)}`);
-            return;
-        }
-        if (trimmed.endsWith('\\')) {
-            if (multilineRef.current.length >= 50) {
-                add('system', 'Multiline limit reached (50 lines). Sending now.');
-            }
-            else {
-                multilineRef.current.push(trimmed.slice(0, -1));
-                add('system', '... (continue typing, submit without \\ to send)');
-                return;
-            }
-        }
-        let finalText;
-        if (multilineRef.current.length > 0) {
-            multilineRef.current.push(trimmed);
-            finalText = multilineRef.current.join('\n');
-            multilineRef.current = [];
-        }
-        else {
-            finalText = trimmed;
-        }
+    // Process ONE finalized user message through the full input pipeline:
+    // slash-command → `!` shell → skill/correction → send to agent. Shared by the
+    // main submit path and the queue-drain loop so queued /compact, /clear, !ls,
+    // etc. behave identically to freshly typed input. Returns true if the message
+    // was handled inline (command/shell) and did NOT go to the agent.
+    const processFinalizedInput = useCallback(async (rawFinalText) => {
+        let finalText = rawFinalText;
         if (finalText.startsWith('/') && handleCommand(finalText))
             return;
         const triggeredSkill = getSkillByTrigger(loadedSkills, finalText);
@@ -2652,7 +3008,8 @@ function App({ config }) {
                 return;
             add('system', `$ ${shellCmd}`);
             try {
-                let output = execSync(shellCmd, { encoding: 'utf-8', timeout: HEADLESS_DEFAULTS.commandTimeoutMs, cwd: process.cwd() }).trim();
+                const { stdout } = await runShellAsync(shellCmd, { timeout: HEADLESS_DEFAULTS.commandTimeoutMs, cwd: process.cwd() });
+                let output = stdout.trim();
                 if (output) {
                     if (output.length > 2000) {
                         output = output.slice(0, 2000) + `\n... (${(output.length - 2000).toLocaleString()} chars truncated)`;
@@ -2677,7 +3034,6 @@ function App({ config }) {
             add('user', finalText);
         }
         pendingImagesRef.current = [];
-        setIsLoading(true);
         setStatus('thinking');
         setThinkStart(Date.now());
         try {
@@ -2689,30 +3045,73 @@ function App({ config }) {
         catch (e) {
             add('error', e.message || 'Unknown error');
         }
+    }, [add, handleCommand]);
+    const handleSubmit = useCallback(async (text) => {
+        const trimmed = text.trim();
+        if (!trimmed)
+            return;
+        // Reset idle nudge on any user activity
+        lastActivityRef.current = Date.now();
+        idleNudgedRef.current = false;
+        // Allow /mode even while the agent is working
+        if (isLoadingRef.current && trimmed.startsWith('/mode')) {
+            handleCommand(trimmed);
+            return;
+        }
+        // Queue messages while agent is working
+        if (isLoadingRef.current) {
+            messageQueueRef.current.push(trimmed);
+            add('system', `Queued (${messageQueueRef.current.length}): ${truncate(trimmed, 60)}`);
+            return;
+        }
+        if (trimmed.endsWith('\\')) {
+            if (multilineRef.current.length >= 50) {
+                add('system', 'Multiline limit reached (50 lines). Sending now.');
+            }
+            else {
+                multilineRef.current.push(trimmed.slice(0, -1));
+                add('system', '... (continue typing, submit without \\ to send)');
+                return;
+            }
+        }
+        let finalText;
+        if (multilineRef.current.length > 0) {
+            multilineRef.current.push(trimmed);
+            finalText = multilineRef.current.join('\n');
+            multilineRef.current = [];
+        }
+        else {
+            finalText = trimmed;
+        }
+        // Inline commands/shell that never enter the loading state and don't touch
+        // the queue: run them and return without flipping isLoading.
+        if (finalText.startsWith('/') && handleCommand(finalText))
+            return;
+        if (finalText.startsWith('!')) {
+            await processFinalizedInput(finalText);
+            return;
+        }
+        setIsLoading(true);
+        setStatus('thinking');
+        setThinkStart(Date.now());
+        try {
+            await processFinalizedInput(finalText);
+        }
         finally {
-            // Process queued messages sequentially
+            // Process queued messages sequentially through the SAME pipeline, so a
+            // queued /compact, /clear, !ls, etc. behaves like freshly typed input.
             while (messageQueueRef.current.length > 0) {
                 const next = messageQueueRef.current.shift();
                 const remaining = messageQueueRef.current.length;
                 if (remaining > 0)
                     add('system', `${remaining} more queued`);
-                add('user', next);
-                setStatus('thinking');
-                setThinkStart(Date.now());
-                try {
-                    const qResult = await agent.send(next);
-                    if (!qResult || !qResult.trim())
-                        add('system', 'Agent returned no response.');
-                }
-                catch (e) {
-                    add('error', e.message || 'Unknown error');
-                }
+                await processFinalizedInput(next);
             }
             setIsLoading(false);
             setStatus('ready');
             setThinkStart(null);
         }
-    }, [add, handleCommand]);
+    }, [add, handleCommand, processFinalizedInput]);
     const handleSessionSelect = useCallback((session) => {
         setSessionList(null);
         setIsLoading(true);
@@ -2748,10 +3147,7 @@ function App({ config }) {
     }, [add]);
     const handleAbort = useCallback(() => {
         agent.abort();
-        if (pendingConfirm) {
-            pendingConfirm.resolve(false);
-            pendingConfirm = null;
-        }
+        drainConfirmQueue(false);
         setConfirmInfo(null);
         setIsLoading(false);
         setStatus('ready');
@@ -2775,6 +3171,19 @@ function App({ config }) {
         setRateLimitWarn(false);
         sessionId = generateSessionId();
     }, [models]);
+    // Save the session (with the current model) and exit — mirrors /exit so that
+    // Escape on an empty, idle prompt doesn't lose work.
+    const handleExit = useCallback(() => {
+        const msgs = agent?.getMessages() ?? [];
+        if (msgs.length > 0) {
+            saveSession(sessionId, msgs, models[0] || 'unknown', undefined, costTracker.getState())
+                .catch((err) => { logger.warn('Failed to save session on exit', { error: err.message }); })
+                .finally(() => process.exit(0));
+        }
+        else {
+            process.exit(0);
+        }
+    }, [models]);
     const handleSetupDone = useCallback((newConfig) => {
         setShowSetup(false);
         try {
@@ -2800,7 +3209,7 @@ function App({ config }) {
             catch {
                 parsed = {};
             }
-            const extraCount = Math.min(Object.keys(parsed).filter(k => !['command', 'filePath', 'file_path', 'notebook_path', 'message', 'content'].includes(k)).length, 3);
+            const extraCount = Math.min(Object.keys(parsed).filter(k => !['command', 'filePath', 'file_path', 'notebook_path', 'message', 'content', 'oldString', 'newString', 'old_string', 'new_string'].includes(k)).length, 3);
             const hasHighlight = !!(parsed.command ?? parsed.filePath ?? parsed.file_path ?? parsed.notebook_path ?? parsed.message);
             return 5 + (hasHighlight ? 1 : 0) + extraCount;
         }
@@ -2835,7 +3244,7 @@ function App({ config }) {
     if (showSetup) {
         return _jsx(SetupScreen, { onComplete: handleSetupDone, existingConfig: config });
     }
-    return (_jsxs(Box, { flexDirection: "column", width: "100%", height: rows, children: [showBanner && _jsx(Banner, {}), _jsx(StatusBar, { status: status, model: models[0] || 'no model', toolCount: allTools.length + pluginTools.length, thinkStart: thinkStart, tokens: totalTokens, mode: currentMode, contextPercent: contextPercent, rateLimitWarn: rateLimitWarn }), _jsxs(Box, { flexDirection: "column", flexGrow: 1, flexShrink: 1, minHeight: 6, overflowY: "hidden", children: [showBanner && !isLoading && _jsx(WelcomeScreen, {}), !isAtTop && !showBanner && (_jsx(Box, { justifyContent: "center", children: _jsxs(Text, { dimColor: true, children: [" ", '\u2191', " more above ", '\u2014', " Shift+Up "] }) })), visibleItems.map((item) => _jsx(RenderItem, { item: item }, item.id)), isLoading && _jsx(StreamingArea, { text: streamText, reasoning: reasoningText, model: shortModel(models[0] || '') }), !isAtBottom && (_jsx(Box, { justifyContent: "center", children: _jsxs(Text, { dimColor: true, children: [" ", '\u2193', " more below ", '\u2014', " Shift+Down "] }) }))] }), _jsx(Box, { flexShrink: 0, flexDirection: "column", children: confirmInfo ? (_jsx(ConfirmPrompt, { toolName: confirmInfo.toolName, args: confirmInfo.args, onRespond: handleConfirm, onScrollUp: scrollUp, onScrollDown: scrollDown })) : selectingModel ? (_jsx(ModelPicker, { currentModels: models, onSelect: (v) => {
+    return (_jsxs(Box, { flexDirection: "column", width: "100%", height: rows, children: [showBanner && _jsx(Banner, {}), _jsx(StatusBar, { status: status, model: models[0] || 'no model', toolCount: allTools.length + pluginTools.length + cloudInfo.toolCount, thinkStart: thinkStart, tokens: totalTokens, mode: currentMode, contextPercent: contextPercent, rateLimitWarn: rateLimitWarn }), _jsxs(Box, { flexDirection: "column", flexGrow: 1, flexShrink: 1, minHeight: 6, overflowY: "hidden", children: [showBanner && !isLoading && _jsx(WelcomeScreen, { cloud: cloudInfo }), !isAtTop && !showBanner && (_jsx(Box, { justifyContent: "center", children: _jsxs(Text, { dimColor: true, children: [" ", '\u2191', " more above ", '\u2014', " Shift+Up "] }) })), visibleItems.map((item) => _jsx(RenderItem, { item: item }, item.id)), isLoading && _jsx(StreamingArea, { text: streamText, reasoning: reasoningText, model: shortModel(models[0] || '') }), !isAtBottom && (_jsx(Box, { justifyContent: "center", children: _jsxs(Text, { dimColor: true, children: [" ", '\u2193', " more below ", '\u2014', " Shift+Down "] }) }))] }), _jsx(Box, { flexShrink: 0, flexDirection: "column", children: confirmInfo ? (_jsx(ConfirmPrompt, { toolName: confirmInfo.toolName, args: confirmInfo.args, onRespond: handleConfirm, onScrollUp: scrollUp, onScrollDown: scrollDown })) : selectingModel ? (_jsx(ModelPicker, { currentModels: models, onSelect: (v) => {
                         agent.setModel(v);
                         setModels([v]);
                         setSelectingModel(false);
@@ -2877,7 +3286,7 @@ function App({ config }) {
                         }).catch(() => {
                             add('error', 'Failed to load config.');
                         });
-                    }, onClose: () => setEditingSettings(false) })) : sessionList ? (_jsx(SessionPicker, { sessions: sessionList, onSelect: handleSessionSelect, onCancel: () => setSessionList(null) })) : (_jsx(InputSection, { onSubmit: handleInputSubmit, disabled: isLoading, onAbort: handleAbort, onClear: handleClearScreen, onScrollUp: scrollUp, onScrollDown: scrollDown, onHeightChange: handleInputHeightChange, onToggleToolGroups: toggleToolGroups, onImagePaste: (dataUrl) => { pendingImagesRef.current.push(dataUrl); } })) })] }));
+                    }, onClose: () => setEditingSettings(false) })) : sessionList ? (_jsx(SessionPicker, { sessions: sessionList, onSelect: handleSessionSelect, onCancel: () => setSessionList(null) })) : (_jsx(InputSection, { onSubmit: handleInputSubmit, disabled: isLoading, onAbort: handleAbort, onClear: handleClearScreen, onScrollUp: scrollUp, onScrollDown: scrollDown, onHeightChange: handleInputHeightChange, onToggleToolGroups: toggleToolGroups, onImagePaste: (dataUrl) => { pendingImagesRef.current.push(dataUrl); }, onExit: handleExit })) })] }));
 }
 // ─── Root (config loading + setup gate) ───
 function Root() {