orquesta-cli 0.2.92 → 0.2.94

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');
@@ -151,6 +152,8 @@ program
     if (options.appendSystemPrompt) {
         setAppendedSystemPrompt(options.appendSystemPrompt);
     }
+    await configManager.initialize();
+    await ensureBatutaFromEnv();
     if (options.endpoint) {
         const wanted = String(options.endpoint).toLowerCase();
         const all = configManager.getAllEndpoints();
@@ -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();
@@ -182,8 +188,6 @@ program
         disableHooks();
         return;
     }
-    await configManager.initialize();
-    await ensureBatutaFromEnv();
     if (shouldShowOnboarding()) {
         await runOnboarding();
     }

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

@@ -424,9 +424,10 @@ export class LLMClient {
                     currentAttempt: currentAttempt + 1,
                 });
             }
-            if (!this.triedBatutaFallback && this.isConnectionError(error) && this.switchToBatutaProxy()) {
+            const upstream5xx = axios.isAxiosError(error) && (error.response?.status ?? 0) >= 500;
+            if (!this.triedBatutaFallback && (this.isConnectionError(error) || upstream5xx) && this.switchToBatutaProxy()) {
                 this.triedBatutaFallback = true;
-                logger.flow('Primary endpoint unreachable — falling back to Batuta');
+                logger.flow('Primary endpoint failed — falling back to Batuta');
                 return this.chatCompletion(options, { maxRetries, currentAttempt: 1 });
             }
             logger.flow('API call failed - Error handling');
@@ -672,6 +673,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 +686,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;
@@ -15,6 +15,7 @@ declare class AuditLogger {
     startRun(sessionId: string, data?: Record<string, unknown>): string;
     emit(sessionId: string, kind: AuditEventKind, data?: Record<string, unknown>): void;
     private write;
+    private rotateIfNeeded;
     tail(n?: number): Promise<AuditEvent[]>;
     stats(opts?: {
         sinceDays?: number;

package/dist/orchestration/audit-log.js

@@ -31,12 +31,24 @@ class AuditLogger {
                 await fs.mkdir(LOCAL_HOME_DIR, { recursive: true });
                 this.initialized = true;
             }
+            await this.rotateIfNeeded();
             await fs.appendFile(AUDIT_LOG_PATH, JSON.stringify(event) + '\n', 'utf8');
         }
         catch (error) {
             logger.warn('Audit log write failed', { error: error.message });
         }
     }
+    async rotateIfNeeded() {
+        try {
+            const max = Number(process.env['ORQUESTA_AUDIT_MAX_BYTES']) || 10 * 1024 * 1024;
+            const { size } = await fs.stat(AUDIT_LOG_PATH);
+            if (size < max)
+                return;
+            await fs.rename(AUDIT_LOG_PATH, `${AUDIT_LOG_PATH}.1`).catch(() => undefined);
+        }
+        catch {
+        }
+    }
     async tail(n = 50) {
         try {
             const raw = await fs.readFile(AUDIT_LOG_PATH, 'utf8');

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/prompts/agents/planning.js

@@ -53,10 +53,11 @@ Use this ONLY for pure questions that need NO action:
 ## Guidelines
 
 ### For create_todos:
-1. **1-5 high-level TODOs** - Even 1 TODO is fine! Don't be too granular, let Execution LLM handle details
-2. **Actionable titles** - Clear what needs to be done
-3. **Sequential order** - Execution order matters
-4. **User's language** - Write titles in the same language as the user
+1. **Create the MINIMUM number of TODOs.** 1 task is the ideal and most common case. Only add more when the work is genuinely separable AND benefits from it. Debugging, investigation, and "figure out / fix X" are SEQUENTIAL by nature — each finding informs the next step — so they should be a SINGLE task, never split. Add multiple tasks only for genuinely independent, parallelizable implementation work (e.g. "build feature A" + "build unrelated feature B"). When unsure, prefer fewer.
+2. **dependsOn for ordered steps** - If task B needs task A's result (build → upload → restart), set B.dependsOn=[A]. Tasks that touch the filesystem with no declared deps run sequentially in listed order.
+3. **Actionable titles** - Clear what needs to be done
+4. **Sequential order** - List tasks in execution order
+5. **User's language** - Write titles in the same language as the user
 
 ### For respond_to_user:
 1. **Clear and helpful** - Answer the question directly

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/dist/utils/file-system.js

@@ -4,7 +4,10 @@ import { promisify } from 'util';
 const mkdir = promisify(fs.mkdir);
 const readFile = promisify(fs.readFile);
 const writeFile = promisify(fs.writeFile);
+const rename = promisify(fs.rename);
+const unlink = promisify(fs.unlink);
 const access = promisify(fs.access);
+let tmpCounter = 0;
 const stat = promisify(fs.stat);
 export async function directoryExists(dirPath) {
     try {
@@ -51,7 +54,18 @@ export async function writeJsonFile(filePath, data) {
         const dirPath = path.dirname(filePath);
         await ensureDirectory(dirPath);
         const content = JSON.stringify(data, null, 2);
-        await writeFile(filePath, content, 'utf-8');
+        const tmpPath = `${filePath}.tmp.${process.pid}.${tmpCounter++}`;
+        try {
+            await writeFile(tmpPath, content, 'utf-8');
+            await rename(tmpPath, filePath);
+        }
+        catch (err) {
+            try {
+                await unlink(tmpPath);
+            }
+            catch { }
+            throw err;
+        }
     }
     catch (error) {
         if (error instanceof Error) {

package/package.json

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