scalix 1.1.0 → 1.3.2

package/dist/cli.js

@@ -1,11 +1,13 @@
 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';
 import path from 'node:path';
@@ -21,24 +23,62 @@ import { browserTools, closeBrowser } from './tools-browser.js';
 import { loadMcpServices } from './mcp.js';
 import { renderMarkdown } from './markdown.js';
 import { costTracker } from './cost-tracker.js';
-import { saveSession, listSessions, loadSession, generateSessionId } from './sessions.js';
+import { saveSession, listSessions, loadSession, generateSessionId, saveCrashState, loadCrashState, clearCrashState, forkSession } from './sessions.js';
 import { logger } from './logger.js';
-import { VERSION, PRODUCT_NAME, DEFAULT_MODELS, DEFAULT_BASE_URL, DEFAULT_INSTRUCTIONS, ENV_API_KEY, ENV_MODEL, TOOL_DEFAULTS, HEADLESS_DEFAULTS, fetchModelSpecs } from './constants.js';
+import { VERSION, PRODUCT_NAME, DEFAULT_MODELS, DEFAULT_BASE_URL, DEFAULT_INSTRUCTIONS, ENV_API_KEY, ENV_MODEL, TOOL_DEFAULTS, HEADLESS_DEFAULTS, GIT_BOT_IDENTITY, fetchModelSpecs } from './constants.js';
 import { checkForUpdate, getUpdateBanner, performUpdate } from './update-checker.js';
 import { loadConfig, saveConfig, isConfigured, DEFAULT_LIMITS, THINKING_MODES } from './settings.js';
-import { getModeDescription, PERMISSION_MODES, setSandboxRoot } from './sandbox.js';
+import { getModeDescription, PERMISSION_MODES, setSandboxRoot, checkScopedPermission, getScopedPermissionRules } from './sandbox.js';
 import { buildProjectIndex, indexToContext } from './project-index.js';
 import { collectGitInfo, gitInfoToContext } from './git-context.js';
 import { loadMemory, autoDetectConventions, saveMemory, memoryToContext, addNote, detectCorrection } from './project-memory.js';
-import { discoverPlugins, getPluginTools, pluginsSummary } from './plugins.js';
+import { discoverPlugins, getPluginTools, pluginsSummary, installPlugin, uninstallPlugin, listInstalledPlugins, enablePlugin, disablePlugin } from './plugins.js';
 import { createRouterConfig, getRouterStatus } from './model-router.js';
 import { loadCustomCommands, expandCommand, commandsSummary } from './commands.js';
 import { hooksSummary } from './hooks.js';
 import { spawnSubAgent, pickCheapestModel } from './sub-agent.js';
 import { createCheckpoint, undoLastCheckpoint, listCheckpoints } from './git-undo.js';
 import { loadScopedRules, rulesToContext } from './scoped-rules.js';
+import { loadSkills, skillsSummary, getSkillByTrigger, getSkillContent } from './skills.js';
 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';
 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;
@@ -47,20 +87,45 @@ 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');
 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;
-const confirmToolCall = async (toolName, args) => new Promise((resolve) => {
-    pendingConfirm = { resolve, toolName, args };
-    confirmEmitter.emit('pending');
-});
+// 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;
+    if (scoped === 'allow')
+        return true;
+    return new Promise((resolve) => {
+        confirmQueue.push({ resolve, toolName, args });
+        confirmEmitter.emit('pending');
+    });
+};
 // ─── Agent (deferred until config is ready) ───
 let baseInstructions = DEFAULT_INSTRUCTIONS;
 let agent = null;
@@ -69,6 +134,27 @@ let projectIndex = null;
 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;
+// 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();
@@ -98,13 +184,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) {
@@ -136,16 +226,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) => {
@@ -154,28 +239,45 @@ function initAgent(config) {
     loadCustomCommands(process.cwd()).then((cmds) => {
         customCommands = cmds;
     }).catch((err) => { logger.warn('Failed to load custom commands', { error: err.message }); });
+    loadSkills(process.cwd()).then((skills) => {
+        loadedSkills = skills;
+    }).catch((err) => { logger.warn('Failed to load skills', { error: err.message }); });
     return agent;
 }
 // ─── Helpers ───
 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) {
@@ -200,9 +302,63 @@ 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 ${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();
+                if (hasImage !== 'yes')
+                    return null;
+                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 > ${q}`, { stdio: 'pipe', timeout: 3000 });
+        }
+        const { readFileSync, unlinkSync } = await import('node:fs');
+        const data = readFileSync(tmpFile);
+        try {
+            unlinkSync(tmpFile);
+        }
+        catch { }
+        if (data.length < 8)
+            return null;
+        return `data:image/png;base64,${data.toString('base64')}`;
+    }
+    catch {
+        try {
+            const { unlinkSync } = await import('node:fs');
+            unlinkSync(tmpFile);
+        }
+        catch { }
+        return null;
+    }
 }
 function LongTextInput({ value, onChange, onSubmit, placeholder, maxVisible = 80 }) {
     const valueRef = useRef(value);
@@ -387,7 +543,7 @@ function SetupScreen({ onComplete, existingConfig }) {
                                             });
                                         }, placeholder: String(DEFAULT_LIMITS.maxContextTokens) })] })] })), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { dimColor: true, italic: true, children: [stepNumber > 1 ? 'Backspace (empty) to go back \u2022 ' : '', "ESC to quit"] }) })] })] }));
 }
-const StatusBar = memo(function StatusBar({ status, model, toolCount, thinkStart, tokens, mode }) {
+const StatusBar = memo(function StatusBar({ status, model, toolCount, thinkStart, tokens, mode, contextPercent, rateLimitWarn }) {
     const { cols } = useTermSize();
     const [elapsedStr, setElapsedStr] = useState('');
     useEffect(() => {
@@ -402,7 +558,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)
@@ -410,10 +579,13 @@ const StatusBar = memo(function StatusBar({ status, model, toolCount, thinkStart
     leftParts.push(`${toolCount} tools`);
     if (activeAgents > 0)
         leftParts.push(`${activeAgents} agent${activeAgents > 1 ? 's' : ''}`);
+    if (contextPercent > 50)
+        leftParts.push(`ctx ${contextPercent}%`);
     const leftText = leftParts.join(' \u00B7 ');
-    const rightLen = mode.length + VERSION.length + 6 + (elapsedStr ? elapsedStr.length + 3 : 0);
+    const warnText = rateLimitWarn ? ' \u26A0 Rate limited' : '';
+    const rightLen = mode.length + VERSION.length + 6 + (elapsedStr ? elapsedStr.length + 3 : 0) + warnText.length;
     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: [_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] })] })] }));
+    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)))] })] }));
@@ -456,6 +628,12 @@ const ToolResultMessage = memo(function ToolResultMessage({ name, result }) {
 const ToolBlockedMessage = memo(function ToolBlockedMessage({ text }) {
     return (_jsxs(Box, { paddingLeft: 3, paddingRight: 2, gap: 1, children: [_jsx(Text, { color: "red", children: '\u25CF' }), _jsx(Text, { color: "red", children: text })] }));
 });
+const ToolGroupMessage = memo(function ToolGroupMessage({ count, children, collapsed }) {
+    if (collapsed || !children) {
+        return (_jsxs(Box, { paddingLeft: 3, paddingRight: 2, gap: 1, marginTop: 1, children: [_jsx(Text, { color: "cyan", children: '○' }), _jsxs(Text, { dimColor: true, children: ["Ran ", count, " tools"] }), _jsx(Text, { dimColor: true, italic: true, children: "(Ctrl+O to expand)" })] }));
+    }
+    return (_jsx(Box, { flexDirection: "column", children: children.map(child => _jsx(RenderItem, { item: child }, child.id)) }));
+});
 const DIFF_MAX_LINES = 60;
 const DiffMessage = memo(function DiffMessage({ text, meta }) {
     const allLines = text.split('\n');
@@ -491,6 +669,7 @@ const RenderItem = memo(function RenderItem({ item }) {
         case 'tool-call': return _jsx(ToolCallMessage, { name: item.meta ?? '', args: item.text });
         case 'tool-result': return _jsx(ToolResultMessage, { name: item.meta ?? '', result: item.text });
         case 'tool-blocked': return _jsx(ToolBlockedMessage, { text: item.text });
+        case 'tool-group': return _jsx(ToolGroupMessage, { count: item.children?.length ?? 0, children: item.children, collapsed: item.collapsed });
         case 'diff': return _jsx(DiffMessage, { text: item.text, meta: item.meta });
         case 'system': return _jsx(SystemMessage, { text: item.text });
     }
@@ -519,14 +698,20 @@ const StreamingArea = memo(function StreamingArea({ text, reasoning, model, maxL
 function ConfirmPrompt({ toolName, args, onRespond, onScrollUp, onScrollDown }) {
     const { cols } = useTermSize();
     useInput((ch, key) => {
-        if (ch.toLowerCase() === 'y')
+        if (ch.toLowerCase() === 'a')
+            onRespond(true, true);
+        else if (ch.toLowerCase() === 'y')
             onRespond(true);
         else if (ch.toLowerCase() === 'n' || key.escape)
             onRespond(false);
-        else if (key.pageUp || (key.upArrow && key.shift))
-            onScrollUp?.();
-        else if (key.pageDown || (key.downArrow && key.shift))
-            onScrollDown?.();
+        else if (key.pageUp)
+            onScrollUp?.(15);
+        else if (key.upArrow && key.shift)
+            onScrollUp?.(5);
+        else if (key.pageDown)
+            onScrollDown?.(15);
+        else if (key.downArrow && key.shift)
+            onScrollDown?.(5);
     });
     let parsed = {};
     try {
@@ -538,16 +723,29 @@ 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));
-            }), _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: "red", bold: true, children: "[N]" }), _jsx(Text, { children: " Deny  " }), _jsx(Text, { dimColor: true, children: "ESC to deny" }), _jsx(Text, { children: ' '.repeat(Math.max(0, boxWidth - 33)) }), '\u2502'] }), _jsxs(Text, { color: "yellow", children: ['\u2514', border, '\u2518'] })] }));
+    // 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 }) {
     const [customInput, setCustomInput] = useState('');
@@ -733,7 +931,7 @@ function SettingsEditor({ onSave, onClose }) {
                     }
                 } })] }));
 }
-const InputSection = memo(function InputSection({ onSubmit, disabled, onAbort, onClear, onScrollUp, onScrollDown, onHeightChange }) {
+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]);
@@ -744,7 +942,11 @@ const InputSection = memo(function InputSection({ onSubmit, disabled, onAbort, o
     const [history, setHistory] = useState([]);
     const [historyIndex, setHistoryIndex] = useState(-1);
     const savedInput = useRef('');
+    const [searchMode, setSearchMode] = useState(false);
+    const [searchQuery, setSearchQuery] = useState('');
+    const ctrlXPending = useRef(false);
     const valueRef = useRef('');
+    const [imageChips, setImageChips] = useState([]);
     const onChange = useCallback((v) => {
         setValue(v);
         valueRef.current = v;
@@ -761,6 +963,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) => {
@@ -775,16 +980,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 ──
@@ -814,6 +1023,88 @@ const InputSection = memo(function InputSection({ onSubmit, disabled, onAbort, o
             onChange('');
             return;
         }
+        // ── Alt+Enter / Meta+Enter: insert newline ──
+        if (key.return && key.meta && !disabled) {
+            onChange(val + '\n');
+            return;
+        }
+        // ── Ctrl+X Ctrl+E: open external editor ──
+        if (ch === 'x' && key.ctrl && !disabled) {
+            ctrlXPending.current = true;
+            setTimeout(() => { ctrlXPending.current = false; }, 1000);
+            return;
+        }
+        if (ch === 'e' && key.ctrl && ctrlXPending.current && !disabled) {
+            ctrlXPending.current = false;
+            const editor = process.env.EDITOR || process.env.VISUAL || 'vi';
+            const tmpFile = path.join(os.tmpdir(), `scalix-input-${Date.now()}.txt`);
+            import('node:fs').then(async (fs) => {
+                fs.writeFileSync(tmpFile, val);
+                const { execSync } = await import('node:child_process');
+                try {
+                    execSync(`${editor} ${tmpFile}`, { stdio: 'inherit' });
+                    const edited = fs.readFileSync(tmpFile, 'utf-8');
+                    onChange(edited.trimEnd());
+                }
+                catch { /* editor exited with error */ }
+                try {
+                    fs.unlinkSync(tmpFile);
+                }
+                catch { /* cleanup */ }
+            });
+            return;
+        }
+        // ── Ctrl+O: toggle collapsed tool groups ──
+        if (ch === 'o' && key.ctrl) {
+            onToggleToolGroups?.();
+            return;
+        }
+        // ── Ctrl+R: reverse history search ──
+        if (ch === 'r' && key.ctrl && !disabled) {
+            if (searchMode) {
+                setSearchMode(false);
+                setSearchQuery('');
+            }
+            else {
+                setSearchMode(true);
+                setSearchQuery('');
+            }
+            return;
+        }
+        // ── Search mode input handling ──
+        if (searchMode && !disabled) {
+            if (key.return) {
+                // Accept found match
+                setSearchMode(false);
+                return;
+            }
+            if (key.escape) {
+                setSearchMode(false);
+                setSearchQuery('');
+                return;
+            }
+            if (key.backspace || key.delete) {
+                const newQ = searchQuery.slice(0, -1);
+                setSearchQuery(newQ);
+                const match = history.slice().reverse().find(h => h.toLowerCase().includes(newQ.toLowerCase()));
+                if (match) {
+                    setValue(match);
+                    valueRef.current = match;
+                }
+                return;
+            }
+            if (!key.ctrl && !key.meta && !key.tab && ch.length > 0) {
+                const newQ = searchQuery + ch;
+                setSearchQuery(newQ);
+                const match = history.slice().reverse().find(h => h.toLowerCase().includes(newQ.toLowerCase()));
+                if (match) {
+                    setValue(match);
+                    valueRef.current = match;
+                }
+                return;
+            }
+            return;
+        }
         // ── Ctrl+S: stash / restore prompt ──
         if (ch === 's' && key.ctrl && !disabled) {
             if (val.length > 0) {
@@ -826,6 +1117,16 @@ const InputSection = memo(function InputSection({ onSubmit, disabled, onAbort, o
             }
             return;
         }
+        // ── Ctrl+V: paste image from clipboard ──
+        if (ch === 'v' && key.ctrl && !disabled) {
+            tryPasteImage().then(dataUrl => {
+                if (dataUrl) {
+                    setImageChips(prev => [...prev, dataUrl]);
+                    onImagePaste?.(dataUrl);
+                }
+            }).catch(() => { });
+            return;
+        }
         // ── Tab: autocomplete slash commands ──
         if (key.tab && !disabled && val.startsWith('/') && !val.includes(' ')) {
             const cmdNames = commands.map((c) => c.cmd);
@@ -834,13 +1135,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 ──
@@ -859,12 +1181,20 @@ const InputSection = memo(function InputSection({ onSubmit, disabled, onAbort, o
             return;
         }
         // ── Scroll ──
-        if (key.pageUp || (key.upArrow && key.shift)) {
-            onScrollUp();
+        if (key.pageUp) {
+            onScrollUp(15);
+            return;
+        }
+        if (key.upArrow && key.shift) {
+            onScrollUp(5);
             return;
         }
-        if (key.pageDown || (key.downArrow && key.shift)) {
-            onScrollDown();
+        if (key.pageDown) {
+            onScrollDown(15);
+            return;
+        }
+        if (key.downArrow && key.shift) {
+            onScrollDown(5);
             return;
         }
         // ── History navigation ──
@@ -906,6 +1236,8 @@ const InputSection = memo(function InputSection({ onSubmit, disabled, onAbort, o
         { cmd: '/copy', desc: 'Copy last response to clipboard' },
         { cmd: '/save', desc: 'Save current session' },
         { cmd: '/load', desc: 'Resume a saved session' },
+        { cmd: '/resume', desc: 'Resume from crash recovery or saved session' },
+        { cmd: '/fork', desc: 'Fork conversation from a point in history' },
         { cmd: '/export', desc: 'Export conversation as text' },
         { cmd: '/index', desc: 'Scan & index project files' },
         { cmd: '/init', desc: 'Initialize project config (SCALIX.md)' },
@@ -914,15 +1246,18 @@ 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: '/setup', desc: 'Reconfigure API key, URL & models' },
         { cmd: '/settings', desc: 'View & configure limits' },
+        { cmd: '/permissions', desc: 'View permission rules & recent denials' },
         { cmd: '/shortcuts', desc: 'Keyboard shortcuts' },
         { cmd: '/hooks', desc: 'Show lifecycle hooks' },
         { cmd: '/commands', desc: 'Show custom commands' },
+        { cmd: '/skills', desc: 'List available skills' },
         { cmd: '/delegate', desc: 'Run task with sub-agent' },
         { cmd: '/agents', desc: 'Show active agents & usage' },
         { cmd: '/checkpoint', desc: 'Create git checkpoint' },
@@ -932,6 +1267,9 @@ const InputSection = memo(function InputSection({ onSubmit, disabled, onAbort, o
         { cmd: '/review', desc: 'AI code review of current changes' },
         { cmd: '/watch', desc: 'Run command, auto-fix on failure' },
         { cmd: '/create', desc: 'Scaffold a new project' },
+        { cmd: '/worktree', desc: 'Manage git worktrees for isolated work' },
+        { cmd: '/plugin', desc: 'Install/enable/disable/uninstall plugins' },
+        { cmd: '/notify', desc: 'Test terminal notification' },
         { cmd: '/exit', desc: 'Save & exit' },
         ...customCommands.map((c) => ({ cmd: `/${c.name}`, desc: c.description })),
     ], [customCommands]);
@@ -940,18 +1278,37 @@ const InputSection = memo(function InputSection({ onSubmit, disabled, onAbort, o
     const filteredCommands = showCommandPicker
         ? commands.filter((c) => c.cmd.startsWith(prefix))
         : [];
-    const pickerActive = showCommandPicker && filteredCommands.length > 0;
+    // @-mention file typeahead
+    const atMatch = value.match(/@(\S*)$/);
+    const atQuery = atMatch?.[1]?.toLowerCase() ?? '';
+    const showFilePicker = !disabled && !!atMatch && projectIndex;
+    const filteredFiles = useMemo(() => {
+        if (!showFilePicker || !projectIndex)
+            return [];
+        const q = atQuery;
+        return projectIndex.files
+            .map(f => f.relativePath)
+            .filter(p => {
+            if (!q)
+                return true;
+            const name = p.split('/').pop()?.toLowerCase() ?? '';
+            return name.includes(q) || p.toLowerCase().includes(q);
+        })
+            .slice(0, 10);
+    }, [showFilePicker, atQuery]);
+    const pickerActive = (showCommandPicker && filteredCommands.length > 0) || (showFilePicker && filteredFiles.length > 0);
     useEffect(() => {
         if (!onHeightChange)
             return;
         let h = 3; // separator + input row + padding
+        const pickerCount = showCommandPicker ? filteredCommands.length : filteredFiles.length;
         if (pickerActive)
-            h += Math.min(filteredCommands.length, 10) + 2; // items + header + footer
+            h += Math.min(pickerCount, 10) + 2;
         if (stash.length > 0 && !disabled)
             h += 1;
         onHeightChange(h);
-    }, [pickerActive, filteredCommands.length, stash.length, disabled, onHeightChange]);
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { paddingX: 2, children: _jsx(Text, { dimColor: true, children: line }) }), pickerActive && (_jsxs(Box, { flexDirection: "column", paddingX: 3, marginX: 0, paddingY: 0, children: [_jsxs(Box, { gap: 1, marginBottom: 0, children: [_jsx(Text, { dimColor: true, bold: true, children: "Commands" }), _jsxs(Text, { dimColor: true, children: ["(", filteredCommands.length, ")"] })] }), _jsx(SelectInput, { items: filteredCommands.map((c) => ({
+    }, [pickerActive, filteredCommands.length, filteredFiles.length, stash.length, disabled, onHeightChange, showCommandPicker]);
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { paddingX: 2, children: _jsx(Text, { dimColor: true, children: line }) }), showCommandPicker && filteredCommands.length > 0 && (_jsxs(Box, { flexDirection: "column", paddingX: 3, marginX: 0, paddingY: 0, children: [_jsxs(Box, { gap: 1, marginBottom: 0, children: [_jsx(Text, { dimColor: true, bold: true, children: "Commands" }), _jsxs(Text, { dimColor: true, children: ["(", filteredCommands.length, ")"] })] }), _jsx(SelectInput, { items: filteredCommands.map((c) => ({
                             label: `${c.cmd.padEnd(16)} ${c.desc}`,
                             value: c.cmd,
                         })), isFocused: true, onSelect: (item) => {
@@ -963,17 +1320,25 @@ const InputSection = memo(function InputSection({ onSubmit, disabled, onAbort, o
                                 onChange('');
                                 handleSubmit(item.value);
                             }
-                        }, limit: 10 }), _jsxs(Text, { dimColor: true, italic: true, children: ['↑↓', " navigate ", '•', " Enter select ", '•', " keep typing to filter"] })] })), stash.length > 0 && !disabled && (_jsxs(Box, { paddingX: 3, children: [_jsxs(Text, { color: "magenta", dimColor: true, children: ['⚑', " Stashed: ", truncate(stash, 40), " "] }), _jsx(Text, { dimColor: true, children: "(Ctrl+S to restore)" })] })), _jsx(Box, { paddingX: 2, children: _jsxs(Box, { flexGrow: 1, children: [_jsx(Box, { flexShrink: 0, width: 2, children: disabled ? (_jsx(Text, { color: "magentaBright", children: _jsx(Spinner, { type: "dots" }) })) : (_jsx(Text, { color: "magentaBright", bold: true, children: '❯' })) }), _jsx(Box, { flexGrow: 1, children: _jsx(TextInput, { value: value, onChange: onChange, onSubmit: handleSubmit, placeholder: disabled ? 'Queue a message... (sent after current task)' : 'Type a message...', showCursor: true, focus: !pickerActive }) }), disabled && (_jsx(Box, { flexShrink: 0, children: _jsx(Text, { dimColor: true, children: " ^C interrupt" }) }))] }) })] }));
+                        }, limit: 10 }), _jsxs(Text, { dimColor: true, italic: true, children: ['↑↓', " navigate ", '•', " Enter select ", '•', " keep typing to filter"] })] })), showFilePicker && filteredFiles.length > 0 && !showCommandPicker && (_jsxs(Box, { flexDirection: "column", paddingX: 3, marginX: 0, paddingY: 0, children: [_jsxs(Box, { gap: 1, marginBottom: 0, children: [_jsx(Text, { dimColor: true, bold: true, children: "Files" }), _jsxs(Text, { dimColor: true, children: ["(", filteredFiles.length, ")"] })] }), _jsx(SelectInput, { items: filteredFiles.map((f) => ({
+                            label: f,
+                            value: f,
+                        })), isFocused: true, onSelect: (item) => {
+                            // Replace @query with the selected file path
+                            const newValue = value.replace(/@\S*$/, '@' + item.value + ' ');
+                            onChange(newValue);
+                        }, limit: 10 }), _jsxs(Text, { dimColor: true, italic: true, children: ['↑↓', " navigate ", '•', " Enter select ", '•', " keep typing to filter"] })] })), searchMode && (_jsxs(Box, { paddingX: 3, children: [_jsxs(Text, { color: "cyan", dimColor: true, children: ['🔍', " reverse-i-search: "] }), _jsx(Text, { color: "cyan", bold: true, children: searchQuery || '' }), _jsx(Text, { dimColor: true, children: " (Enter to select, Esc to cancel)" })] })), imageChips.length > 0 && !disabled && (_jsxs(Box, { paddingX: 3, gap: 1, children: [imageChips.map((_, i) => (_jsxs(Text, { color: "blue", bold: true, children: ["[Image #", i + 1, "]"] }, i))), _jsxs(Text, { dimColor: true, children: ["(", imageChips.length, " pasted)"] })] })), stash.length > 0 && !disabled && !searchMode && (_jsxs(Box, { paddingX: 3, children: [_jsxs(Text, { color: "magenta", dimColor: true, children: ['⚑', " Stashed: ", truncate(stash, 40), " "] }), _jsx(Text, { dimColor: true, children: "(Ctrl+S to restore)" })] })), _jsx(Box, { paddingX: 2, children: _jsxs(Box, { flexGrow: 1, children: [_jsx(Box, { flexShrink: 0, width: 2, children: disabled ? (_jsx(Text, { color: "magentaBright", children: _jsx(Spinner, { type: "dots" }) })) : (_jsx(Text, { color: "magentaBright", bold: true, children: '❯' })) }), _jsx(Box, { flexGrow: 1, children: _jsx(TextInput, { value: value, onChange: onChange, onSubmit: handleSubmit, placeholder: disabled ? 'Queue a message... (sent after current task)' : 'Type a message...', showCursor: true, focus: !pickerActive }) }), disabled && (_jsx(Box, { flexShrink: 0, children: _jsx(Text, { dimColor: true, children: " ^C interrupt" }) }))] }) })] }));
 });
 // ─── App ───
 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
@@ -983,12 +1348,14 @@ function estimateLines(item, cols) {
             return totalLines + markdownExpansion + 2; // marginTop=1 + padding
         }
         case 'error': return totalLines + 2;
-        case 'tool-call': return 2; // single row + marginTop=1
-        case 'tool-result': return 1;
+        case 'tool-call': return 2;
+        case 'tool-result': return Math.max(1, totalLines);
         case 'tool-blocked': return 1;
-        case 'diff': return lines.length + 2; // header + each diff line + footer
-        case 'system': return 1;
+        case 'tool-group': return item.collapsed ? 2 : (item.children?.length ?? 0) * 2;
+        case 'diff': return lines.length + 2;
+        case 'system': return Math.max(1, totalLines);
     }
+    return totalLines;
 }
 function useScrollableItems(items, availableHeight, cols, isLoading, streamLineCount = 0) {
     const [scrollOffset, setScrollOffset] = useState(0);
@@ -1004,7 +1371,7 @@ function useScrollableItems(items, availableHeight, cols, isLoading, streamLineC
         if (isLoading && autoScroll.current)
             setScrollOffset(0);
     }, [isLoading]);
-    const scrollUp = useCallback((amount = 3) => {
+    const scrollUp = useCallback((amount = 5) => {
         setScrollOffset((prev) => {
             const maxOffset = Math.max(items.length - 1, 0);
             const next = Math.min(prev + amount, maxOffset);
@@ -1012,7 +1379,7 @@ function useScrollableItems(items, availableHeight, cols, isLoading, streamLineC
             return next;
         });
     }, [items.length]);
-    const scrollDown = useCallback((amount = 3) => {
+    const scrollDown = useCallback((amount = 5) => {
         setScrollOffset((prev) => {
             const next = Math.max(prev - amount, 0);
             if (next === 0)
@@ -1053,6 +1420,8 @@ function App({ config }) {
     const [thinkStart, setThinkStart] = useState(null);
     const [showBanner, setShowBanner] = useState(true);
     const [totalTokens, setTotalTokens] = useState(0);
+    const [contextPercent, setContextPercent] = useState(0);
+    const [rateLimitWarn, setRateLimitWarn] = useState(false);
     const [sessionList, setSessionList] = useState(null);
     const [showSetup, setShowSetup] = useState(false);
     const [currentMode, setCurrentMode] = useState(agent?.getPermissionMode() ?? 'default');
@@ -1065,6 +1434,7 @@ function App({ config }) {
     useEffect(() => { modelsRef.current = models; }, [models]);
     const nextId = () => ++counter.current;
     const MAX_DISPLAY_ITEMS = 2000;
+    const TOOL_GROUP_THRESHOLD = 3;
     const add = useCallback((kind, text, meta, hint) => {
         setItems((prev) => {
             const next = [...prev, { id: nextId(), kind, text, meta, hint }];
@@ -1075,6 +1445,29 @@ function App({ config }) {
             setShowBanner(false);
         }
     }, []);
+    const collapseToolGroups = useCallback(() => {
+        setItems(prev => {
+            const isToolItem = (k) => k === 'tool-call' || k === 'tool-result';
+            let i = prev.length - 1;
+            while (i >= 0 && isToolItem(prev[i].kind))
+                i--;
+            const toolStart = i + 1;
+            const toolItems = prev.slice(toolStart);
+            if (toolItems.length < TOOL_GROUP_THRESHOLD)
+                return prev;
+            const group = {
+                id: nextId(),
+                kind: 'tool-group',
+                text: `Ran ${Math.ceil(toolItems.length / 2)} tools`,
+                children: toolItems,
+                collapsed: true,
+            };
+            return [...prev.slice(0, toolStart), group];
+        });
+    }, []);
+    const toggleToolGroups = useCallback(() => {
+        setItems(prev => prev.map(item => item.kind === 'tool-group' ? { ...item, collapsed: !item.collapsed } : item));
+    }, []);
     // Register agent event handlers ONCE
     useEffect(() => {
         const onThinkingStart = () => {
@@ -1126,9 +1519,18 @@ function App({ config }) {
             streamBuffer = '';
             setStreamText('');
             setReasoningText('');
+            collapseToolGroups();
             if (full.trim()) {
                 add('assistant', full);
             }
+            // Auto-save session after each assistant turn
+            if (agent) {
+                const msgs = agent.getMessages();
+                if (msgs.length > 0) {
+                    saveCrashState(sessionId, msgs, modelsRef.current[0] || 'unknown', costTracker.getState())
+                        .catch(() => { });
+                }
+            }
         };
         let reasoningBuffer = '';
         let reasoningFlushTimer = null;
@@ -1142,9 +1544,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) {
@@ -1198,6 +1604,8 @@ function App({ config }) {
             const lower = reason?.toLowerCase() || '';
             if (lower.includes('rate limit') || lower.includes('429')) {
                 hint = 'Rate limited. Try /model to switch models, or wait a moment.';
+                setRateLimitWarn(true);
+                setTimeout(() => setRateLimitWarn(false), 120_000);
             }
             else if (lower.includes('auth') || lower.includes('401') || lower.includes('api key')) {
                 hint = 'Authentication failed. Run /setup to reconfigure your API key.';
@@ -1217,6 +1625,7 @@ function App({ config }) {
             add('system', `Context compressed: ${formatTokens(info.saved)} tokens saved (${formatTokens(info.before)} \u2192 ${formatTokens(info.after)})`);
         };
         const onContextUsage = (info) => {
+            setContextPercent(info.percentage);
             if (info.percentage > 80) {
                 add('system', `Context usage: ${info.percentage}% (${formatTokens(info.tokens)}/${formatTokens(info.maxTokens)} tokens)`);
             }
@@ -1264,11 +1673,60 @@ function App({ config }) {
             currentAgent.off('context:usage', onContextUsage);
         };
     }, [add, agentVersion]);
-    // Confirmation bridge (event-driven)
+    // Crash recovery: check for recoverable session on startup
+    useEffect(() => {
+        loadCrashState().then(state => {
+            if (state && state.messages.length > 0 && agent) {
+                add('system', `Recoverable session found (${state.messages.length} messages). Use /resume to restore.`);
+            }
+        }).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]);
+    // Idle session nudge: suggest /clear after 75+ minutes of inactivity
+    const lastActivityRef = useRef(Date.now());
+    const idleNudgedRef = useRef(false);
+    useEffect(() => {
+        const IDLE_THRESHOLD_MS = 75 * 60_000; // 75 minutes
+        const timer = setInterval(() => {
+            const idle = Date.now() - lastActivityRef.current;
+            if (idle >= IDLE_THRESHOLD_MS && !idleNudgedRef.current && agent && agent.getMessages().length > 10) {
+                idleNudgedRef.current = true;
+                add('system', 'Session idle for 75+ minutes. Consider /clear to optimize token usage, or /compact to compress context.');
+            }
+        }, 60_000);
+        return () => clearInterval(timer);
+    }, [add]);
+    // Terminal notification on task completion
+    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 = () => {
+            // `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');
+            }
+        };
+        currentAgent.on('stream:end', onStreamEnd);
+        return () => { currentAgent.off('stream:end', onStreamEnd); };
+    }, [agentVersion]);
+    // 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);
@@ -1279,12 +1737,25 @@ function App({ config }) {
         if (banner)
             add('system', banner);
     }, [add]);
-    const handleConfirm = useCallback((ok) => {
-        if (pendingConfirm) {
-            pendingConfirm.resolve(ok);
-            pendingConfirm = null;
+    const handleConfirm = useCallback((ok, always) => {
+        const current = confirmQueue.shift();
+        if (current) {
+            if (ok && always)
+                alwaysAllowedTools.add(current.toolName);
+            if (!ok) {
+                recentDenials.push({
+                    toolName: current.toolName,
+                    args: JSON.stringify(current.args).slice(0, 100),
+                    timestamp: Date.now(),
+                });
+                if (recentDenials.length > 20)
+                    recentDenials.shift();
+            }
+            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();
@@ -1318,6 +1789,7 @@ function App({ config }) {
                 '  /checkpoint   \u2014 create git checkpoint',
                 '  /undo         \u2014 undo last checkpoint',
                 '  /checkpoints  \u2014 list recent checkpoints',
+                '  /worktree     \u2014 manage git worktrees (list/create/remove/cleanup)',
                 '  /git          \u2014 show git context',
                 '',
                 'Project:',
@@ -1339,6 +1811,9 @@ function App({ config }) {
                 '  /setup        \u2014 reconfigure API key, URL & models',
                 '  /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',
                 '  /hooks        \u2014 show lifecycle hooks',
@@ -1358,10 +1833,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) => {
@@ -1380,6 +1852,8 @@ function App({ config }) {
             setShowBanner(true);
             costTracker.reset();
             setTotalTokens(0);
+            setContextPercent(0);
+            setRateLimitWarn(false);
             sessionId = generateSessionId();
             return true;
         }
@@ -1432,7 +1906,35 @@ function App({ config }) {
             });
             return true;
         }
-        if (cmd === '/load') {
+        if (cmd === '/load' || cmd === '/resume') {
+            if (cmd === '/resume') {
+                loadCrashState().then(async (state) => {
+                    if (state && state.messages.length > 0 && agent) {
+                        agent.loadMessages(state.messages);
+                        sessionId = state.sessionId;
+                        if (state.costState) {
+                            costTracker.restore(state.costState);
+                            setTotalTokens(state.costState.totalTokens);
+                        }
+                        add('system', `Resumed session with ${state.messages.length} messages.`);
+                        showBannerRef.current = false;
+                        setShowBanner(false);
+                        await clearCrashState();
+                    }
+                    else {
+                        const sessions = await listSessions();
+                        if (sessions.length === 0) {
+                            add('system', 'No saved sessions or crash recovery data found.');
+                        }
+                        else {
+                            setSessionList(sessions);
+                        }
+                    }
+                }).catch(() => {
+                    add('system', 'Failed to load crash recovery data.');
+                });
+                return true;
+            }
             listSessions().then((sessions) => {
                 if (sessions.length === 0) {
                     add('system', 'No saved sessions found.');
@@ -1443,20 +1945,43 @@ function App({ config }) {
             });
             return true;
         }
+        if (cmd === '/fork') {
+            const pointStr = text.split(' ')[1];
+            const point = pointStr ? parseInt(pointStr, 10) : agent?.getMessages().length;
+            if (!point || point <= 0) {
+                add('system', 'Usage: /fork [message_number] — fork conversation from a specific point');
+                return true;
+            }
+            forkSession(sessionId, point).then(({ id, meta }) => {
+                add('system', `Forked to new session: ${meta.name} (${id.slice(0, 8)})`);
+                agent.loadMessages(agent.getMessages().slice(0, point));
+                sessionId = id;
+            }).catch((err) => {
+                add('error', `Fork failed: ${err.message}`);
+            });
+            return true;
+        }
         if (cmd === '/shortcuts') {
             const shortcuts = [
                 'Ctrl+C \u2014 interrupt agent / clear input / double-press to quit',
                 'Ctrl+D \u2014 exit (when input is empty)',
                 'Ctrl+L \u2014 clear screen & conversation',
+                'Ctrl+O \u2014 toggle collapsed tool groups',
                 'Ctrl+U \u2014 clear entire input line',
                 'Ctrl+W \u2014 delete last word',
                 'Ctrl+K \u2014 delete to end of line',
                 'Ctrl+S \u2014 stash / restore current prompt',
+                'Ctrl+V \u2014 paste image from clipboard',
+                'Ctrl+R \u2014 reverse history search',
+                'Ctrl+X Ctrl+E \u2014 open in external editor ($EDITOR)',
+                'Alt+Enter \u2014 insert newline (multiline)',
                 'Tab \u2014 autocomplete slash commands',
                 '\u2191/\u2193 \u2014 navigate input history',
-                'Shift+\u2191 / PageUp \u2014 scroll chat up',
-                'Shift+\u2193 / PageDown \u2014 scroll chat down',
-                'Y/N \u2014 confirm or deny tool execution',
+                'Shift+\u2191 \u2014 scroll up (5 items)',
+                'Shift+\u2193 \u2014 scroll down (5 items)',
+                'PageUp \u2014 scroll up fast (15 items)',
+                'PageDown \u2014 scroll down fast (15 items)',
+                'Y/A/N \u2014 allow / always allow / deny tool execution',
                 'Esc \u2014 quit',
                 '',
                 'Copy \u2014 Cmd+C (Mac) / Ctrl+Shift+C (Linux)',
@@ -1468,6 +1993,32 @@ function App({ config }) {
             shortcuts.forEach((s) => add('system', s));
             return true;
         }
+        if (cmd === '/permissions') {
+            add('system', `Permission Mode: ${currentMode.toUpperCase()} — ${getModeDescription(currentMode)}`);
+            if (alwaysAllowedTools.size > 0) {
+                add('system', `Always Allowed (session): ${[...alwaysAllowedTools].join(', ')}`);
+            }
+            const scopedRules = getScopedPermissionRules();
+            if (scopedRules.length > 0) {
+                add('system', 'Scoped Rules:');
+                scopedRules.forEach(r => {
+                    const spec = r.prefix ? `${r.tool}(${r.prefix}*)` : r.tool;
+                    add('system', `  ${r.action === 'allow' ? '✓' : '✗'} ${spec}${r.regex ? ` [regex: ${r.regex}]` : ''}`);
+                });
+            }
+            if (recentDenials.length > 0) {
+                add('system', 'Recent Denials:');
+                const recent = recentDenials.slice(-10);
+                recent.forEach(d => {
+                    const ago = Math.round((Date.now() - d.timestamp) / 1000);
+                    add('system', `  ✗ ${d.toolName} (${ago}s ago) ${d.args}`);
+                });
+            }
+            else {
+                add('system', 'No recent denials.');
+            }
+            return true;
+        }
         if (cmd === '/settings') {
             setEditingSettings(true);
             return true;
@@ -1560,6 +2111,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();
@@ -1610,6 +2182,10 @@ function App({ config }) {
             commandsSummary(customCommands).split('\n').forEach((l) => add('system', l));
             return true;
         }
+        if (cmd === '/skills') {
+            skillsSummary(loadedSkills).split('\n').forEach((l) => add('system', l));
+            return true;
+        }
         if (cmd === '/delegate') {
             const prompt = text.slice(10).trim();
             if (!prompt) {
@@ -1677,6 +2253,130 @@ function App({ config }) {
             }).catch(() => add('error', 'Failed to list checkpoints.'));
             return true;
         }
+        if (cmd === '/worktree') {
+            const subArgs = text.slice(10).trim().split(/\s+/);
+            const subCmd = subArgs[0] || 'list';
+            const cwd = process.cwd();
+            if (subCmd === 'list' || subCmd === 'ls') {
+                listWorktrees(cwd).then(wts => {
+                    if (wts.length === 0)
+                        add('system', 'No active worktrees.');
+                    else {
+                        add('system', `${wts.length} worktree(s):`);
+                        wts.forEach(wt => add('system', `  ${wt.branch} → ${wt.path}`));
+                    }
+                }).catch(err => add('error', `Failed to list worktrees: ${err.message}`));
+            }
+            else if (subCmd === 'create' || subCmd === 'new') {
+                const name = subArgs[1] || `work-${Date.now().toString(36)}`;
+                createWorktree(name, cwd).then(wt => {
+                    add('system', `Worktree created: ${wt.branch} → ${wt.path}`);
+                    add('system', `cd ${wt.path} to work in isolation`);
+                }).catch(err => add('error', `Failed to create worktree: ${err.message}`));
+            }
+            else if (subCmd === 'remove' || subCmd === 'rm') {
+                const branchOrId = subArgs[1];
+                if (!branchOrId) {
+                    add('system', 'Usage: /worktree remove <branch-or-agent-id>');
+                    return true;
+                }
+                listWorktrees(cwd).then(wts => {
+                    const wt = wts.find(w => w.branch.includes(branchOrId) || w.agentId.includes(branchOrId));
+                    if (!wt) {
+                        add('error', `Worktree not found: ${branchOrId}`);
+                        return;
+                    }
+                    removeWorktree(wt, cwd).then(() => {
+                        add('system', `Worktree removed: ${wt.branch}`);
+                    }).catch(err => add('error', `Failed to remove: ${err.message}`));
+                }).catch(err => add('error', `Failed: ${err.message}`));
+            }
+            else if (subCmd === 'cleanup') {
+                cleanupStaleWorktrees(cwd).then(count => {
+                    add('system', count > 0 ? `Cleaned up ${count} stale worktree(s).` : 'No stale worktrees found.');
+                }).catch(err => add('error', `Cleanup failed: ${err.message}`));
+            }
+            else {
+                add('system', 'Usage: /worktree [list|create <name>|remove <branch>|cleanup]');
+            }
+            return true;
+        }
+        if (cmd === '/plugin') {
+            const subArgs = text.slice(8).trim().split(/\s+/);
+            const subCmd = subArgs[0] || 'list';
+            const cwd = process.cwd();
+            if (subCmd === 'list' || subCmd === 'ls') {
+                listInstalledPlugins(cwd).then(plugins => {
+                    if (plugins.length === 0) {
+                        add('system', 'No plugins installed. Use /plugin install <source> to add one.');
+                    }
+                    else {
+                        add('system', `${plugins.length} plugin(s) installed:`);
+                        plugins.forEach(p => {
+                            const status = p.enabled ? 'enabled' : 'disabled';
+                            add('system', `  ${p.name} v${p.version} [${status}]`);
+                        });
+                    }
+                }).catch(err => add('error', `Failed to list plugins: ${err.message}`));
+            }
+            else if (subCmd === 'install') {
+                const source = subArgs[1];
+                if (!source) {
+                    add('system', 'Usage: /plugin install <path-or-git-url>');
+                    return true;
+                }
+                add('system', `Installing plugin from ${source}...`);
+                installPlugin(cwd, source).then(result => {
+                    if (result) {
+                        add('system', `Plugin installed: ${result.name} v${result.version}`);
+                        add('system', 'Restart session to load new plugin tools.');
+                    }
+                    else {
+                        add('system', 'Plugin already installed.');
+                    }
+                }).catch(err => add('error', `Install failed: ${err.message}`));
+            }
+            else if (subCmd === 'uninstall' || subCmd === 'remove') {
+                const name = subArgs[1];
+                if (!name) {
+                    add('system', 'Usage: /plugin uninstall <name>');
+                    return true;
+                }
+                uninstallPlugin(cwd, name).then(ok => {
+                    add(ok ? 'system' : 'error', ok ? `Plugin uninstalled: ${name}` : `Plugin not found: ${name}`);
+                }).catch(err => add('error', `Uninstall failed: ${err.message}`));
+            }
+            else if (subCmd === 'enable') {
+                const name = subArgs[1];
+                if (!name) {
+                    add('system', 'Usage: /plugin enable <name>');
+                    return true;
+                }
+                enablePlugin(cwd, name).then(ok => {
+                    add(ok ? 'system' : 'error', ok ? `Plugin enabled: ${name}` : `Plugin not found or already enabled: ${name}`);
+                }).catch(err => add('error', `Enable failed: ${err.message}`));
+            }
+            else if (subCmd === 'disable') {
+                const name = subArgs[1];
+                if (!name) {
+                    add('system', 'Usage: /plugin disable <name>');
+                    return true;
+                }
+                disablePlugin(cwd, name).then(ok => {
+                    add(ok ? 'system' : 'error', ok ? `Plugin disabled: ${name}` : `Plugin not found: ${name}`);
+                }).catch(err => add('error', `Disable failed: ${err.message}`));
+            }
+            else {
+                add('system', 'Usage: /plugin [list|install <source>|uninstall <name>|enable <name>|disable <name>]');
+            }
+            return true;
+        }
+        if (cmd === '/notify') {
+            const message = text.slice(8).trim() || 'Test notification from Scalix';
+            sendNotification('Scalix', message);
+            add('system', `Notification sent (terminal: ${getTerminalType()})`);
+            return true;
+        }
         if (cmd === '/commit') {
             setIsLoading(true);
             setStatus('thinking');
@@ -1684,17 +2384,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}`);
@@ -1715,7 +2416,8 @@ function App({ config }) {
                     }
                     add('system', `Commit message: ${cleanMsg}`);
                     try {
-                        const result = execFileSync('git', ['commit', '-m', cleanMsg], { encoding: 'utf-8', timeout: TOOL_DEFAULTS.gitTimeoutMs, cwd: process.cwd() }).trim();
+                        const fullMsg = cleanMsg + `\n\nCo-Authored-By: ${GIT_BOT_IDENTITY.name} <${GIT_BOT_IDENTITY.email}>`;
+                        const result = (await execFileAsync('git', ['commit', '-m', fullMsg], gitOpts)).stdout.trim();
                         add('system', result);
                     }
                     catch (e) {
@@ -1740,26 +2442,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 { }
                     }
@@ -1795,7 +2498,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}.`);
@@ -1846,30 +2550,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') {
@@ -2096,10 +2803,72 @@ function App({ config }) {
     useEffect(() => { isLoadingRef.current = isLoading; }, [isLoading]);
     const multilineRef = useRef([]);
     const messageQueueRef = useRef([]);
+    const pendingImagesRef = useRef([]);
+    // 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);
+        if (triggeredSkill) {
+            finalText = `${getSkillContent(triggeredSkill, 'full')}\n\n---\nUser request: ${finalText}`;
+            add('system', `Skill activated: ${triggeredSkill.name}`);
+        }
+        if (finalText.startsWith('!')) {
+            const shellCmd = finalText.slice(1).trim();
+            if (!shellCmd)
+                return;
+            add('system', `$ ${shellCmd}`);
+            try {
+                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)`;
+                    }
+                    add('system', output);
+                }
+            }
+            catch (err) {
+                add('error', err.stderr?.trim() || err.message);
+            }
+            return;
+        }
+        const correction = detectCorrection(finalText);
+        if (correction) {
+            addNote(process.cwd(), `[correction] ${correction}`).catch((err) => { logger.warn('Failed to save correction note', { error: err.message }); });
+        }
+        const images = pendingImagesRef.current.length > 0 ? [...pendingImagesRef.current] : undefined;
+        if (images) {
+            add('user', `${finalText} [${images.length} image${images.length > 1 ? 's' : ''} attached]`);
+        }
+        else {
+            add('user', finalText);
+        }
+        pendingImagesRef.current = [];
+        setStatus('thinking');
+        setThinkStart(Date.now());
+        try {
+            const result = await agent.send(finalText, images);
+            if (!result || !result.trim()) {
+                add('system', 'Agent returned no response.');
+            }
+        }
+        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);
@@ -2130,68 +2899,35 @@ function App({ config }) {
         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('!')) {
-            const shellCmd = finalText.slice(1).trim();
-            if (!shellCmd)
-                return;
-            add('system', `$ ${shellCmd}`);
-            try {
-                let output = execSync(shellCmd, { encoding: 'utf-8', timeout: HEADLESS_DEFAULTS.commandTimeoutMs, cwd: process.cwd() }).trim();
-                if (output) {
-                    if (output.length > 2000) {
-                        output = output.slice(0, 2000) + `\n... (${(output.length - 2000).toLocaleString()} chars truncated)`;
-                    }
-                    add('system', output);
-                }
-            }
-            catch (err) {
-                add('error', err.stderr?.trim() || err.message);
-            }
+            await processFinalizedInput(finalText);
             return;
         }
-        const correction = detectCorrection(finalText);
-        if (correction) {
-            addNote(process.cwd(), `[correction] ${correction}`).catch((err) => { logger.warn('Failed to save correction note', { error: err.message }); });
-        }
-        add('user', finalText);
         setIsLoading(true);
         setStatus('thinking');
         setThinkStart(Date.now());
         try {
-            const result = await agent.send(finalText);
-            if (!result || !result.trim()) {
-                add('system', 'Agent returned no response.');
-            }
-        }
-        catch (e) {
-            add('error', e.message || 'Unknown error');
+            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);
@@ -2227,10 +2963,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');
@@ -2250,8 +2983,23 @@ function App({ config }) {
         setShowBanner(true);
         costTracker.reset();
         setTotalTokens(0);
+        setContextPercent(0);
+        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 {
@@ -2277,7 +3025,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;
         }
@@ -2300,7 +3048,7 @@ function App({ config }) {
         const reasonLines = reasoningText ? (reasoningText.match(/\n/g) || []).length + 1 : 0;
         return textLines + reasonLines;
     }, [isLoading, streamText, reasoningText]);
-    const { visibleItems, scrollUp, scrollDown, scrollToBottom, isAtBottom, } = useScrollableItems(items, chatHeight, cols, isLoading, streamLineCount);
+    const { visibleItems, scrollUp, scrollDown, scrollToBottom, isAtBottom, isAtTop, } = useScrollableItems(items, chatHeight, cols, isLoading, streamLineCount);
     const scrollToBottomRef = useRef(scrollToBottom);
     scrollToBottomRef.current = scrollToBottom;
     const handleSubmitRef = useRef(handleSubmit);
@@ -2312,7 +3060,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 }), _jsxs(Box, { flexDirection: "column", flexGrow: 1, flexShrink: 1, minHeight: 6, overflowY: "hidden", children: [showBanner && !isLoading && _jsx(WelcomeScreen, {}), 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, 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) => {
                         agent.setModel(v);
                         setModels([v]);
                         setSelectingModel(false);
@@ -2354,7 +3102,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 })) })] }));
+                    }, 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() {