orquesta-cli 0.1.27 → 0.2.1

package/dist/core/slash-command-handler.js

@@ -4,6 +4,7 @@ import { logger } from '../utils/logger.js';
 import { fullSync } from '../orquesta/config-sync.js';
 import { configManager } from './config/config-manager.js';
 import { getForcedTier, setForcedTier, resetBatutaSession } from './routing-state.js';
+import { auditLog } from '../orchestration/audit-log.js';
 export async function executeSlashCommand(command, context) {
     const trimmedCommand = command.trim();
     logger.enter('executeSlashCommand', { command: trimmedCommand });
@@ -169,6 +170,144 @@ export async function executeSlashCommand(command, context) {
             updatedContext: { messages: updatedMessages },
         };
     }
+    if (trimmedCommand === '/role' || trimmedCommand.startsWith('/role ')) {
+        const args = trimmedCommand.slice('/role'.length).trim().split(/\s+/).filter(Boolean);
+        const currentModelId = configManager.getConfig().currentModel ?? 'none';
+        const formatStatus = () => {
+            const roles = ['planner', 'executor', 'refiner'];
+            const lines = roles.map(r => {
+                const override = configManager.getOrchestrationConfig().roleModels?.[r];
+                const effective = override ?? currentModelId;
+                const suffix = override ? '' : '  (fallback to currentModel)';
+                return `  ${r.padEnd(10)} → ${effective}${suffix}`;
+            });
+            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`;
+        };
+        let body;
+        try {
+            if (args.length === 0) {
+                body = formatStatus();
+            }
+            else if (args[0] === 'clear') {
+                await configManager.clearRoleModels();
+                body = 'Role pins cleared. Every role falls back to currentModel.';
+            }
+            else if (args[0] === 'parallel' && args[1]) {
+                const n = parseInt(args[1], 10);
+                if (!Number.isFinite(n) || n < 1) {
+                    body = 'parallel must be an integer >= 1';
+                }
+                else {
+                    await configManager.setMaxParallelWorkers(n);
+                    body = `Max parallel workers set to ${configManager.getMaxParallelWorkers()}.`;
+                }
+            }
+            else if (args[0] === 'worktree' && (args[1] === 'on' || args[1] === 'off')) {
+                await configManager.setWorktreeIsolationEnabled(args[1] === 'on');
+                body = `Worktree isolation: ${args[1]}.`;
+            }
+            else if ((args[0] === 'planner' || args[0] === 'executor' || args[0] === 'refiner') && args[1]) {
+                const role = args[0];
+                if (role === 'refiner' && args[1] === 'off') {
+                    await configManager.setRefinerEnabled(false);
+                    body = 'Refiner pass disabled.';
+                }
+                else {
+                    await configManager.setRoleModel(role, args[1]);
+                    if (role === 'refiner') {
+                        await configManager.setRefinerEnabled(true);
+                        body = `Refiner pinned to ${args[1]} and refiner pass enabled.`;
+                    }
+                    else {
+                        body = `${role} pinned to ${args[1]}.`;
+                    }
+                }
+            }
+            else {
+                body = `Unknown /role usage. Run /role with no args for help.`;
+            }
+        }
+        catch (error) {
+            body = `Error: ${error.message}`;
+        }
+        const updatedMessages = [
+            ...context.messages,
+            { role: 'assistant', content: body },
+        ];
+        context.setMessages(updatedMessages);
+        return {
+            handled: true,
+            shouldContinue: false,
+            updatedContext: { messages: updatedMessages },
+        };
+    }
+    if (trimmedCommand === '/audit' || trimmedCommand.startsWith('/audit ')) {
+        const args = trimmedCommand.slice('/audit'.length).trim().split(/\s+/).filter(Boolean);
+        let body;
+        try {
+            if (args[0] === 'tail') {
+                const n = Number(args[1]) || 20;
+                const events = await auditLog.tail(n);
+                if (events.length === 0) {
+                    body = '(no audit events yet)';
+                }
+                else {
+                    body = `Last ${events.length} audit events:\n\n` + events
+                        .map(e => `[${e.timestamp.slice(11, 19)}] ${e.kind.padEnd(22)} ${JSON.stringify(e.data).slice(0, 140)}`)
+                        .join('\n');
+                }
+            }
+            else if (args[0] === 'clear') {
+                await auditLog.clear();
+                body = 'Audit log cleared.';
+            }
+            else {
+                const sinceDays = args[0] === 'day' ? 1 : args[0] === 'week' ? 7 : undefined;
+                const s = await auditLog.stats({ sinceDays });
+                const period = sinceDays ? `last ${sinceDays}d` : 'lifetime';
+                const plannerLines = Object.entries(s.byPlannerModel)
+                    .map(([m, c]) => `    ${m}: ${c}`).join('\n') || '    (none)';
+                const executorLines = Object.entries(s.byExecutorModel)
+                    .map(([m, c]) => `    ${m}: ${c}`).join('\n') || '    (none)';
+                body = `Orchestration audit (${period})
+
+  runs:                 ${s.runs}
+  parallel runs:        ${s.parallelRuns}
+  sequential runs:      ${s.sequentialRuns}
+  total workers:        ${s.totalWorkers}
+  worker failures:      ${s.workerFailures}
+  avg planner ms:       ${s.avgPlannerMs}
+  avg worker ms:        ${s.avgWorkerMs}
+  avg waves per run:    ${s.avgWavesPerRun}
+  refiner runs:         ${s.refinerRuns}
+  refiner rewrites:     ${s.refinerRewrites}
+
+  by planner model:
+${plannerLines}
+
+  by executor model:
+${executorLines}
+
+  Subcommands: /audit | /audit day | /audit week | /audit tail [N] | /audit clear`;
+            }
+        }
+        catch (error) {
+            body = `Error: ${error.message}`;
+        }
+        const updatedMessages = [
+            ...context.messages,
+            { role: 'assistant', content: body },
+        ];
+        context.setMessages(updatedMessages);
+        return {
+            handled: true,
+            shouldContinue: false,
+            updatedContext: { messages: updatedMessages },
+        };
+    }
     if (trimmedCommand === '/cost') {
         const costMessage = usageTracker.formatCostDisplay();
         const updatedMessages = [

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

@@ -0,0 +1,40 @@
+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 interface AuditEvent {
+    schema: typeof SCHEMA_VERSION;
+    timestamp: string;
+    sessionId: string;
+    runId: string;
+    kind: AuditEventKind;
+    data: Record<string, unknown>;
+}
+declare class AuditLogger {
+    private initialized;
+    private writeQueue;
+    private currentRunId;
+    startRun(sessionId: string, data?: Record<string, unknown>): string;
+    emit(sessionId: string, kind: AuditEventKind, data?: Record<string, unknown>): void;
+    private write;
+    tail(n?: number): Promise<AuditEvent[]>;
+    stats(opts?: {
+        sinceDays?: number;
+    }): Promise<{
+        runs: number;
+        parallelRuns: number;
+        sequentialRuns: number;
+        totalWorkers: number;
+        workerFailures: number;
+        avgPlannerMs: number;
+        avgWorkerMs: number;
+        avgWavesPerRun: number;
+        byPlannerModel: Record<string, number>;
+        byExecutorModel: Record<string, number>;
+        refinerRuns: number;
+        refinerRewrites: number;
+    }>;
+    private readAll;
+    clear(): Promise<void>;
+}
+export declare const auditLog: AuditLogger;
+export {};
+//# sourceMappingURL=audit-log.d.ts.map

package/dist/orchestration/audit-log.js

@@ -0,0 +1,156 @@
+import { promises as fs } from 'fs';
+import * as path from 'path';
+import { LOCAL_HOME_DIR } from '../constants.js';
+import { logger } from '../utils/logger.js';
+const AUDIT_LOG_PATH = path.join(LOCAL_HOME_DIR, 'audit.jsonl');
+const SCHEMA_VERSION = 1;
+class AuditLogger {
+    initialized = false;
+    writeQueue = Promise.resolve();
+    currentRunId = null;
+    startRun(sessionId, data = {}) {
+        this.currentRunId = `run-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+        this.emit(sessionId, 'run.start', data);
+        return this.currentRunId;
+    }
+    emit(sessionId, kind, data = {}) {
+        const runId = (typeof data['runId'] === 'string' ? data['runId'] : null) ?? this.currentRunId ?? 'unknown';
+        const event = {
+            schema: SCHEMA_VERSION,
+            timestamp: new Date().toISOString(),
+            sessionId,
+            runId,
+            kind,
+            data,
+        };
+        this.writeQueue = this.writeQueue.then(() => this.write(event)).catch(() => undefined);
+    }
+    async write(event) {
+        try {
+            if (!this.initialized) {
+                await fs.mkdir(LOCAL_HOME_DIR, { recursive: true });
+                this.initialized = true;
+            }
+            await fs.appendFile(AUDIT_LOG_PATH, JSON.stringify(event) + '\n', 'utf8');
+        }
+        catch (error) {
+            logger.warn('Audit log write failed', { error: error.message });
+        }
+    }
+    async tail(n = 50) {
+        try {
+            const raw = await fs.readFile(AUDIT_LOG_PATH, 'utf8');
+            const lines = raw.split('\n').filter(Boolean);
+            const last = lines.slice(-n);
+            const events = [];
+            for (const line of last) {
+                try {
+                    events.push(JSON.parse(line));
+                }
+                catch {
+                }
+            }
+            return events.reverse();
+        }
+        catch {
+            return [];
+        }
+    }
+    async stats(opts) {
+        const events = await this.readAll();
+        const cutoff = opts?.sinceDays ? Date.now() - opts.sinceDays * 86400_000 : 0;
+        const filtered = cutoff ? events.filter(e => Date.parse(e.timestamp) >= cutoff) : events;
+        const runs = new Set();
+        let parallelRuns = 0;
+        let sequentialRuns = 0;
+        let totalWorkers = 0;
+        let workerFailures = 0;
+        let plannerDurMs = 0;
+        let plannerCount = 0;
+        let workerDurMs = 0;
+        let workerCount = 0;
+        let waveCount = 0;
+        let refinerRuns = 0;
+        let refinerRewrites = 0;
+        const byPlannerModel = {};
+        const byExecutorModel = {};
+        for (const e of filtered) {
+            runs.add(e.runId);
+            const d = e.data;
+            if (e.kind === 'orchestrator.decision') {
+                if (d['parallel'])
+                    parallelRuns++;
+                else
+                    sequentialRuns++;
+            }
+            if (e.kind === 'planner.complete') {
+                plannerCount++;
+                const dur = d['durationMs'];
+                if (typeof dur === 'number')
+                    plannerDurMs += dur;
+                const model = d['model'];
+                if (typeof model === 'string')
+                    byPlannerModel[model] = (byPlannerModel[model] || 0) + 1;
+            }
+            if (e.kind === 'worker.complete') {
+                totalWorkers++;
+                if (d['success'] === false)
+                    workerFailures++;
+                const dur = d['durationMs'];
+                if (typeof dur === 'number') {
+                    workerDurMs += dur;
+                    workerCount++;
+                }
+                const model = d['model'];
+                if (typeof model === 'string')
+                    byExecutorModel[model] = (byExecutorModel[model] || 0) + 1;
+            }
+            if (e.kind === 'wave.complete')
+                waveCount++;
+            if (e.kind === 'refiner.complete') {
+                refinerRuns++;
+                if (d['rewrote'])
+                    refinerRewrites++;
+            }
+        }
+        return {
+            runs: runs.size,
+            parallelRuns,
+            sequentialRuns,
+            totalWorkers,
+            workerFailures,
+            avgPlannerMs: plannerCount ? Math.round(plannerDurMs / plannerCount) : 0,
+            avgWorkerMs: workerCount ? Math.round(workerDurMs / workerCount) : 0,
+            avgWavesPerRun: runs.size ? Number((waveCount / runs.size).toFixed(2)) : 0,
+            byPlannerModel,
+            byExecutorModel,
+            refinerRuns,
+            refinerRewrites,
+        };
+    }
+    async readAll() {
+        try {
+            const raw = await fs.readFile(AUDIT_LOG_PATH, 'utf8');
+            return raw.split('\n').filter(Boolean).flatMap(line => {
+                try {
+                    return [JSON.parse(line)];
+                }
+                catch {
+                    return [];
+                }
+            });
+        }
+        catch {
+            return [];
+        }
+    }
+    async clear() {
+        try {
+            await fs.rm(AUDIT_LOG_PATH, { force: true });
+        }
+        catch {
+        }
+    }
+}
+export const auditLog = new AuditLogger();
+//# sourceMappingURL=audit-log.js.map

package/dist/orchestration/index.d.ts

@@ -1,4 +1,7 @@
 export type { ExecutionPhase, PlanExecutionState, AskUserRequest, AskUserResponse, AskUserState, StateCallbacks, ExecutionContext, ExecutionResult, PlanExecutionActions, } from './types.js';
 export { formatErrorMessage, buildTodoContext, areAllTodosCompleted, findActiveTodo, getTodoStats, } from './utils.js';
 export { PlanExecutor, planExecutor } from './plan-executor.js';
+export { WorktreeManager, worktreeManager, type WorktreeAllocation, type WorktreeBackend, type MergeResult, } from './worktree-manager.js';
+export { MemoryStore, memoryStore, type MemoryEntry, } from './memory-store.js';
+export { auditLog, type AuditEvent, type AuditEventKind, } from './audit-log.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/orchestration/index.js

@@ -1,3 +1,6 @@
 export { formatErrorMessage, buildTodoContext, areAllTodosCompleted, findActiveTodo, getTodoStats, } from './utils.js';
 export { PlanExecutor, planExecutor } from './plan-executor.js';
+export { WorktreeManager, worktreeManager, } from './worktree-manager.js';
+export { MemoryStore, memoryStore, } from './memory-store.js';
+export { auditLog, } from './audit-log.js';
 //# sourceMappingURL=index.js.map

package/dist/orchestration/memory-store.d.ts

@@ -0,0 +1,21 @@
+export interface MemoryEntry {
+    writtenAt: string;
+    source?: 'planner' | 'executor' | 'worker' | 'refiner' | 'user' | string;
+    value: unknown;
+}
+export declare class MemoryStore {
+    private cache;
+    private pendingFlush;
+    private pendingLoad;
+    private filePath;
+    load(sessionId: string): Promise<void>;
+    get(sessionId: string, key: string): MemoryEntry | null;
+    all(sessionId: string): Record<string, MemoryEntry>;
+    bySource(sessionId: string, source: MemoryEntry['source']): MemoryEntry[];
+    set(sessionId: string, key: string, value: unknown, source?: MemoryEntry['source']): Promise<void>;
+    delete(sessionId: string, key: string): Promise<void>;
+    clear(sessionId: string): Promise<void>;
+    private scheduleFlush;
+}
+export declare const memoryStore: MemoryStore;
+//# sourceMappingURL=memory-store.d.ts.map

package/dist/orchestration/memory-store.js

@@ -0,0 +1,102 @@
+import { promises as fs } from 'fs';
+import * as path from 'path';
+import { LOCAL_HOME_DIR } from '../constants.js';
+import { logger } from '../utils/logger.js';
+export class MemoryStore {
+    cache = new Map();
+    pendingFlush = new Map();
+    pendingLoad = new Map();
+    filePath(sessionId) {
+        return path.join(LOCAL_HOME_DIR, 'sessions', sessionId, 'memory.json');
+    }
+    async load(sessionId) {
+        if (this.cache.has(sessionId))
+            return;
+        const inFlight = this.pendingLoad.get(sessionId);
+        if (inFlight)
+            return inFlight;
+        const loadPromise = (async () => {
+            const fp = this.filePath(sessionId);
+            try {
+                const raw = await fs.readFile(fp, 'utf8');
+                const obj = JSON.parse(raw);
+                if (!this.cache.has(sessionId)) {
+                    this.cache.set(sessionId, new Map(Object.entries(obj)));
+                }
+            }
+            catch (error) {
+                const code = error.code;
+                if (code !== 'ENOENT') {
+                    logger.warn('MemoryStore load failed; starting empty', { sessionId, error: error.message });
+                }
+                if (!this.cache.has(sessionId)) {
+                    this.cache.set(sessionId, new Map());
+                }
+            }
+            finally {
+                this.pendingLoad.delete(sessionId);
+            }
+        })();
+        this.pendingLoad.set(sessionId, loadPromise);
+        return loadPromise;
+    }
+    get(sessionId, key) {
+        return this.cache.get(sessionId)?.get(key) ?? null;
+    }
+    all(sessionId) {
+        const map = this.cache.get(sessionId);
+        if (!map)
+            return {};
+        return Object.fromEntries(map);
+    }
+    bySource(sessionId, source) {
+        const map = this.cache.get(sessionId);
+        if (!map)
+            return [];
+        return Array.from(map.values()).filter(e => e.source === source);
+    }
+    async set(sessionId, key, value, source) {
+        if (!this.cache.has(sessionId))
+            await this.load(sessionId);
+        const map = this.cache.get(sessionId);
+        map.set(key, { writtenAt: new Date().toISOString(), source, value });
+        await this.scheduleFlush(sessionId);
+    }
+    async delete(sessionId, key) {
+        const map = this.cache.get(sessionId);
+        if (!map)
+            return;
+        map.delete(key);
+        await this.scheduleFlush(sessionId);
+    }
+    async clear(sessionId) {
+        this.cache.delete(sessionId);
+        const fp = this.filePath(sessionId);
+        await fs.rm(fp, { force: true }).catch(() => { });
+    }
+    async scheduleFlush(sessionId) {
+        const existing = this.pendingFlush.get(sessionId);
+        if (existing)
+            return existing;
+        const flushPromise = (async () => {
+            await new Promise(resolve => setTimeout(resolve, 0));
+            this.pendingFlush.delete(sessionId);
+            const map = this.cache.get(sessionId);
+            if (!map)
+                return;
+            const fp = this.filePath(sessionId);
+            try {
+                await fs.mkdir(path.dirname(fp), { recursive: true });
+                const obj = Object.fromEntries(map);
+                await fs.writeFile(fp, JSON.stringify(obj, null, 2), 'utf8');
+            }
+            catch (error) {
+                logger.warn('MemoryStore flush failed', { sessionId, error: error.message });
+            }
+        })();
+        this.pendingFlush.set(sessionId, flushPromise);
+        return flushPromise;
+    }
+}
+export const memoryStore = new MemoryStore();
+//# sourceMappingURL=memory-store.js.map

package/dist/orchestration/parallel-orchestrator.d.ts

@@ -0,0 +1,22 @@
+import { LLMClient } from '../core/llm/llm-client.js';
+import { Message, TodoItem } from '../types/index.js';
+import type { StateCallbacks } from './types.js';
+export interface ParallelRunResult {
+    newMessages: Message[];
+    todos: TodoItem[];
+    workerOutputs: Record<string, string>;
+}
+export declare function shouldUseParallelOrchestrator(todos: TodoItem[]): boolean;
+export declare function planWaves(todos: TodoItem[]): TodoItem[][];
+export interface RunGraphOptions {
+    llmClient: LLMClient;
+    todos: TodoItem[];
+    baseSystemPrompt: string;
+    sessionId: string;
+    callbacks: StateCallbacks;
+    isInterruptedRef: {
+        current: boolean;
+    };
+}
+export declare function runParallelGraph(opts: RunGraphOptions): Promise<ParallelRunResult>;
+//# sourceMappingURL=parallel-orchestrator.d.ts.map