orquesta-cli 0.2.91 → 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/core/project-context.js

@@ -1,51 +1,85 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import { logger } from '../utils/logger.js';
-const MAX_BYTES = 32_000;
-const CANDIDATE_PATHS = [
+const PER_FILE_MAX_BYTES = 32_000;
+const TOTAL_MAX_BYTES = 48_000;
+const CANDIDATE_FILES = [
     'CLAUDE.md',
     '.claude/CLAUDE.md',
+    'AGENTS.md',
     'AGENT.md',
     'agent.md',
+    'GEMINI.md',
+    'QWEN.md',
+    'KIRO.md',
+];
+const CANDIDATE_DIRS = [
+    '.kiro/steering',
 ];
 let cachedContext;
-function readFirstAvailable(cwd) {
-    for (const rel of CANDIDATE_PATHS) {
+function capFile(content) {
+    if (Buffer.byteLength(content, 'utf-8') > PER_FILE_MAX_BYTES) {
+        return content.slice(0, PER_FILE_MAX_BYTES) + '\n\n[...truncated for context window]';
+    }
+    return content;
+}
+function collectContextFiles(cwd) {
+    const out = [];
+    const seen = new Set();
+    const tryAdd = (rel) => {
         const abs = path.join(cwd, rel);
         try {
             const stat = fs.statSync(abs);
             if (!stat.isFile())
-                continue;
-            let content = fs.readFileSync(abs, 'utf-8');
-            if (Buffer.byteLength(content, 'utf-8') > MAX_BYTES) {
-                content = content.slice(0, MAX_BYTES) + '\n\n[...truncated for context window]';
-            }
-            return { path: rel, content };
+                return;
+            const content = capFile(fs.readFileSync(abs, 'utf-8'));
+            const key = content.trim();
+            if (!key || seen.has(key))
+                return;
+            seen.add(key);
+            out.push({ path: rel, content });
+        }
+        catch {
+        }
+    };
+    for (const rel of CANDIDATE_FILES)
+        tryAdd(rel);
+    for (const dir of CANDIDATE_DIRS) {
+        try {
+            const entries = fs.readdirSync(path.join(cwd, dir)).filter(f => f.toLowerCase().endsWith('.md')).sort();
+            for (const f of entries)
+                tryAdd(path.join(dir, f));
         }
         catch {
-            continue;
         }
     }
-    return null;
+    return out;
 }
 export function getProjectContext(cwd = process.cwd()) {
     if (cachedContext !== undefined)
         return cachedContext ?? '';
-    const hit = readFirstAvailable(cwd);
-    if (!hit) {
+    const files = collectContextFiles(cwd);
+    if (files.length === 0) {
         cachedContext = null;
-        logger.debug('No CLAUDE.md / AGENT.md found in cwd', { cwd });
+        logger.debug('No agent-instruction files (CLAUDE.md / AGENTS.md / …) found in cwd', { cwd });
         return '';
     }
-    logger.info(`Loaded project context from ${hit.path} (${hit.content.length} chars)`);
-    cachedContext = [
-        '',
-        '## PROJECT CONTEXT',
-        `(from ${hit.path} — treat as authoritative project conventions)`,
-        '',
-        hit.content,
-        '',
-    ].join('\n');
+    const sections = ['', '## PROJECT CONTEXT'];
+    let total = 0;
+    const used = [];
+    for (const f of files) {
+        const block = `\n### From ${f.path} (authoritative project conventions)\n\n${f.content}\n`;
+        if (total + Buffer.byteLength(block, 'utf-8') > TOTAL_MAX_BYTES) {
+            logger.debug(`Skipping ${f.path}: merged project context would exceed ${TOTAL_MAX_BYTES} bytes`);
+            continue;
+        }
+        total += Buffer.byteLength(block, 'utf-8');
+        sections.push(block);
+        used.push(f.path);
+    }
+    sections.push('');
+    logger.info(`Loaded project context from ${used.length} file(s): ${used.join(', ')} (${total} bytes)`);
+    cachedContext = sections.join('\n');
     return cachedContext;
 }
 export function invalidateProjectContext() {

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.91",
+  "version": "0.2.93",
   "description": "Orquesta CLI - AI-powered coding assistant with team collaboration",
   "type": "module",
   "main": "dist/index.js",