orquesta-cli 0.2.94 → 0.2.96

package/dist/cli.js

@@ -17,6 +17,7 @@ import React from 'react';
 import { render } from 'ink';
 import { createRequire } from 'module';
 import { configManager } from './core/config/config-manager.js';
+import { resolveEndpointOverride } from './core/config/endpoint-override.js';
 import { createLLMClient } from './core/llm/llm-client.js';
 import { PlanExecuteApp } from './ui/components/PlanExecuteApp.js';
 import { setAppendedSystemPrompt } from './orchestration/plan-executor.js';
@@ -155,17 +156,12 @@ program
     await configManager.initialize();
     await ensureBatutaFromEnv();
     if (options.endpoint) {
-        const wanted = String(options.endpoint).toLowerCase();
         const all = configManager.getAllEndpoints();
-        const ep = wanted === 'batuta'
-            ? all.find((e) => e.id === 'batuta-proxy' || e.provider === 'batuta')
-            : all.find((e) => e.id === options.endpoint) ||
-                all.find((e) => (e.name || '').toLowerCase() === wanted);
-        if (ep) {
-            await configManager.setCurrentEndpoint(ep.id);
-            const m = ep.models.find((x) => x.enabled) || ep.models[0];
-            if (m)
-                await configManager.setCurrentModel(m.id);
+        const resolved = resolveEndpointOverride(all, String(options.endpoint));
+        if (resolved) {
+            await configManager.setCurrentEndpoint(resolved.endpointId);
+            if (resolved.modelId)
+                await configManager.setCurrentModel(resolved.modelId);
         }
         else {
             logger.warn(`--endpoint "${options.endpoint}" matched no configured endpoint (have: ${all.map(e => e.id).join(', ') || 'none'}); keeping current selection`);

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

@@ -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/config/endpoint-override.d.ts

@@ -0,0 +1,15 @@
+export interface OverrideEndpoint {
+    id: string;
+    name?: string;
+    provider?: string;
+    models?: Array<{
+        id: string;
+        enabled?: boolean;
+    }>;
+}
+export interface ResolvedOverride {
+    endpointId: string;
+    modelId?: string;
+}
+export declare function resolveEndpointOverride(endpoints: OverrideEndpoint[], wanted: string): ResolvedOverride | null;
+//# sourceMappingURL=endpoint-override.d.ts.map

package/dist/core/config/endpoint-override.js

@@ -0,0 +1,12 @@
+export function resolveEndpointOverride(endpoints, wanted) {
+    const w = String(wanted).toLowerCase();
+    const ep = w === 'batuta'
+        ? endpoints.find((e) => e.id === 'batuta-proxy' || e.provider === 'batuta')
+        : endpoints.find((e) => e.id === wanted) ||
+            endpoints.find((e) => (e.name || '').toLowerCase() === w);
+    if (!ep)
+        return null;
+    const m = ep.models?.find((x) => x.enabled) || ep.models?.[0];
+    return { endpointId: ep.id, modelId: m?.id };
+}
+//# sourceMappingURL=endpoint-override.js.map

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/package.json

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