orquesta-cli 0.2.95 → 0.2.97

package/dist/cli.js

@@ -377,6 +377,14 @@ program
         await Promise.all([toolsPromise, syncPromise]);
         spinner.stop();
         process.stdout.write('\x1B[2J\x1B[0f');
+        if (!process.stdin.isTTY) {
+            spinner.stop();
+            console.log(chalk.yellow('No interactive terminal available (stdin is not a TTY).'));
+            console.log(chalk.dim('For non-interactive use run:  orquesta -p "your prompt"  (reads the prompt from stdin when value is omitted).'));
+            if (cleanup)
+                await cleanup();
+            return;
+        }
         if (options.verbose || options.debug) {
             console.log(chalk.cyan('Starting Orquesta CLI...\n'));
         }

package/dist/core/config/config-manager.d.ts

@@ -60,6 +60,8 @@ export declare class ConfigManager {
     setMaxParallelWorkers(n: number): Promise<void>;
     isRefinerEnabled(): boolean;
     setRefinerEnabled(enabled: boolean): Promise<void>;
+    isSingleAgentMode(): boolean;
+    setSingleAgentMode(enabled: boolean): Promise<void>;
     isWorktreeIsolationEnabled(): boolean;
     setWorktreeIsolationEnabled(enabled: boolean): Promise<void>;
 }

package/dist/core/config/config-manager.js

@@ -48,7 +48,7 @@ export class ConfigManager {
             throw error;
         }
         logger.flow('Saving configuration');
-        await writeJsonFile(CONFIG_FILE_PATH, this.config);
+        await writeJsonFile(CONFIG_FILE_PATH, this.config, 0o600);
     }
     getConfig() {
         if (!this.config) {
@@ -415,6 +415,16 @@ export class ConfigManager {
         config.orchestration.refinerEnabled = enabled;
         await this.saveConfig();
     }
+    isSingleAgentMode() {
+        return this.config?.orchestration?.singleAgentMode ?? false;
+    }
+    async setSingleAgentMode(enabled) {
+        const config = this.getConfig();
+        if (!config.orchestration)
+            config.orchestration = {};
+        config.orchestration.singleAgentMode = enabled;
+        await this.saveConfig();
+    }
     isWorktreeIsolationEnabled() {
         return this.config?.orchestration?.worktreeIsolation ?? false;
     }

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

@@ -141,7 +141,8 @@ export async function executeSlashCommand(command, context) {
             const parallel = configManager.getMaxParallelWorkers();
             const refiner = configManager.isRefinerEnabled() ? 'on' : 'off';
             const worktree = configManager.isWorktreeIsolationEnabled() ? 'on' : 'off';
-            return `Multi-role orchestration\n\n${lines.join('\n')}\n\n  max parallel workers: ${parallel}\n  refiner pass:         ${refiner}\n  worktree isolation:   ${worktree}\n\nUsage:\n  /role planner <model-id>\n  /role executor <model-id>\n  /role refiner <model-id> | off\n  /role parallel <N>\n  /role worktree on|off\n  /role clear`;
+            const single = configManager.isSingleAgentMode() ? 'on' : 'off';
+            return `Multi-role orchestration\n\n${lines.join('\n')}\n\n  max parallel workers: ${parallel}\n  refiner pass:         ${refiner}\n  worktree isolation:   ${worktree}\n  single-agent mode:    ${single}\n\nUsage:\n  /role planner <model-id>\n  /role executor <model-id>\n  /role refiner <model-id> | off\n  /role parallel <N>\n  /role worktree on|off\n  /role single on|off    (skip planner; one accumulative agent — best for debugging)\n  /role clear`;
         };
         let body;
         try {
@@ -166,6 +167,12 @@ export async function executeSlashCommand(command, context) {
                 await configManager.setWorktreeIsolationEnabled(args[1] === 'on');
                 body = `Worktree isolation: ${args[1]}.`;
             }
+            else if (args[0] === 'single' && (args[1] === 'on' || args[1] === 'off')) {
+                await configManager.setSingleAgentMode(args[1] === 'on');
+                body = args[1] === 'on'
+                    ? 'Single-agent mode ON — planner/orchestrator bypassed; one accumulative agent (best for debugging/investigation).'
+                    : 'Single-agent mode OFF — planner + orchestrator restored.';
+            }
             else if ((args[0] === 'planner' || args[0] === 'executor' || args[0] === 'refiner') && args[1]) {
                 const role = args[0];
                 if (role === 'refiner' && args[1] === 'off') {

package/dist/orchestration/plan-executor.js

@@ -106,6 +106,29 @@ export class PlanExecutor {
                 throw new Error('INTERRUPTED');
             }
             let currentMessages = messages;
+            if (configManager.isSingleAgentMode()) {
+                logger.flow('Single-agent mode — bypassing planner/orchestrator');
+                callbacks.setExecutionPhase('executing');
+                callbacks.setCurrentActivity('Working (single-agent)');
+                const saTools = toolRegistry.getLLMToolDefinitions();
+                const lastUserIdx = currentMessages.map(m => m.role).lastIndexOf('user');
+                const saMessages = (lastUserIdx >= 0 && currentMessages[lastUserIdx]?.content === userMessage)
+                    ? currentMessages
+                    : [...currentMessages, { role: 'user', content: userMessage }];
+                const saExecutorModel = configManager.getRoleModel('executor');
+                const saResult = await llmClient.chatCompletionWithTools(saMessages, saTools, {
+                    getPendingMessage: callbacks.getPendingMessage,
+                    clearPendingMessage: callbacks.clearPendingMessage,
+                    ...(saExecutorModel ? { model: saExecutorModel } : {}),
+                });
+                currentMessages = [...saMessages, ...saResult.allMessages.slice(saMessages.length)];
+                callbacks.setMessages([...currentMessages]);
+                sessionManager.autoSaveCurrentSession(currentMessages);
+                callbacks.setExecutionPhase('idle');
+                auditLog.emit(auditSid, 'run.complete', { runId, mode: 'single-agent', success: true });
+                logger.exit('PlanExecutor.executePlanMode', { singleAgent: true });
+                return;
+            }
             callbacks.setCurrentActivity('Thinking');
             const plannerModel = configManager.getRoleModel('planner');
             const planningLLM = new PlanningLLM(llmClient, plannerModel ?? undefined);

package/dist/types/index.d.ts

@@ -126,6 +126,7 @@ export interface OrchestrationConfig {
     maxParallelWorkers?: number;
     refinerEnabled?: boolean;
     worktreeIsolation?: boolean;
+    singleAgentMode?: boolean;
 }
 export interface OpenConfig {
     version: string;

package/dist/ui/components/TodoListView.js

@@ -3,7 +3,7 @@ import { Box, Text } from 'ink';
 import Spinner from 'ink-spinner';
 import { logger } from '../../utils/logger.js';
 const STATUS_CONFIG = {
-    completed: { icon: '☑', color: 'gray' },
+    completed: { icon: '☑', color: 'green' },
     in_progress: { icon: '☐', color: 'white' },
     failed: { icon: '☒', color: 'red' },
     pending: { icon: '☐', color: 'gray' },
@@ -57,7 +57,7 @@ export const TodoListView = ({ todos, showProgressBar = true, }) => {
             React.createElement(Box, null,
                 React.createElement(Box, { width: 2 }, isInProgress ? (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', dimColor: isCompleted, strikethrough: isCompleted, bold: isInProgress }, todo.title),
+                React.createElement(Text, { color: isCompleted ? 'green' : isInProgress ? 'white' : 'gray', dimColor: false, bold: isInProgress }, todo.title),
                 isInProgress && React.createElement(Text, { color: "blueBright" }, " \u2190"),
                 todo.dependsOn && todo.dependsOn.length > 0 && (React.createElement(Text, { color: "gray", dimColor: true },
                     " (after ",

package/dist/utils/file-system.d.ts

@@ -2,7 +2,7 @@ export declare function directoryExists(dirPath: string): Promise<boolean>;
 export declare function fileExists(filePath: string): Promise<boolean>;
 export declare function ensureDirectory(dirPath: string): Promise<void>;
 export declare function readJsonFile<T>(filePath: string): Promise<T | null>;
-export declare function writeJsonFile<T>(filePath: string, data: T): Promise<void>;
+export declare function writeJsonFile<T>(filePath: string, data: T, mode?: number): Promise<void>;
 export declare function readTextFile(filePath: string): Promise<string>;
 export declare function writeTextFile(filePath: string, content: string): Promise<void>;
 export declare function getFileSize(filePath: string): Promise<number>;

package/dist/utils/file-system.js

@@ -49,14 +49,20 @@ export async function readJsonFile(filePath) {
         throw error;
     }
 }
-export async function writeJsonFile(filePath, data) {
+export async function writeJsonFile(filePath, data, mode) {
     try {
         const dirPath = path.dirname(filePath);
         await ensureDirectory(dirPath);
         const content = JSON.stringify(data, null, 2);
         const tmpPath = `${filePath}.tmp.${process.pid}.${tmpCounter++}`;
         try {
-            await writeFile(tmpPath, content, 'utf-8');
+            await writeFile(tmpPath, content, mode !== undefined ? { encoding: 'utf-8', mode } : 'utf-8');
+            if (mode !== undefined) {
+                try {
+                    await new Promise((res, rej) => fs.chmod(tmpPath, mode, e => e ? rej(e) : res()));
+                }
+                catch { }
+            }
             await rename(tmpPath, filePath);
         }
         catch (err) {

package/package.json

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