orquesta-cli 0.2.92 → 0.2.93

package/dist/cli.js

@@ -45,6 +45,7 @@ async function ensureBatutaFromEnv() {
     const token = process.env['ORQUESTA_TOKEN'];
     if (!token)
         return;
+    await configManager.initialize();
     const apiUrl = (process.env['ORQUESTA_API_URL'] || 'https://getorquesta.com').replace(/\/+$/, '');
     if (configManager.getAllEndpoints().some((e) => e.id === 'batuta-proxy')) {
         await configManager.removeEndpoint('batuta-proxy');
@@ -152,6 +153,8 @@ program
         setAppendedSystemPrompt(options.appendSystemPrompt);
     }
     if (options.endpoint) {
+        await configManager.initialize();
+        await ensureBatutaFromEnv();
         const wanted = String(options.endpoint).toLowerCase();
         const all = configManager.getAllEndpoints();
         const ep = wanted === 'batuta'
@@ -164,6 +167,9 @@ program
             if (m)
                 await configManager.setCurrentModel(m.id);
         }
+        else {
+            logger.warn(`--endpoint "${options.endpoint}" matched no configured endpoint (have: ${all.map(e => e.id).join(', ') || 'none'}); keeping current selection`);
+        }
     }
     if (options.eval) {
         await runEvalMode();

package/dist/core/llm/llm-client.js

@@ -672,6 +672,7 @@ export class LLMClient {
         let finalResponseFailures = 0;
         const MAX_NO_TOOL_CALL_RETRIES = 3;
         const MAX_FINAL_RESPONSE_FAILURES = 3;
+        const MAX_ITERATIONS = Number(process.env['ORQUESTA_MAX_TOOL_ITERATIONS']) || 50;
         const recentToolSignatures = [];
         const recentNormalizedSignatures = [];
         const LOOP_WINDOW = 5;
@@ -684,6 +685,11 @@ export class LLMClient {
                 throw new Error('INTERRUPTED');
             }
             iterations++;
+            if (iterations > MAX_ITERATIONS) {
+                logger.error('Tool-call iteration budget exhausted — aborting', new Error(`MAX_ITERATIONS: ${iterations}`));
+                throw new Error(`MAX_ITERATIONS: exceeded ${MAX_ITERATIONS} tool iterations without producing a final answer. ` +
+                    `Aborting to protect the session. Raise ORQUESTA_MAX_TOOL_ITERATIONS for genuinely long tasks.`);
+            }
             if (options?.getPendingMessage && options?.clearPendingMessage) {
                 const pendingMsg = options.getPendingMessage();
                 if (pendingMsg) {

package/dist/orchestration/audit-log.d.ts

@@ -1,5 +1,5 @@
 declare const SCHEMA_VERSION = 1;
-export type AuditEventKind = 'run.start' | 'planner.complete' | 'orchestrator.decision' | 'worker.start' | 'worker.complete' | 'wave.complete' | 'refiner.complete' | 'run.complete' | 'run.error';
+export type AuditEventKind = 'run.start' | 'planner.complete' | 'orchestrator.decision' | 'worker.start' | 'worker.complete' | 'worker.blocked' | 'wave.complete' | 'refiner.complete' | 'run.complete' | 'run.stalled' | 'run.error';
 export interface AuditEvent {
     schema: typeof SCHEMA_VERSION;
     timestamp: string;

package/dist/orchestration/parallel-orchestrator.js

@@ -4,6 +4,7 @@ import { logger } from '../utils/logger.js';
 import { worktreeManager } from './worktree-manager.js';
 import { memoryStore } from './memory-store.js';
 import { auditLog } from './audit-log.js';
+const WORKER_TIMEOUT_MS = Number(process.env['ORQUESTA_WORKER_TIMEOUT_MS']) || 15 * 60 * 1000;
 export function shouldUseParallelOrchestrator(todos) {
     if (todos.length < 2)
         return false;
@@ -11,8 +12,8 @@ export function shouldUseParallelOrchestrator(todos) {
     if (hasExplicitDeps)
         return true;
     const fsTouching = todos.filter(t => t.requiresFilesystem).length;
-    if (fsTouching >= 2)
-        return true;
+    if (fsTouching > 0)
+        return false;
     const allIndependent = todos.every(t => !t.dependsOn || t.dependsOn.length === 0);
     if (allIndependent && todos.length >= 3)
         return true;
@@ -83,9 +84,17 @@ async function runWorker(ctx) {
         isolated: !!ctx.workingDirectory && ctx.workingDirectory !== process.cwd(),
     });
     const startedAt = Date.now();
-    const result = await ctx.llmClient.chatCompletionWithTools(messages, tools, {
-        ...(ctx.executorModel ? { model: ctx.executorModel } : {}),
-    });
+    let watchdog;
+    const result = await Promise.race([
+        ctx.llmClient.chatCompletionWithTools(messages, tools, {
+            ...(ctx.executorModel ? { model: ctx.executorModel } : {}),
+        }),
+        new Promise((_, reject) => {
+            watchdog = setTimeout(() => reject(new Error(`Worker ${ctx.todo.id} exceeded ${Math.round(WORKER_TIMEOUT_MS / 1000)}s watchdog — task aborted`)), WORKER_TIMEOUT_MS);
+            watchdog.unref?.();
+        }),
+    ]).finally(() => { if (watchdog)
+        clearTimeout(watchdog); });
     const extractSummary = () => {
         for (let i = result.allMessages.length - 1; i >= 0; i--) {
             const m = result.allMessages[i];
@@ -135,6 +144,7 @@ export async function runParallelGraph(opts) {
     const todoById = new Map(todos.map(t => [t.id, t]));
     const outputs = {};
     const allNewMessages = [];
+    const failed = new Set();
     const waves = planWaves(todos);
     logger.flow('Parallel orchestrator plan', {
         waveCount: waves.length,
@@ -147,7 +157,27 @@ export async function runParallelGraph(opts) {
         callbacks.setCurrentActivity(`Wave ${waveIdx + 1}/${waves.length} (${wave.length} task${wave.length === 1 ? '' : 's'})`);
         const waveStartedAt = Date.now();
         for (let i = 0; i < wave.length; i += maxParallel) {
-            const batch = wave.slice(i, i + maxParallel);
+            const fullBatch = wave.slice(i, i + maxParallel);
+            const batch = [];
+            for (const t of fullBatch) {
+                const item = todoById.get(t.id);
+                const deadDeps = (item.dependsOn ?? []).filter(d => failed.has(d));
+                if (deadDeps.length > 0) {
+                    item.status = 'failed';
+                    item.error = `Blocked: prerequisite ${deadDeps.join(', ')} did not complete`;
+                    failed.add(t.id);
+                    await memoryStore.set(sessionId, `worker:${t.id}`, {
+                        title: item.title,
+                        summary: `⛔ ${item.error}`,
+                        blocked: true,
+                        completedAt: new Date().toISOString(),
+                    }, 'worker');
+                    auditLog.emit(sessionId, 'worker.blocked', { todoId: t.id, deadDeps });
+                }
+                else {
+                    batch.push(t);
+                }
+            }
             for (const t of batch) {
                 const item = todoById.get(t.id);
                 item.status = 'in_progress';
@@ -194,7 +224,14 @@ export async function runParallelGraph(opts) {
                     const err = res.reason;
                     item.status = 'failed';
                     item.error = err?.message || String(err);
+                    failed.add(t.id);
                     logger.error('Worker failed', err);
+                    await memoryStore.set(sessionId, `worker:${t.id}`, {
+                        title: item.title,
+                        summary: `❌ Failed: ${item.error}`,
+                        failed: true,
+                        completedAt: new Date().toISOString(),
+                    }, 'worker');
                     auditLog.emit(sessionId, 'worker.complete', {
                         todoId: t.id,
                         model: executorModel,

package/dist/orchestration/plan-executor.js

@@ -78,6 +78,29 @@ export class PlanExecutor {
         });
         let runError = null;
         let runInterrupted = false;
+        let runHadFailures = false;
+        const STALL_TIMEOUT_MS = Number(process.env['ORQUESTA_STALL_TIMEOUT_MS']) || 20 * 60 * 1000;
+        let lastActivityAt = Date.now();
+        const bumpActivity = () => { lastActivityAt = Date.now(); };
+        const baseCb = callbacks;
+        callbacks = {
+            ...baseCb,
+            setTodos: (t) => { bumpActivity(); baseCb.setTodos(t); },
+            setMessages: (m) => { bumpActivity(); baseCb.setMessages(m); },
+            setCurrentActivity: (a) => { bumpActivity(); baseCb.setCurrentActivity(a); },
+            setCurrentTodoId: (id) => { bumpActivity(); baseCb.setCurrentTodoId(id); },
+            setExecutionPhase: (p) => { bumpActivity(); baseCb.setExecutionPhase(p); },
+        };
+        const stallTimer = setInterval(() => {
+            const idleMs = Date.now() - lastActivityAt;
+            if (!isInterruptedRef.current && idleMs > STALL_TIMEOUT_MS) {
+                logger.warn(`Stall watchdog: no progress for ${Math.round(idleMs / 1000)}s — aborting run`);
+                auditLog.emit(auditSid, 'run.stalled', { runId, idleMs });
+                isInterruptedRef.current = true;
+                baseCb.setIsInterrupted(true);
+            }
+        }, 30_000);
+        stallTimer.unref?.();
         try {
             if (isInterruptedRef.current) {
                 throw new Error('INTERRUPTED');
@@ -221,9 +244,24 @@ export class PlanExecutor {
             await this.checkAndPerformAutoCompact(llmClient, currentMessages, currentTodos, callbacks, (updated) => { currentMessages = updated; });
             currentMessages = await this.maybeRunRefiner(llmClient, currentMessages, currentTodos, callbacks);
             const stats = getTodoStats(currentTodos);
+            const failedTodos = currentTodos.filter(t => t.status === 'failed');
+            const runSucceeded = failedTodos.length === 0;
+            runHadFailures = !runSucceeded;
             sessionManager.autoSaveCurrentSession(currentMessages);
-            auditLog.emit(auditSid, 'run.complete', { runId, ...stats });
-            logger.exit('PlanExecutor.executePlanMode', { success: true, ...stats });
+            if (failedTodos.length > 0) {
+                const lines = failedTodos
+                    .map(t => `  • [${t.id}] ${t.title} — ${t.error || 'failed'}`)
+                    .join('\n');
+                callbacks.setMessages((prev) => [
+                    ...prev,
+                    {
+                        role: 'assistant',
+                        content: `⚠️ Run did NOT fully succeed — ${failedTodos.length} task(s) failed or were blocked:\n${lines}\n\nDo not treat this as a successful deploy/run until these are resolved.`,
+                    },
+                ]);
+            }
+            auditLog.emit(auditSid, 'run.complete', { runId, success: runSucceeded, ...stats });
+            logger.exit('PlanExecutor.executePlanMode', { success: runSucceeded, ...stats });
         }
         catch (error) {
             if (error instanceof Error && error.message === 'INTERRUPTED') {
@@ -259,6 +297,7 @@ export class PlanExecutor {
             });
         }
         finally {
+            clearInterval(stallTimer);
             if (orquestaTrackingId) {
                 try {
                     if (runInterrupted) {
@@ -267,8 +306,8 @@ export class PlanExecutor {
                     else {
                         const usage = usageTracker.getSessionUsage();
                         await reportPromptComplete(orquestaTrackingId, {
-                            success: !runError,
-                            error: runError ? formatErrorMessage(runError) : undefined,
+                            success: !runError && !runHadFailures,
+                            error: runError ? formatErrorMessage(runError) : (runHadFailures ? 'One or more tasks failed or were blocked' : undefined),
                             tokensUsed: usage.totalTokens || undefined,
                         });
                     }

package/dist/tools/llm/simple/bash-tool.js

@@ -12,37 +12,65 @@ async function executeBash(command, cwd, timeout = 30000, explicitEnv) {
         const child = spawn(shell, shellArgs, {
             cwd: cwd || process.cwd(),
             env: filterSafeEnv(process.env, userSafeVars, explicitEnv || {}),
+            detached: true,
         });
         let stdout = '';
         let stderr = '';
         let killed = false;
-        child.stdout?.on('data', (data) => {
-            stdout += data.toString();
-        });
-        child.stderr?.on('data', (data) => {
-            stderr += data.toString();
-        });
-        child.on('close', (code) => {
+        let settled = false;
+        const finish = (code) => {
+            if (settled)
+                return;
+            settled = true;
             clearTimeout(timer);
+            clearTimeout(hardTimer);
             resolve({
                 stdout: stdout.trim(),
                 stderr: stderr.trim(),
                 exitCode: code ?? (killed ? 124 : 0),
                 timedOut: killed,
             });
+        };
+        const killGroup = (sig) => {
+            try {
+                if (child.pid)
+                    process.kill(-child.pid, sig);
+                else
+                    child.kill(sig);
+            }
+            catch {
+                try {
+                    child.kill(sig);
+                }
+                catch { }
+            }
+        };
+        child.stdout?.on('data', (data) => {
+            stdout += data.toString();
         });
+        child.stderr?.on('data', (data) => {
+            stderr += data.toString();
+        });
+        child.on('close', (code) => finish(code));
         child.on('error', (error) => {
+            if (settled)
+                return;
+            settled = true;
             clearTimeout(timer);
+            clearTimeout(hardTimer);
             reject(error);
         });
         const timer = setTimeout(() => {
             killed = true;
-            child.kill('SIGTERM');
-            setTimeout(() => { try {
-                child.kill('SIGKILL');
-            }
-            catch { } }, 2000).unref?.();
+            killGroup('SIGTERM');
+            setTimeout(() => killGroup('SIGKILL'), 2000).unref?.();
         }, timeout);
+        const hardTimer = setTimeout(() => {
+            killed = true;
+            killGroup('SIGKILL');
+            finish(124);
+        }, timeout + 5000);
+        hardTimer.unref?.();
     });
 }
 const BASH_TOOL_DEFINITION = {

package/dist/ui/components/PlanExecuteApp.js

@@ -459,9 +459,10 @@ export const PlanExecuteApp = ({ llmClient: initialLlmClient, modelInfo, resumeL
         }
         const interval = setInterval(() => {
             const sessionUsage = usageTracker.getSessionUsage();
-            setSessionTokens(sessionUsage.totalTokens);
-            setSessionElapsed(usageTracker.getSessionElapsedSeconds());
-        }, 500);
+            setSessionTokens(prev => (prev === sessionUsage.totalTokens ? prev : sessionUsage.totalTokens));
+            const elapsed = usageTracker.getSessionElapsedSeconds();
+            setSessionElapsed(prev => (prev === elapsed ? prev : elapsed));
+        }, 1000);
         return () => clearInterval(interval);
     }, [isProcessing]);
     useEffect(() => {

package/package.json

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