orquesta-cli 0.2.93 → 0.2.95

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';
@@ -152,20 +153,15 @@ program
     if (options.appendSystemPrompt) {
         setAppendedSystemPrompt(options.appendSystemPrompt);
     }
+    await configManager.initialize();
+    await ensureBatutaFromEnv();
     if (options.endpoint) {
-        await configManager.initialize();
-        await ensureBatutaFromEnv();
-        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`);
@@ -188,8 +184,6 @@ program
         disableHooks();
         return;
     }
-    await configManager.initialize();
-    await ensureBatutaFromEnv();
     if (shouldShowOnboarding()) {
         await runOnboarding();
     }

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/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');

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

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