orquesta-cli 0.2.112 → 0.2.116

package/dist/agents/planner/index.js

@@ -71,10 +71,11 @@ Choose one of your 3 tools now.`,
                         });
                         logger.warn(`Planning LLM retry attempt ${attempt}/${MAX_RETRIES}`, { lastError: lastError?.message });
                     }
+                    const toolChoiceAuto = /^(1|true|yes|on)$/i.test(process.env['ORQUESTA_TOOL_CHOICE_AUTO'] || '');
                     const response = await this.llmClient.chatCompletion({
                         messages,
                         tools: planningTools,
-                        tool_choice: 'required',
+                        tool_choice: toolChoiceAuto ? 'auto' : 'required',
                         temperature: 0.7,
                         max_tokens: 2000,
                         ...(this.modelOverride ? { model: this.modelOverride } : {}),

package/dist/cli.js

@@ -30,8 +30,15 @@ import { syncOrquestaConfigs } from './orquesta/config-sync.js';
 import { scanProviders, scanProvider, toEndpointConfig } from './core/config/auto-detect.js';
 import { getProviders, refreshCatalogFromServer } from './core/config/providers.js';
 import { shouldShowOnboarding, runOnboarding } from './core/onboarding.js';
+import { APP_VERSION } from './constants.js';
 const require = createRequire(import.meta.url);
-const packageJson = require('../package.json');
+let packageJson;
+try {
+    packageJson = require('../package.json');
+}
+catch {
+    packageJson = { version: APP_VERSION };
+}
 const program = new Command();
 async function readPromptFromStdin() {
     if (process.stdin.isTTY)

package/dist/constants.d.ts

@@ -5,5 +5,5 @@ export declare const DOCS_DIR: string;
 export declare const BACKUPS_DIR: string;
 export declare const PROJECTS_DIR: string;
 export declare function cwdToProjectSegment(cwd?: string): string;
-export declare const APP_VERSION = "0.2.45";
+export declare const APP_VERSION = "0.2.115";
 //# sourceMappingURL=constants.d.ts.map

package/dist/constants.js

@@ -12,5 +12,5 @@ export function cwdToProjectSegment(cwd = process.cwd()) {
         .replace(/[:*?"<>|]/g, '')
         .replace(/^-+/, '');
 }
-export const APP_VERSION = '0.2.45';
+export const APP_VERSION = '0.2.115';
 //# sourceMappingURL=constants.js.map

package/dist/core/git-auto-updater.d.ts

@@ -0,0 +1,58 @@
+export type UpdateStatus = {
+    type: 'checking';
+} | {
+    type: 'no_update';
+} | {
+    type: 'first_run';
+    step: number;
+    totalSteps: number;
+    message: string;
+} | {
+    type: 'updating';
+    step: number;
+    totalSteps: number;
+    message: string;
+} | {
+    type: 'complete';
+    needsRestart: boolean;
+    message: string;
+} | {
+    type: 'error';
+    message: string;
+} | {
+    type: 'skipped';
+    reason: string;
+};
+export type StatusCallback = (status: UpdateStatus) => void;
+export declare class GitAutoUpdater {
+    private repoUrl;
+    private repoDir;
+    private commitFile;
+    private enabled;
+    private onStatus;
+    constructor(options?: {
+        repoUrl?: string;
+        enabled?: boolean;
+        onStatus?: StatusCallback;
+    });
+    setStatusCallback(callback: StatusCallback): void;
+    private emitStatus;
+    run(options?: {
+        noUpdate?: boolean;
+    }): Promise<boolean>;
+    private runBinaryMode;
+    private getRemoteCommit;
+    private getSavedCommit;
+    private saveCommit;
+    private updateBinary;
+    private initialSetup;
+    private pullAndUpdate;
+    private freshClone;
+    private rebuildAndLink;
+    private copyBinariesInternal;
+    private ensurePathConfigured;
+    private unlinkNpm;
+    private cleanupRepo;
+}
+export default GitAutoUpdater;
+//# sourceMappingURL=git-auto-updater.d.ts.map

package/dist/core/git-auto-updater.js

@@ -0,0 +1,374 @@
+import { spawn } from 'child_process';
+import fs, { createReadStream, createWriteStream } from 'fs';
+import { rm, copyFile, chmod } from 'fs/promises';
+import { pipeline } from 'stream/promises';
+import path from 'path';
+import os from 'os';
+import zlib from 'zlib';
+import { logger } from '../utils/logger.js';
+function isRunningAsBinary() {
+    const execPath = process.execPath;
+    const isNodeRuntime = execPath.includes('node') || execPath.includes('nodejs');
+    return !isNodeRuntime;
+}
+function execAsync(command, options = {}) {
+    return new Promise((resolve, reject) => {
+        const [cmd, ...args] = command.split(' ');
+        const child = spawn(cmd, args, {
+            cwd: options.cwd,
+            shell: true,
+            stdio: 'pipe',
+        });
+        let stdout = '';
+        let stderr = '';
+        child.stdout?.on('data', (data) => {
+            stdout += data.toString();
+        });
+        child.stderr?.on('data', (data) => {
+            stderr += data.toString();
+        });
+        child.on('close', (code) => {
+            if (code === 0) {
+                resolve({ stdout, stderr });
+            }
+            else {
+                const error = new Error(`Command failed: ${command}`);
+                error.stdout = stdout;
+                error.stderr = stderr;
+                error.code = code;
+                reject(error);
+            }
+        });
+        child.on('error', (err) => {
+            reject(err);
+        });
+    });
+}
+export class GitAutoUpdater {
+    repoUrl = 'https://github.com/A2G-Dev-Space/Local-CLI.git';
+    repoDir;
+    commitFile;
+    enabled = true;
+    onStatus = null;
+    constructor(options) {
+        this.repoDir = path.join(os.homedir(), '.local-cli', 'repo');
+        this.commitFile = path.join(os.homedir(), '.local-cli', 'current-commit');
+        if (options?.repoUrl) {
+            this.repoUrl = options.repoUrl;
+        }
+        if (options?.enabled !== undefined) {
+            this.enabled = options.enabled;
+        }
+        if (options?.onStatus) {
+            this.onStatus = options.onStatus;
+        }
+    }
+    setStatusCallback(callback) {
+        this.onStatus = callback;
+    }
+    emitStatus(status) {
+        if (this.onStatus) {
+            this.onStatus(status);
+        }
+    }
+    async run(options = {}) {
+        logger.enter('GitAutoUpdater.run', {
+            noUpdate: options.noUpdate,
+            enabled: this.enabled,
+            repoDir: this.repoDir
+        });
+        if (options.noUpdate || !this.enabled) {
+            logger.flow('Git auto-update disabled - skipping');
+            this.emitStatus({ type: 'skipped', reason: 'disabled' });
+            return false;
+        }
+        this.emitStatus({ type: 'checking' });
+        try {
+            if (isRunningAsBinary() && fs.existsSync(this.repoDir)) {
+                logger.flow('Cleaning up leftover repo from previous version');
+                await this.cleanupRepo();
+            }
+            if (isRunningAsBinary()) {
+                return await this.runBinaryMode();
+            }
+            logger.flow('Checking repository directory');
+            if (!fs.existsSync(this.repoDir)) {
+                logger.flow('First run detected - need initial setup');
+                return await this.initialSetup();
+            }
+            else {
+                return await this.pullAndUpdate();
+            }
+        }
+        catch (error) {
+            logger.error('Git auto-update failed', error);
+            this.emitStatus({ type: 'error', message: 'Auto-update failed, continuing with current version' });
+        }
+        return false;
+    }
+    async runBinaryMode() {
+        logger.flow('Running in binary mode - using ls-remote for update check');
+        try {
+            const remoteCommit = await this.getRemoteCommit();
+            if (!remoteCommit) {
+                logger.error('Failed to get remote commit');
+                this.emitStatus({ type: 'error', message: 'Failed to check for updates' });
+                return false;
+            }
+            const savedCommit = this.getSavedCommit();
+            logger.debug('Version check', { remote: remoteCommit.slice(0, 7), saved: savedCommit?.slice(0, 7) || 'none' });
+            if (savedCommit === remoteCommit) {
+                logger.flow('Already up to date');
+                this.emitStatus({ type: 'no_update' });
+                return false;
+            }
+            logger.flow('Update available, starting update process');
+            return await this.updateBinary(remoteCommit);
+        }
+        catch (error) {
+            logger.error('Binary mode update failed', error);
+            this.emitStatus({ type: 'error', message: 'Update check failed' });
+            return false;
+        }
+    }
+    async getRemoteCommit() {
+        try {
+            const result = await execAsync(`git ls-remote ${this.repoUrl} refs/heads/main`);
+            const match = result.stdout.match(/^([a-f0-9]+)/);
+            return match && match[1] ? match[1] : null;
+        }
+        catch (error) {
+            logger.error('Failed to get remote commit via ls-remote', error);
+            return null;
+        }
+    }
+    getSavedCommit() {
+        try {
+            if (fs.existsSync(this.commitFile)) {
+                return fs.readFileSync(this.commitFile, 'utf-8').trim();
+            }
+        }
+        catch (error) {
+            logger.debug('Failed to read saved commit: ' + (error instanceof Error ? error.message : String(error)));
+        }
+        return null;
+    }
+    saveCommit(commit) {
+        try {
+            const dir = path.dirname(this.commitFile);
+            if (!fs.existsSync(dir)) {
+                fs.mkdirSync(dir, { recursive: true });
+            }
+            fs.writeFileSync(this.commitFile, commit);
+            logger.debug('Saved commit hash: ' + commit.slice(0, 7));
+        }
+        catch (error) {
+            logger.debug('Failed to save commit: ' + (error instanceof Error ? error.message : String(error)));
+        }
+    }
+    async updateBinary(remoteCommit) {
+        const totalSteps = 3;
+        const isFirstRun = !this.getSavedCommit();
+        try {
+            const statusType = isFirstRun ? 'first_run' : 'updating';
+            this.emitStatus({ type: statusType, step: 1, totalSteps, message: 'Downloading update...' });
+            const parentDir = path.dirname(this.repoDir);
+            if (!fs.existsSync(parentDir)) {
+                fs.mkdirSync(parentDir, { recursive: true });
+            }
+            await execAsync(`git clone --depth 1 ${this.repoUrl} ${this.repoDir}`);
+            this.emitStatus({ type: statusType, step: 2, totalSteps, message: 'Installing update...' });
+            const success = await this.copyBinariesInternal();
+            if (!success) {
+                return false;
+            }
+            this.emitStatus({ type: statusType, step: 3, totalSteps, message: 'Finalizing...' });
+            await this.cleanupRepo();
+            this.saveCommit(remoteCommit);
+            const shell = process.env['SHELL'] || '/bin/bash';
+            const rcFile = shell.includes('zsh') ? '~/.zshrc' : '~/.bashrc';
+            const restartMsg = isFirstRun
+                ? `Setup complete! Run: source ${rcFile} && lcli`
+                : 'Update complete! Please restart.';
+            this.emitStatus({ type: 'complete', needsRestart: true, message: restartMsg });
+            return true;
+        }
+        catch (error) {
+            logger.error('Binary update failed', error);
+            await this.cleanupRepo();
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            this.emitStatus({ type: 'error', message: `Update failed: ${message}` });
+            return false;
+        }
+    }
+    async initialSetup() {
+        logger.enter('initialSetup', {
+            repoDir: this.repoDir,
+            repoUrl: this.repoUrl
+        });
+        const totalSteps = 4;
+        try {
+            this.emitStatus({ type: 'first_run', step: 1, totalSteps, message: 'Cloning repository...' });
+            const parentDir = path.dirname(this.repoDir);
+            if (!fs.existsSync(parentDir)) {
+                fs.mkdirSync(parentDir, { recursive: true });
+            }
+            await execAsync(`git clone ${this.repoUrl} ${this.repoDir}`);
+            this.emitStatus({ type: 'first_run', step: 2, totalSteps, message: 'Installing dependencies...' });
+            await execAsync('npm install', { cwd: this.repoDir });
+            this.emitStatus({ type: 'first_run', step: 3, totalSteps, message: 'Building project...' });
+            await execAsync('npm run build', { cwd: this.repoDir });
+            this.emitStatus({ type: 'first_run', step: 4, totalSteps, message: 'Creating global link...' });
+            await execAsync('npm link', { cwd: this.repoDir });
+            this.emitStatus({ type: 'complete', needsRestart: true, message: 'Setup complete! Please restart.' });
+            return true;
+        }
+        catch (error) {
+            logger.error('Initial setup failed', error);
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            this.emitStatus({ type: 'error', message: `Setup failed: ${message}` });
+            return false;
+        }
+    }
+    async pullAndUpdate() {
+        logger.debug('Checking for updates', { repoDir: this.repoDir });
+        try {
+            await execAsync('git fetch origin main', { cwd: this.repoDir });
+            const currentResult = await execAsync('git rev-parse HEAD', { cwd: this.repoDir });
+            const latestResult = await execAsync('git rev-parse origin/main', { cwd: this.repoDir });
+            const currentCommit = currentResult.stdout.trim();
+            const latestCommit = latestResult.stdout.trim();
+            if (currentCommit === latestCommit) {
+                logger.debug('Already up to date, no rebuild needed');
+                this.emitStatus({ type: 'no_update' });
+                return false;
+            }
+            logger.debug('Resetting to latest commit...', { from: currentCommit.slice(0, 7), to: latestCommit.slice(0, 7) });
+            await execAsync('git reset --hard origin/main', { cwd: this.repoDir });
+            return await this.rebuildAndLink();
+        }
+        catch (error) {
+            logger.error('Pull/reset failed, attempting fresh clone', error);
+            return await this.freshClone();
+        }
+    }
+    async freshClone() {
+        logger.flow('Performing fresh clone');
+        try {
+            this.emitStatus({ type: 'updating', step: 1, totalSteps: 4, message: 'Removing old repository...' });
+            await rm(this.repoDir, { recursive: true, force: true });
+            return await this.initialSetup();
+        }
+        catch (error) {
+            logger.error('Fresh clone failed', error);
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            this.emitStatus({ type: 'error', message: `Fresh clone failed: ${message}` });
+            return false;
+        }
+    }
+    async rebuildAndLink() {
+        const totalSteps = 3;
+        try {
+            this.emitStatus({ type: 'updating', step: 1, totalSteps, message: 'Updating dependencies...' });
+            await execAsync('npm install', { cwd: this.repoDir });
+            this.emitStatus({ type: 'updating', step: 2, totalSteps, message: 'Building project...' });
+            await execAsync('npm run build', { cwd: this.repoDir });
+            this.emitStatus({ type: 'updating', step: 3, totalSteps, message: 'Updating global link...' });
+            await execAsync('npm link', { cwd: this.repoDir });
+            this.emitStatus({ type: 'complete', needsRestart: true, message: 'Update complete! Please restart.' });
+            return true;
+        }
+        catch (buildError) {
+            logger.error('Build/link failed', buildError);
+            const message = buildError instanceof Error ? buildError.message : 'Unknown error';
+            this.emitStatus({ type: 'error', message: `Build failed: ${message}` });
+            return false;
+        }
+    }
+    async copyBinariesInternal() {
+        try {
+            const repoBinDir = path.join(this.repoDir, 'bin');
+            const installDir = path.join(os.homedir(), '.local', 'bin');
+            const lcliGzSrc = path.join(repoBinDir, 'lcli.gz');
+            const yogaSrc = path.join(repoBinDir, 'yoga.wasm');
+            const lcliDest = path.join(installDir, 'lcli');
+            const yogaDest = path.join(installDir, 'yoga.wasm');
+            if (!fs.existsSync(lcliGzSrc)) {
+                this.emitStatus({ type: 'error', message: 'Binary not found in repository (bin/lcli.gz)' });
+                return false;
+            }
+            if (!fs.existsSync(installDir)) {
+                fs.mkdirSync(installDir, { recursive: true });
+            }
+            await rm(lcliDest, { force: true });
+            await pipeline(createReadStream(lcliGzSrc), zlib.createGunzip(), createWriteStream(lcliDest));
+            await chmod(lcliDest, 0o755);
+            if (fs.existsSync(yogaSrc)) {
+                await copyFile(yogaSrc, yogaDest);
+            }
+            await this.ensurePathConfigured(installDir);
+            await this.unlinkNpm();
+            logger.debug('Binaries copied successfully');
+            return true;
+        }
+        catch (error) {
+            logger.error('Copy binaries internal failed', error);
+            return false;
+        }
+    }
+    async ensurePathConfigured(binDir) {
+        const pathExport = `export PATH="${binDir}:$PATH"`;
+        const marker = '# local-cli binary';
+        const shell = process.env['SHELL'] || '/bin/bash';
+        let rcFile;
+        if (shell.includes('zsh')) {
+            rcFile = path.join(os.homedir(), '.zshrc');
+        }
+        else {
+            rcFile = path.join(os.homedir(), '.bashrc');
+        }
+        try {
+            let content = '';
+            if (fs.existsSync(rcFile)) {
+                content = fs.readFileSync(rcFile, 'utf-8');
+            }
+            if (content.includes(marker)) {
+                logger.debug('PATH already configured (marker found)');
+                return;
+            }
+            const currentPath = process.env['PATH'] || '';
+            if (currentPath.split(':').includes(binDir)) {
+                logger.debug('PATH already contains binDir, adding marker for future reference');
+                fs.appendFileSync(rcFile, `\n${marker}\n# PATH already configured elsewhere\n`);
+                return;
+            }
+            const addition = `\n${marker}\n${pathExport}\n`;
+            fs.appendFileSync(rcFile, addition);
+            logger.debug('PATH configuration added to ' + rcFile);
+        }
+        catch (error) {
+            logger.debug('Failed to configure PATH: ' + (error instanceof Error ? error.message : String(error)));
+        }
+    }
+    async unlinkNpm() {
+        try {
+            await execAsync('npm unlink -g local-cli');
+        }
+        catch (error) {
+        }
+    }
+    async cleanupRepo() {
+        try {
+            if (fs.existsSync(this.repoDir)) {
+                logger.debug('Cleaning up repo directory to prevent source code exposure');
+                await rm(this.repoDir, { recursive: true, force: true });
+                logger.debug('Repo directory removed successfully');
+            }
+        }
+        catch (error) {
+            logger.debug('Failed to cleanup repo: ' + (error instanceof Error ? error.message : String(error)));
+        }
+    }
+}
+export default GitAutoUpdater;
+//# sourceMappingURL=git-auto-updater.js.map

package/dist/core/slash-command-handler.js

@@ -6,6 +6,7 @@ import { fullSync } from '../orquesta/config-sync.js';
 import { readHookConfig, writeHookFiles, disableHooks } from '../orquesta/hook-init.js';
 import { checkForCliUpdate, runCliUpdate, setSkippedVersion } from '../utils/update-checker.js';
 import { createRequire } from 'module';
+import { APP_VERSION } from '../constants.js';
 import { configManager } from './config/config-manager.js';
 import { getForcedTier, setForcedTier } from './routing-state.js';
 import { auditLog } from '../orchestration/audit-log.js';
@@ -491,7 +492,7 @@ ${executorLines}
             context.setMessages(updatedMessages);
             return { handled: true, shouldContinue: false, updatedContext: { messages: updatedMessages } };
         };
-        let currentVersion = '0.0.0';
+        let currentVersion = APP_VERSION;
         try {
             const require = createRequire(import.meta.url);
             currentVersion = require('../../package.json').version;

package/dist/index.js

@@ -1,6 +1,13 @@
 import { createRequire } from 'module';
+import { APP_VERSION } from './constants.js';
 const require = createRequire(import.meta.url);
-const packageJson = require('../package.json');
+let packageJson;
+try {
+    packageJson = require('../package.json');
+}
+catch {
+    packageJson = { version: APP_VERSION, name: 'orquesta-cli' };
+}
 export const version = packageJson.version;
 export const name = packageJson.name;
 //# sourceMappingURL=index.js.map

package/dist/tools/mcp/mcp-client.js

@@ -5,7 +5,14 @@ import { createRequire } from 'module';
 import { toolRegistry } from '../registry.js';
 import { loadMcpServerConfigs } from './mcp-config.js';
 import { logger } from '../../utils/logger.js';
-const pkg = createRequire(import.meta.url)('../../../package.json');
+import { APP_VERSION } from '../../constants.js';
+let pkg;
+try {
+    pkg = createRequire(import.meta.url)('../../../package.json');
+}
+catch {
+    pkg = { version: APP_VERSION };
+}
 const CONNECT_TIMEOUT_MS = Number(process.env['ORQUESTA_MCP_TIMEOUT_MS']) || 15000;
 const CALL_TIMEOUT_MS = Number(process.env['ORQUESTA_MCP_CALL_TIMEOUT_MS']) || 120000;
 const connected = [];

package/dist/ui/TodoPanel.js

@@ -91,7 +91,7 @@ export const TodoPanel = React.memo(({ todos, currentTodoId, isProcessing = fals
                     React.createElement(Box, null,
                         React.createElement(Box, { width: 2 }, isInProgress && isProcessing ? (React.createElement(Text, { color: "blueBright" },
                             React.createElement(Spinner, { type: "dots2" }))) : (React.createElement(Text, { color: config.color }, config.icon))),
-                        React.createElement(Text, { color: isCompleted ? 'gray' : isInProgress ? 'white' : 'gray', bold: isInProgress, dimColor: isCompleted, strikethrough: isCompleted }, todo.title),
+                        React.createElement(Text, { color: isCompleted ? 'gray' : isInProgress ? 'white' : 'gray', bold: isInProgress, strikethrough: isCompleted }, todo.title),
                         isInProgress && isProcessing && (React.createElement(Text, { color: "blueBright" }, " \u2190"))),
                     todo.error && (React.createElement(Box, { marginLeft: 2 },
                         React.createElement(Text, { color: "red", dimColor: true },

package/dist/ui/components/ActivityIndicator.js

@@ -86,9 +86,9 @@ export const ActivityIndicator = ({ activity, startTime, detail, subActivities =
                 formatTime(elapsedSeconds)),
             renderProgressBar()),
         detail && (React.createElement(Box, { marginLeft: 2 },
-            React.createElement(Text, { color: "gray", dimColor: true }, detail))),
+            React.createElement(Text, { color: "cyan" }, detail))),
         stepName && (React.createElement(Box, { marginLeft: 2 },
-            React.createElement(Text, { color: "gray", dimColor: true },
+            React.createElement(Text, { color: "gray" },
                 currentStep,
                 "/",
                 totalSteps,
@@ -98,15 +98,15 @@ export const ActivityIndicator = ({ activity, startTime, detail, subActivities =
             const subInfo = ACTIVITY_INFO[sub.type];
             return (React.createElement(Box, { key: idx },
                 getStatusIcon(sub.status),
-                React.createElement(Text, { color: "gray", dimColor: true },
+                React.createElement(Text, { color: "gray" },
                     " ",
                     subInfo.label),
-                sub.detail && React.createElement(Text, { color: "gray", dimColor: true },
+                sub.detail && React.createElement(Text, { color: "white" },
                     ": ",
                     sub.detail)));
         }))),
         tokenCount !== undefined && (React.createElement(Box, { marginLeft: 2 },
-            React.createElement(Text, { color: "gray", dimColor: true },
+            React.createElement(Text, { color: "gray" },
                 formatTokens(tokenCount),
                 " tokens",
                 tokensPerSecond !== undefined && tokensPerSecond > 0 && ` · ${tokensPerSecond.toFixed(0)} tok/s`)))));

package/dist/ui/components/CustomTextInput.d.ts

@@ -3,6 +3,7 @@ interface CustomTextInputProps {
     value: string;
     onChange: (value: string) => void;
     onSubmit?: (value: string) => void;
+    onCtrlS?: (value: string) => void;
     onHistoryPrev?: () => void;
     onHistoryNext?: () => void;
     placeholder?: string;

package/dist/ui/components/CustomTextInput.js

@@ -1,7 +1,7 @@
 import React, { useState, useEffect, useRef } from 'react';
 import { Box, Text, useStdin } from 'ink';
 const MULTILINE_COLLAPSE_THRESHOLD = 10;
-export const CustomTextInput = ({ value, onChange, onSubmit, onHistoryPrev, onHistoryNext, placeholder = '', focus = true, }) => {
+export const CustomTextInput = ({ value, onChange, onSubmit, onCtrlS, onHistoryPrev, onHistoryNext, placeholder = '', focus = true, }) => {
     const { stdin, setRawMode } = useStdin();
     const [cursorPosition, setCursorPosition] = useState(value.length);
     const previousValueLength = useRef(value.length);
@@ -10,6 +10,7 @@ export const CustomTextInput = ({ value, onChange, onSubmit, onHistoryPrev, onHi
     const cursorPositionRef = useRef(cursorPosition);
     const onChangeRef = useRef(onChange);
     const onSubmitRef = useRef(onSubmit);
+    const onCtrlSRef = useRef(onCtrlS);
     const onHistoryPrevRef = useRef(onHistoryPrev);
     const onHistoryNextRef = useRef(onHistoryNext);
     const setIsCollapsedViewRef = useRef(setIsCollapsedView);
@@ -19,6 +20,7 @@ export const CustomTextInput = ({ value, onChange, onSubmit, onHistoryPrev, onHi
         cursorPositionRef.current = cursorPosition;
         onChangeRef.current = onChange;
         onSubmitRef.current = onSubmit;
+        onCtrlSRef.current = onCtrlS;
         onHistoryPrevRef.current = onHistoryPrev;
         onHistoryNextRef.current = onHistoryNext;
         setIsCollapsedViewRef.current = setIsCollapsedView;
@@ -49,6 +51,10 @@ export const CustomTextInput = ({ value, onChange, onSubmit, onHistoryPrev, onHi
         const str = data.toString();
         const currentValue = valueRef.current;
         const currentCursor = cursorPositionRef.current;
+        if (str === '\x13') {
+            onCtrlSRef.current?.(currentValue);
+            return;
+        }
         const deleteWordBeforeCursor = (value, cursor) => {
             if (cursor > 0) {
                 const beforeCursor = value.slice(0, cursor);

package/dist/ui/components/PlanExecuteApp.js

@@ -46,11 +46,17 @@ import { UpdateNotification } from '../UpdateNotification.js';
 import { checkForCliUpdate, runCliUpdate, setSkippedVersion } from '../../utils/update-checker.js';
 import { setToolExecutionCallback, setTellToUserCallback, setToolResponseCallback, setPlanCreatedCallback, setTodoStartCallback, setTodoCompleteCallback, setTodoFailCallback, setCompactCallback, setAssistantResponseCallback, setToolApprovalCallback, setReasoningCallback, } from '../../tools/llm/simple/file-tools.js';
 import { createRequire } from 'module';
+import { APP_VERSION } from '../../constants.js';
 const require = createRequire(import.meta.url);
-const pkg = require('../../../package.json');
-const VERSION = pkg.version;
+let VERSION;
+try {
+    VERSION = require('../../../package.json').version;
+}
+catch {
+    VERSION = APP_VERSION;
+}
 const TOOLS_REQUIRING_APPROVAL = new Set(['create_file', 'edit_file', 'bash']);
-const STARTUP_TIP = 'Type /help for available commands. Type /model to switch models.';
+const STARTUP_TIP = 'Type /help for commands, /model to switch models. Press Ctrl+S to send now (or steer the AI mid-task).';
 function shortenPath(fullPath) {
     const homeDir = os.homedir();
     if (fullPath.startsWith(homeDir)) {
@@ -185,6 +191,7 @@ export const PlanExecuteApp = ({ llmClient: initialLlmClient, modelInfo, resumeL
     const fileBrowserState = useFileBrowserState(input, isProcessing);
     const commandBrowserState = useCommandBrowserState(input, isProcessing);
     const planExecutionState = usePlanExecution(pendingMessageCallbacks);
+    const dialogAwaitingInput = !!planExecutionState.askUserRequest || !!pendingToolApproval;
     useEffect(() => {
         sessionManager.setTodos(planExecutionState.todos);
     }, [planExecutionState.todos]);
@@ -457,6 +464,9 @@ export const PlanExecuteApp = ({ llmClient: initialLlmClient, modelInfo, resumeL
         if (!isProcessing) {
             return;
         }
+        if (dialogAwaitingInput) {
+            return;
+        }
         const interval = setInterval(() => {
             const sessionUsage = usageTracker.getSessionUsage();
             setSessionTokens(prev => (prev === sessionUsage.totalTokens ? prev : sessionUsage.totalTokens));
@@ -464,7 +474,7 @@ export const PlanExecuteApp = ({ llmClient: initialLlmClient, modelInfo, resumeL
             setSessionElapsed(prev => (prev === elapsed ? prev : elapsed));
         }, 1000);
         return () => clearInterval(interval);
-    }, [isProcessing]);
+    }, [isProcessing, dialogAwaitingInput]);
     useEffect(() => {
         const initialize = async () => {
             logger.flow('Starting initialization');
@@ -640,30 +650,33 @@ export const PlanExecuteApp = ({ llmClient: initialLlmClient, modelInfo, resumeL
         if (key.ctrl && inputChar === 'o') {
             setShowLogFiles(prev => !prev);
         }
-        if (key.ctrl && inputChar === 's') {
-            if (showSessionBrowser ||
-                showSettings ||
-                showSetupWizard ||
-                fileBrowserState.showFileBrowser ||
-                commandBrowserState.showCommandBrowser ||
-                planExecutionState.askUserRequest ||
-                pendingToolApproval) {
-                return;
-            }
-            const text = input.trim();
-            if (text) {
-                if (isProcessing) {
-                    addLog({ type: 'user_input', content: `(⚡ steering now — picked up at next step) ${text}` });
-                    setPendingUserMessage(text);
-                    setInput('');
-                }
-                else {
-                    handleSubmitRef.current?.(text);
-                }
-            }
+    });
+    const handleCtrlS = useCallback((rawValue) => {
+        if (showSessionBrowser ||
+            showSettings ||
+            showSetupWizard ||
+            fileBrowserState.showFileBrowser ||
+            commandBrowserState.showCommandBrowser ||
+            planExecutionState.askUserRequest ||
+            pendingToolApproval) {
             return;
         }
-    });
+        const text = (rawValue ?? '').trim();
+        if (!text)
+            return;
+        if (isProcessing) {
+            addLog({ type: 'user_input', content: `(⚡ Ctrl+S — steering now, picked up at next step) ${text}` });
+            setPendingUserMessage(text);
+            setInput('');
+        }
+        else {
+            handleSubmitRef.current?.(text);
+        }
+    }, [
+        showSessionBrowser, showSettings, showSetupWizard,
+        fileBrowserState.showFileBrowser, commandBrowserState.showCommandBrowser,
+        planExecutionState.askUserRequest, pendingToolApproval, isProcessing, addLog,
+    ]);
     const handleFileSelect = useCallback((filePaths) => {
         logger.debug('File selected', { filePaths });
         const newInput = fileBrowserState.handleFileSelect(filePaths, input);
@@ -1348,6 +1361,7 @@ export const PlanExecuteApp = ({ llmClient: initialLlmClient, modelInfo, resumeL
                     : reason;
                 return (React.createElement(Box, { key: entry.id, flexDirection: "column", marginTop: 1 },
                     React.createElement(Box, null,
+                        React.createElement(Text, { color: "gray", dimColor: true }, "\u2502 "),
                         React.createElement(Text, { color: "cyan", bold: true },
                             icon,
                             " ",
@@ -1421,9 +1435,11 @@ export const PlanExecuteApp = ({ llmClient: initialLlmClient, modelInfo, resumeL
                             ". ",
                             item))))));
             case 'todo_start':
-                return (React.createElement(Box, { key: entry.id, marginTop: 1 },
-                    React.createElement(Text, { color: "blue", bold: true }, "\uD83C\uDFB5 \u25B6 "),
-                    React.createElement(Text, { bold: true }, entry.content)));
+                return (React.createElement(Box, { key: entry.id, flexDirection: "column", marginTop: 1 },
+                    React.createElement(Text, { color: "gray", dimColor: true }, '─'.repeat(44)),
+                    React.createElement(Box, null,
+                        React.createElement(Text, { color: "blue", bold: true }, "\uD83C\uDFB5 \u25B6 "),
+                        React.createElement(Text, { bold: true }, entry.content))));
             case 'todo_complete':
                 return (React.createElement(Box, { key: entry.id, marginLeft: 2 },
                     React.createElement(Text, { color: "white" }, "\u23BF  "),
@@ -1485,11 +1501,11 @@ export const PlanExecuteApp = ({ llmClient: initialLlmClient, modelInfo, resumeL
         React.createElement(Static, { key: resizeTick, items: logEntries }, (entry) => renderLogEntry(entry)),
         pendingToolApproval && (React.createElement(Box, { marginY: 1 },
             React.createElement(ApprovalDialog, { toolName: pendingToolApproval.toolName, args: pendingToolApproval.args, reason: pendingToolApproval.reason, onResponse: handleApprovalResponse }))),
-        isProcessing && !pendingToolApproval && !isDocsSearching && (React.createElement(Box, { marginY: 1, flexDirection: "column" },
+        isProcessing && !pendingToolApproval && !isDocsSearching && !planExecutionState.askUserRequest && (React.createElement(Box, { marginY: 1, flexDirection: "column" },
             React.createElement(ActivityIndicator, { activity: getCurrentActivityType(), startTime: activityStartTime, detail: activityDetail || currentToolName || '', subActivities: subActivities, modelName: currentModelInfo.model }),
             streamingText && (React.createElement(StreamingOutput, { text: streamingText })))),
         isDocsSearching && (React.createElement(DocsSearchProgress, { logs: docsSearchLogs, isSearching: isDocsSearching })),
-        planExecutionState.todos.length > 0 && (React.createElement(Box, { marginTop: 2, marginBottom: 1 },
+        planExecutionState.todos.length > 0 && (React.createElement(Box, { marginTop: 1 },
             React.createElement(TodoPanel, { todos: planExecutionState.todos, currentTodoId: planExecutionState.currentTodoId, isProcessing: isProcessing }))),
         updatePhase === 'available' && (React.createElement(UpdateNotification, { currentVersion: VERSION, latestVersion: updateLatest })),
         updatePhase === 'updating' && (React.createElement(UpdateNotification, { currentVersion: VERSION, latestVersion: updateLatest, isUpdating: true, updateProgress: updateProgress })),
@@ -1508,7 +1524,7 @@ export const PlanExecuteApp = ({ llmClient: initialLlmClient, modelInfo, resumeL
                                 return;
                             }
                             setInput(value);
-                        }, onSubmit: handleSubmit, onHistoryPrev: isAnyPanelOpen ? undefined : handleHistoryPrev, onHistoryNext: isAnyPanelOpen ? undefined : handleHistoryNext, placeholder: isProcessing
+                        }, onSubmit: handleSubmit, onCtrlS: handleCtrlS, onHistoryPrev: isAnyPanelOpen ? undefined : handleHistoryPrev, onHistoryNext: isAnyPanelOpen ? undefined : handleHistoryNext, placeholder: isProcessing
                             ? "AI is working... (type + Ctrl+S to steer now)"
                             : showSessionBrowser
                                 ? "Select a session or press ESC..."
@@ -1518,6 +1534,9 @@ export const PlanExecuteApp = ({ llmClient: initialLlmClient, modelInfo, resumeL
                                         ? "Select a doc source or press ESC..."
                                         : "Type your message... (@ files, / commands, Alt+Enter newline, Ctrl+S send)", focus: !showSessionBrowser && !showSettings && !showDocsBrowser && !planExecutionState.askUserRequest && updatePhase === 'hidden' })),
                 input.length > 0 && (React.createElement(Text, { color: input.length > 4000 ? 'red' : input.length > 2000 ? 'yellow' : 'gray', dimColor: true }, input.length.toLocaleString())))),
+        isProcessing && input.trim().length > 0 && (React.createElement(Box, { paddingX: 1 },
+            React.createElement(Text, { color: "yellow", bold: true }, "\u26A1 Ctrl+S"),
+            React.createElement(Text, { color: "gray" }, " to send now, or Enter to queue for the next step"))),
         fileBrowserState.showFileBrowser && !isProcessing && (React.createElement(Box, { marginTop: 0 }, fileBrowserState.isLoadingFiles ? (React.createElement(Box, { borderStyle: "single", borderColor: "yellow", paddingX: 1 },
             React.createElement(Spinner, { type: "dots" }),
             React.createElement(Text, { color: "yellow" }, " Loading files..."))) : (React.createElement(FileBrowser, { filter: fileBrowserState.filterText, onSelect: handleFileSelect, onCancel: fileBrowserState.handleFileBrowserCancel, cachedFiles: fileBrowserState.cachedFileList })))),
@@ -1541,8 +1560,7 @@ export const PlanExecuteApp = ({ llmClient: initialLlmClient, modelInfo, resumeL
                     React.createElement(Text, { color: "cyan" },
                         React.createElement(Spinner, { type: "shark" })))) : null,
                 React.createElement(Box, null,
-                    React.createElement(Text, { color: "magenta" },
-                        React.createElement(Spinner, { type: "star" })),
+                    React.createElement(Text, { color: "magenta" }, dialogAwaitingInput ? '✶' : React.createElement(Spinner, { type: "star" })),
                     React.createElement(Text, { color: "white" },
                         ' ',
                         getStatusText({

package/dist/ui/components/StreamingOutput.d.ts

@@ -1,6 +1,7 @@
 import React from 'react';
 interface StreamingOutputProps {
     text: string;
+    height?: number;
 }
 export declare const StreamingOutput: React.FC<StreamingOutputProps>;
 export {};

package/dist/ui/components/StreamingOutput.js

@@ -1,9 +1,11 @@
 import React from 'react';
 import { Box, Text } from 'ink';
-export const StreamingOutput = ({ text }) => {
+export const StreamingOutput = ({ text, height = 3 }) => {
     if (!text)
         return null;
-    return (React.createElement(Box, { marginTop: 1, paddingX: 1 },
-        React.createElement(Text, { wrap: "wrap" }, text.split('\n').slice(-8).join('\n'))));
+    const tail = text.split('\n').slice(-height);
+    const pad = Array(Math.max(0, height - tail.length)).fill('');
+    const rows = [...pad, ...tail];
+    return (React.createElement(Box, { paddingX: 1, flexDirection: "column", height: height }, rows.map((line, i) => (React.createElement(Text, { key: i, wrap: "truncate-end" }, line || ' ')))));
 };
 //# sourceMappingURL=StreamingOutput.js.map

package/dist/ui/components/dialogs/SettingsDialog.js

@@ -1,6 +1,7 @@
 import React, { useState, useEffect, useCallback } from 'react';
 import { Box, Text, useInput } from 'ink';
 import TextInput from 'ink-text-input';
+import { APP_VERSION } from '../../../constants.js';
 import SelectInput from 'ink-select-input';
 import { configManager } from '../../../core/config/config-manager.js';
 import { sessionManager } from '../../../core/session/session-manager.js';
@@ -60,7 +61,7 @@ export const SettingsBrowser = ({ currentPlanningMode: _currentPlanningMode, onP
                 const endpoint = configManager.getCurrentEndpoint();
                 const model = configManager.getCurrentModel();
                 const cwd = process.cwd();
-                let version = '0.1.0';
+                let version = APP_VERSION;
                 try {
                     const { readFile } = await import('fs/promises');
                     const { fileURLToPath } = await import('url');

package/dist/ui/ink-entry.js

@@ -1,13 +1,30 @@
 #!/usr/bin/env node
 import React from 'react';
+import { execSync } from 'child_process';
 import { render } from 'ink';
 import { PlanExecuteApp } from './components/PlanExecuteApp.js';
 import { createLLMClient } from '../core/llm/llm-client.js';
 import { configManager } from '../core/config/config-manager.js';
 import { initializeOptionalTools } from '../tools/registry.js';
 import { logger } from '../utils/logger.js';
+function disableFlowControl() {
+    if (process.platform === 'win32' || !process.stdin.isTTY)
+        return;
+    try {
+        execSync('stty -ixon', { stdio: 'inherit' });
+        process.on('exit', () => {
+            try {
+                execSync('stty ixon', { stdio: 'inherit' });
+            }
+            catch { }
+        });
+    }
+    catch {
+    }
+}
 (async () => {
     try {
+        disableFlowControl();
         await configManager.initialize();
         await initializeOptionalTools();
         const llmClient = createLLMClient();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "orquesta-cli",
-  "version": "0.2.112",
+  "version": "0.2.116",
   "description": "Orquesta CLI - AI-powered coding assistant with team collaboration",
   "type": "module",
   "main": "dist/index.js",