orquesta-cli 0.1.27 → 0.2.0

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

package/dist/orchestration/parallel-orchestrator.js

@@ -0,0 +1,234 @@
+import { configManager } from '../core/config/config-manager.js';
+import { toolRegistry } from '../tools/registry.js';
+import { logger } from '../utils/logger.js';
+import { worktreeManager } from './worktree-manager.js';
+import { memoryStore } from './memory-store.js';
+import { auditLog } from './audit-log.js';
+export function shouldUseParallelOrchestrator(todos) {
+    if (todos.length < 2)
+        return false;
+    const hasExplicitDeps = todos.some(t => Array.isArray(t.dependsOn) && t.dependsOn.length > 0);
+    if (hasExplicitDeps)
+        return true;
+    const fsTouching = todos.filter(t => t.requiresFilesystem).length;
+    if (fsTouching >= 2)
+        return true;
+    const allIndependent = todos.every(t => !t.dependsOn || t.dependsOn.length === 0);
+    if (allIndependent && todos.length >= 3)
+        return true;
+    return false;
+}
+export function planWaves(todos) {
+    const remaining = new Map(todos.map(t => [t.id, t]));
+    const completed = new Set();
+    const waves = [];
+    while (remaining.size > 0) {
+        const wave = [];
+        for (const todo of remaining.values()) {
+            const deps = todo.dependsOn ?? [];
+            if (deps.every(d => completed.has(d))) {
+                wave.push(todo);
+            }
+        }
+        if (wave.length === 0) {
+            logger.warn('Dependency cycle or missing reference detected; dispatching remaining TODOs as final wave', {
+                remaining: Array.from(remaining.keys()),
+            });
+            wave.push(...remaining.values());
+        }
+        for (const t of wave) {
+            remaining.delete(t.id);
+            completed.add(t.id);
+        }
+        waves.push(wave);
+    }
+    return waves;
+}
+function buildWorkerMessages(ctx) {
+    const upstreamSection = Object.keys(ctx.upstreamOutputs).length > 0
+        ? `\n\nUpstream task outputs (your dependencies):\n${Object.entries(ctx.upstreamOutputs)
+            .map(([id, out]) => `- [${id}] ${truncate(out, 800)}`)
+            .join('\n')}`
+        : '';
+    const cwdNote = ctx.workingDirectory && ctx.workingDirectory !== process.cwd()
+        ? `\n\nIMPORTANT: Run all filesystem and shell operations from this directory: ${ctx.workingDirectory}\nDO NOT cd elsewhere.`
+        : '';
+    return [
+        { role: 'system', content: ctx.baseSystemPrompt },
+        {
+            role: 'user',
+            content: `Execute ONLY this single task and then call final_response with a short summary of what you did. Do not start other tasks.
+
+Task [${ctx.todo.id}]: ${ctx.todo.title}${upstreamSection}${cwdNote}`,
+        },
+    ];
+}
+function truncate(s, n) {
+    if (!s || s.length <= n)
+        return s;
+    return s.slice(0, n) + '… [truncated]';
+}
+async function runWorker(ctx) {
+    const tools = toolRegistry.getLLMToolDefinitions();
+    const messages = buildWorkerMessages(ctx);
+    logger.flow('Worker dispatch', {
+        todoId: ctx.todo.id,
+        model: ctx.executorModel ?? '(default)',
+        cwd: ctx.workingDirectory ?? process.cwd(),
+    });
+    auditLog.emit(ctx.sessionId, 'worker.start', {
+        todoId: ctx.todo.id,
+        model: ctx.executorModel,
+        upstreamCount: Object.keys(ctx.upstreamOutputs).length,
+        isolated: !!ctx.workingDirectory && ctx.workingDirectory !== process.cwd(),
+    });
+    const startedAt = Date.now();
+    const result = await ctx.llmClient.chatCompletionWithTools(messages, tools, {
+        ...(ctx.executorModel ? { model: ctx.executorModel } : {}),
+    });
+    const extractSummary = () => {
+        for (let i = result.allMessages.length - 1; i >= 0; i--) {
+            const m = result.allMessages[i];
+            if (m?.role === 'assistant' && Array.isArray(m.tool_calls)) {
+                for (const tc of m.tool_calls) {
+                    if (tc?.function?.name === 'final_response') {
+                        try {
+                            const args = JSON.parse(tc.function.arguments || '{}');
+                            const msg = args.message ?? args.response ?? args.summary ?? args.content;
+                            if (typeof msg === 'string' && msg.trim())
+                                return msg.trim();
+                        }
+                        catch { }
+                    }
+                }
+            }
+        }
+        for (let i = result.allMessages.length - 1; i >= 0; i--) {
+            const m = result.allMessages[i];
+            if (m?.role === 'assistant' && m.content && m.content.trim()) {
+                return m.content.trim();
+            }
+        }
+        return `(no summary from worker ${ctx.todo.id})`;
+    };
+    const summary = extractSummary();
+    await memoryStore.set(ctx.sessionId, `worker:${ctx.todo.id}`, {
+        title: ctx.todo.title,
+        summary,
+        completedAt: new Date().toISOString(),
+    }, 'worker');
+    auditLog.emit(ctx.sessionId, 'worker.complete', {
+        todoId: ctx.todo.id,
+        model: ctx.executorModel,
+        durationMs: Date.now() - startedAt,
+        summaryLength: summary.length,
+        success: true,
+    });
+    return { summary, messages: result.allMessages };
+}
+export async function runParallelGraph(opts) {
+    const { llmClient, callbacks, isInterruptedRef, sessionId, baseSystemPrompt } = opts;
+    const executorModel = configManager.getRoleModel('executor') ?? undefined;
+    const maxParallel = configManager.getMaxParallelWorkers();
+    const useWorktrees = configManager.isWorktreeIsolationEnabled();
+    const todos = opts.todos.map(t => ({ ...t }));
+    const todoById = new Map(todos.map(t => [t.id, t]));
+    const outputs = {};
+    const allNewMessages = [];
+    const waves = planWaves(todos);
+    logger.flow('Parallel orchestrator plan', {
+        waveCount: waves.length,
+        waveSizes: waves.map(w => w.length),
+        maxParallel,
+    });
+    for (const [waveIdx, wave] of waves.entries()) {
+        if (isInterruptedRef.current)
+            throw new Error('INTERRUPTED');
+        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);
+            for (const t of batch) {
+                const item = todoById.get(t.id);
+                item.status = 'in_progress';
+            }
+            callbacks.setTodos([...todos]);
+            const allocations = new Map();
+            if (useWorktrees) {
+                for (const t of batch) {
+                    if (t.requiresFilesystem) {
+                        try {
+                            const alloc = await worktreeManager.allocate(t.id);
+                            allocations.set(t.id, alloc.path);
+                        }
+                        catch (error) {
+                            logger.warn('Worktree allocation failed; worker will run in host cwd', { todoId: t.id, error: error.message });
+                        }
+                    }
+                }
+            }
+            const settled = await Promise.allSettled(batch.map(t => runWorker({
+                todo: todoById.get(t.id),
+                sessionId,
+                llmClient,
+                baseSystemPrompt,
+                executorModel,
+                upstreamOutputs: (t.dependsOn ?? []).reduce((acc, depId) => {
+                    if (outputs[depId])
+                        acc[depId] = outputs[depId];
+                    return acc;
+                }, {}),
+                workingDirectory: allocations.get(t.id),
+            })));
+            for (let k = 0; k < settled.length; k++) {
+                const t = batch[k];
+                const item = todoById.get(t.id);
+                const res = settled[k];
+                if (res.status === 'fulfilled') {
+                    outputs[t.id] = res.value.summary;
+                    item.status = 'completed';
+                    item.result = res.value.summary;
+                    allNewMessages.push(...res.value.messages);
+                }
+                else {
+                    const err = res.reason;
+                    item.status = 'failed';
+                    item.error = err?.message || String(err);
+                    logger.error('Worker failed', err);
+                    auditLog.emit(sessionId, 'worker.complete', {
+                        todoId: t.id,
+                        model: executorModel,
+                        success: false,
+                        error: err?.message,
+                    });
+                }
+            }
+            callbacks.setTodos([...todos]);
+            auditLog.emit(sessionId, 'wave.complete', {
+                waveIdx,
+                size: batch.length,
+                durationMs: Date.now() - waveStartedAt,
+                succeeded: batch.filter((_, k) => settled[k].status === 'fulfilled').length,
+                failed: batch.filter((_, k) => settled[k].status === 'rejected').length,
+            });
+            if (useWorktrees) {
+                for (const [todoId] of allocations) {
+                    const item = todoById.get(todoId);
+                    if (item.status === 'completed') {
+                        const merge = await worktreeManager.mergeBack(todoId);
+                        if (!merge.success) {
+                            logger.warn('Worktree merge had conflicts; left in place for manual resolution', {
+                                todoId,
+                                conflicts: merge.conflicts,
+                            });
+                            continue;
+                        }
+                    }
+                    await worktreeManager.release(todoId);
+                }
+            }
+        }
+    }
+    return { newMessages: allNewMessages, todos, workerOutputs: outputs };
+}
+//# sourceMappingURL=parallel-orchestrator.js.map

package/dist/orchestration/plan-executor.d.ts

@@ -22,6 +22,7 @@ export declare class PlanExecutor {
         percent: number;
     };
     private setupTodoCallbacks;
+    private maybeRunRefiner;
     private checkAndPerformAutoCompact;
 }
 export declare const planExecutor: PlanExecutor;

package/dist/orchestration/plan-executor.js

@@ -14,6 +14,9 @@ import { logger } from '../utils/logger.js';
 import { getStreamLogger } from '../utils/json-stream-logger.js';
 import { detectGitRepo } from '../utils/git-utils.js';
 import { formatErrorMessage, buildTodoContext, findActiveTodo, getTodoStats } from './utils.js';
+import { runParallelGraph, shouldUseParallelOrchestrator } from './parallel-orchestrator.js';
+import { memoryStore } from './memory-store.js';
+import { auditLog } from './audit-log.js';
 function buildSystemPrompt() {
     const isGitRepo = detectGitRepo();
     const projectContext = getProjectContext();
@@ -41,17 +44,36 @@ export class PlanExecutor {
         callbacks.setExecutionPhase('planning');
         callbacks.setCurrentActivity('Planning tasks');
         let currentTodos = [];
+        const auditSid = sessionManager.getCurrentSessionId() || 'no-session';
+        const runId = auditLog.startRun(auditSid, {
+            currentModel: configManager.getConfig().currentModel,
+            plannerModel: configManager.getRoleModel('planner'),
+            executorModel: configManager.getRoleModel('executor'),
+            refinerModel: configManager.getRoleModel('refiner'),
+            refinerEnabled: configManager.isRefinerEnabled(),
+            worktreeEnabled: configManager.isWorktreeIsolationEnabled(),
+            maxParallel: configManager.getMaxParallelWorkers(),
+        });
         try {
             if (isInterruptedRef.current) {
                 throw new Error('INTERRUPTED');
             }
             let currentMessages = messages;
             callbacks.setCurrentActivity('Thinking');
-            const planningLLM = new PlanningLLM(llmClient);
+            const plannerModel = configManager.getRoleModel('planner');
+            const planningLLM = new PlanningLLM(llmClient, plannerModel ?? undefined);
+            const plannerStartedAt = Date.now();
             if (callbacks.askUser) {
                 planningLLM.setAskUserCallback(callbacks.askUser);
             }
             const planResult = await planningLLM.generateTODOListWithDocsDecision(userMessage, currentMessages);
+            auditLog.emit(auditSid, 'planner.complete', {
+                runId,
+                model: plannerModel,
+                durationMs: Date.now() - plannerStartedAt,
+                todoCount: planResult.todos.length,
+                directResponse: !!planResult.directResponse,
+            });
             if (planResult.clarificationMessages?.length) {
                 currentMessages = [...currentMessages, ...planResult.clarificationMessages];
                 callbacks.setMessages([...currentMessages]);
@@ -119,28 +141,69 @@ export class PlanExecutor {
             }
             const activeTodo = findActiveTodo(currentTodos);
             callbacks.setCurrentActivity(activeTodo?.title || 'Working on tasks');
-            const todoContext = buildTodoContext(currentTodos);
-            const lastUserMsgIndex = currentMessages.map(m => m.role).lastIndexOf('user');
-            const messagesForLLM = lastUserMsgIndex >= 0
-                ? currentMessages.map((m, i) => i === lastUserMsgIndex
-                    ? { ...m, content: m.content + todoContext }
-                    : m)
-                : [...currentMessages, { role: 'user', content: `Execute the TODO list.${todoContext}` }];
-            const result = await llmClient.chatCompletionWithTools(messagesForLLM, tools, {
-                getPendingMessage: callbacks.getPendingMessage,
-                clearPendingMessage: callbacks.clearPendingMessage,
+            const sessionId = sessionManager.getCurrentSessionId();
+            if (sessionId) {
+                await memoryStore.set(sessionId, 'plan', {
+                    todos: currentTodos.map(t => ({
+                        id: t.id, title: t.title, dependsOn: t.dependsOn, requiresFilesystem: t.requiresFilesystem,
+                    })),
+                    userMessage,
+                }, 'planner');
+            }
+            const useParallel = shouldUseParallelOrchestrator(currentTodos);
+            auditLog.emit(auditSid, 'orchestrator.decision', {
+                runId,
+                parallel: useParallel,
+                todoCount: currentTodos.length,
+                explicitDeps: currentTodos.filter(t => Array.isArray(t.dependsOn) && t.dependsOn.length > 0).length,
+                requiresFilesystem: currentTodos.filter(t => t.requiresFilesystem).length,
             });
-            const newMessages = result.allMessages.slice(currentMessages.length);
-            currentMessages = [...currentMessages, ...newMessages];
-            callbacks.setMessages([...currentMessages]);
-            sessionManager.autoSaveCurrentSession(currentMessages);
+            if (useParallel && sessionId) {
+                logger.flow('Dispatching parallel orchestrator', { todoCount: currentTodos.length });
+                const baseSystem = currentMessages.find(m => m.role === 'system')?.content || buildSystemPrompt();
+                const graphResult = await runParallelGraph({
+                    llmClient,
+                    todos: currentTodos,
+                    baseSystemPrompt: baseSystem,
+                    sessionId,
+                    callbacks,
+                    isInterruptedRef,
+                });
+                currentTodos = graphResult.todos;
+                callbacks.setTodos([...currentTodos]);
+                currentMessages = [...currentMessages, ...graphResult.newMessages];
+                callbacks.setMessages([...currentMessages]);
+                sessionManager.autoSaveCurrentSession(currentMessages);
+            }
+            else {
+                const todoContext = buildTodoContext(currentTodos);
+                const lastUserMsgIndex = currentMessages.map(m => m.role).lastIndexOf('user');
+                const messagesForLLM = lastUserMsgIndex >= 0
+                    ? currentMessages.map((m, i) => i === lastUserMsgIndex
+                        ? { ...m, content: m.content + todoContext }
+                        : m)
+                    : [...currentMessages, { role: 'user', content: `Execute the TODO list.${todoContext}` }];
+                const executorModel = configManager.getRoleModel('executor');
+                const result = await llmClient.chatCompletionWithTools(messagesForLLM, tools, {
+                    getPendingMessage: callbacks.getPendingMessage,
+                    clearPendingMessage: callbacks.clearPendingMessage,
+                    ...(executorModel ? { model: executorModel } : {}),
+                });
+                const newMessages = result.allMessages.slice(currentMessages.length);
+                currentMessages = [...currentMessages, ...newMessages];
+                callbacks.setMessages([...currentMessages]);
+                sessionManager.autoSaveCurrentSession(currentMessages);
+            }
             await this.checkAndPerformAutoCompact(llmClient, currentMessages, currentTodos, callbacks, (updated) => { currentMessages = updated; });
+            currentMessages = await this.maybeRunRefiner(llmClient, currentMessages, currentTodos, callbacks);
             const stats = getTodoStats(currentTodos);
             sessionManager.autoSaveCurrentSession(currentMessages);
+            auditLog.emit(auditSid, 'run.complete', { runId, ...stats });
             logger.exit('PlanExecutor.executePlanMode', { success: true, ...stats });
         }
         catch (error) {
             if (error instanceof Error && error.message === 'INTERRUPTED') {
+                auditLog.emit(auditSid, 'run.error', { runId, reason: 'interrupted' });
                 logger.flow('Plan mode interrupted by user');
                 callbacks.setMessages((prev) => {
                     const updatedMessages = [
@@ -152,6 +215,7 @@ export class PlanExecutor {
                 });
                 return;
             }
+            auditLog.emit(auditSid, 'run.error', { runId, message: error?.message });
             logger.error('Plan mode execution failed', error);
             const errorMessage = formatErrorMessage(error);
             callbacks.setMessages((prev) => {
@@ -211,9 +275,11 @@ export class PlanExecutor {
                     ? { ...m, content: m.content + todoContext }
                     : m)
                 : [...currentMessages, { role: 'user', content: `Resume the TODO list.${todoContext}` }];
+            const executorModel = configManager.getRoleModel('executor');
             const result = await llmClient.chatCompletionWithTools(messagesForLLM, tools, {
                 getPendingMessage: callbacks.getPendingMessage,
                 clearPendingMessage: callbacks.clearPendingMessage,
+                ...(executorModel ? { model: executorModel } : {}),
             });
             const newMessages = result.allMessages.slice(currentMessages.length);
             currentMessages = [...currentMessages, ...newMessages];
@@ -350,6 +416,81 @@ export class PlanExecutor {
             emitAssistantResponse(message);
         });
     }
+    async maybeRunRefiner(llmClient, currentMessages, currentTodos, callbacks) {
+        if (!configManager.isRefinerEnabled())
+            return currentMessages;
+        const refinerModel = configManager.getRoleModel('refiner');
+        if (!refinerModel)
+            return currentMessages;
+        const lastAssistantIdx = [...currentMessages].map(m => m.role).lastIndexOf('assistant');
+        if (lastAssistantIdx < 0)
+            return currentMessages;
+        const draft = currentMessages[lastAssistantIdx].content || '';
+        if (!draft.trim())
+            return currentMessages;
+        callbacks.setExecutionPhase('executing');
+        callbacks.setCurrentActivity('Refining response');
+        try {
+            const todoSummary = currentTodos
+                .map(t => `- [${t.status}] ${t.title}`)
+                .join('\n');
+            const sessionId = sessionManager.getCurrentSessionId();
+            let workerSummariesBlock = '';
+            if (sessionId) {
+                await memoryStore.load(sessionId);
+                const workerEntries = memoryStore.bySource(sessionId, 'worker');
+                if (workerEntries.length > 0) {
+                    workerSummariesBlock = '\n\nPer-task worker outputs:\n' + workerEntries
+                        .map(e => {
+                        const v = e.value;
+                        return `- ${v.title ?? '(untitled)'}: ${(v.summary ?? '').slice(0, 600)}`;
+                    })
+                        .join('\n');
+                }
+            }
+            const refinerSystem = `You are a refiner reviewing another model's final answer.
+Tasks completed:
+${todoSummary || '(none)'}${workerSummariesBlock}
+
+Read the draft response below. If it is coherent, accurate, and well-structured, repeat it verbatim. If it is unclear, contradicts the completed tasks, or could be tighter, rewrite it concisely. Output ONLY the final user-facing message — no commentary, no preface.`;
+            const response = await llmClient.chatCompletion({
+                messages: [
+                    { role: 'system', content: refinerSystem },
+                    { role: 'user', content: `Draft response:\n\n${draft}` },
+                ],
+                model: refinerModel,
+                temperature: 0.2,
+                max_tokens: 2000,
+            });
+            const refined = response.choices?.[0]?.message?.content?.trim();
+            const auditSid = sessionManager.getCurrentSessionId() || 'no-session';
+            if (refined && refined !== draft.trim()) {
+                const next = [...currentMessages];
+                next[lastAssistantIdx] = { ...next[lastAssistantIdx], content: refined };
+                callbacks.setMessages([...next]);
+                logger.flow('Refiner rewrote final response', {
+                    originalLength: draft.length,
+                    refinedLength: refined.length,
+                });
+                auditLog.emit(auditSid, 'refiner.complete', {
+                    model: refinerModel,
+                    rewrote: true,
+                    originalLength: draft.length,
+                    refinedLength: refined.length,
+                });
+                return next;
+            }
+            logger.flow('Refiner kept original response');
+            auditLog.emit(auditSid, 'refiner.complete', { model: refinerModel, rewrote: false });
+            return currentMessages;
+        }
+        catch (error) {
+            logger.warn('Refiner pass failed, keeping original draft', { error: error.message });
+            const auditSid = sessionManager.getCurrentSessionId() || 'no-session';
+            auditLog.emit(auditSid, 'refiner.complete', { model: refinerModel, rewrote: false, error: error.message });
+            return currentMessages;
+        }
+    }
     async checkAndPerformAutoCompact(llmClient, currentMessages, currentTodos, callbacks, updateLocalMessages) {
         const model = configManager.getCurrentModel();
         const maxTokens = model?.maxTokens || 128000;

package/dist/orchestration/worktree-manager.d.ts

@@ -0,0 +1,25 @@
+export type WorktreeBackend = 'git' | 'copy';
+export interface WorktreeAllocation {
+    id: string;
+    path: string;
+    backend: WorktreeBackend;
+    branch?: string;
+}
+export interface MergeResult {
+    success: boolean;
+    filesChanged: string[];
+    conflicts: string[];
+    error?: string;
+}
+export declare class WorktreeManager {
+    private allocations;
+    private readonly tmpRoot;
+    constructor(tmpRoot?: string);
+    allocate(id: string, hostCwd?: string): Promise<WorktreeAllocation>;
+    mergeBack(id: string, hostCwd?: string): Promise<MergeResult>;
+    release(id: string, hostCwd?: string): Promise<void>;
+    releaseAll(hostCwd?: string): Promise<void>;
+    listActive(): WorktreeAllocation[];
+}
+export declare const worktreeManager: WorktreeManager;
+//# sourceMappingURL=worktree-manager.d.ts.map

package/dist/orchestration/worktree-manager.js

@@ -0,0 +1,124 @@
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { promises as fs } from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { logger } from '../utils/logger.js';
+const execAsync = promisify(exec);
+async function isGitRepo(cwd) {
+    try {
+        await execAsync('git rev-parse --is-inside-work-tree', { cwd });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function gitRepoRoot(cwd) {
+    const { stdout } = await execAsync('git rev-parse --show-toplevel', { cwd });
+    return stdout.trim();
+}
+export class WorktreeManager {
+    allocations = new Map();
+    tmpRoot;
+    constructor(tmpRoot) {
+        this.tmpRoot = tmpRoot ?? path.join(os.tmpdir(), 'orquesta-cli-worktrees');
+    }
+    async allocate(id, hostCwd = process.cwd()) {
+        if (this.allocations.has(id)) {
+            throw new Error(`Worktree already allocated for id=${id}`);
+        }
+        const gitMode = await isGitRepo(hostCwd);
+        let allocation;
+        if (gitMode) {
+            const repoRoot = await gitRepoRoot(hostCwd);
+            const branch = `orquesta/worker-${id}-${Date.now()}`;
+            const worktreeDir = path.join(this.tmpRoot, 'git', id);
+            await fs.mkdir(path.dirname(worktreeDir), { recursive: true });
+            await execAsync(`git worktree add -b ${branch} "${worktreeDir}" HEAD`, { cwd: repoRoot });
+            allocation = { id, path: worktreeDir, backend: 'git', branch };
+            logger.flow('Allocated git worktree', { id, branch, path: worktreeDir });
+        }
+        else {
+            const copyDir = path.join(this.tmpRoot, 'copy', id);
+            await fs.mkdir(copyDir, { recursive: true });
+            try {
+                await execAsync(`rsync -a --exclude='.git' "${hostCwd}/" "${copyDir}/"`);
+            }
+            catch {
+                await execAsync(`cp -a "${hostCwd}/." "${copyDir}/"`);
+            }
+            allocation = { id, path: copyDir, backend: 'copy' };
+            logger.flow('Allocated copy worktree', { id, path: copyDir });
+        }
+        this.allocations.set(id, allocation);
+        return allocation;
+    }
+    async mergeBack(id, hostCwd = process.cwd()) {
+        const alloc = this.allocations.get(id);
+        if (!alloc) {
+            return { success: false, filesChanged: [], conflicts: [], error: `No allocation for id=${id}` };
+        }
+        try {
+            if (alloc.backend === 'git' && alloc.branch) {
+                const repoRoot = await gitRepoRoot(hostCwd);
+                const { stdout: diffStat } = await execAsync(`git diff --name-only HEAD ${alloc.branch}`, { cwd: repoRoot });
+                const filesChanged = diffStat.split('\n').map(s => s.trim()).filter(Boolean);
+                try {
+                    await execAsync(`git merge --no-ff ${alloc.branch}`, { cwd: repoRoot });
+                    return { success: true, filesChanged, conflicts: [] };
+                }
+                catch (mergeError) {
+                    const { stdout: conflicts } = await execAsync('git diff --name-only --diff-filter=U', { cwd: repoRoot }).catch(() => ({ stdout: '' }));
+                    await execAsync('git merge --abort', { cwd: repoRoot }).catch(() => { });
+                    return {
+                        success: false,
+                        filesChanged,
+                        conflicts: conflicts.split('\n').map(s => s.trim()).filter(Boolean),
+                        error: mergeError.message,
+                    };
+                }
+            }
+            const { stdout: rawDiff } = await execAsync(`rsync -avc --dry-run --exclude='.git' "${alloc.path}/" "${hostCwd}/"`).catch(() => ({ stdout: '' }));
+            const filesChanged = rawDiff
+                .split('\n')
+                .filter(line => line && !line.startsWith('sending') && !line.startsWith('total') && !line.startsWith('sent ') && !line.includes('xfer#'))
+                .map(s => s.trim())
+                .filter(Boolean);
+            await execAsync(`rsync -a --exclude='.git' "${alloc.path}/" "${hostCwd}/"`);
+            return { success: true, filesChanged, conflicts: [] };
+        }
+        catch (error) {
+            return { success: false, filesChanged: [], conflicts: [], error: error.message };
+        }
+    }
+    async release(id, hostCwd = process.cwd()) {
+        const alloc = this.allocations.get(id);
+        if (!alloc)
+            return;
+        try {
+            if (alloc.backend === 'git') {
+                const repoRoot = await gitRepoRoot(hostCwd);
+                await execAsync(`git worktree remove --force "${alloc.path}"`, { cwd: repoRoot }).catch(() => { });
+                if (alloc.branch) {
+                    await execAsync(`git branch -D ${alloc.branch}`, { cwd: repoRoot }).catch(() => { });
+                }
+            }
+            else {
+                await fs.rm(alloc.path, { recursive: true, force: true }).catch(() => { });
+            }
+        }
+        finally {
+            this.allocations.delete(id);
+        }
+    }
+    async releaseAll(hostCwd = process.cwd()) {
+        const ids = Array.from(this.allocations.keys());
+        await Promise.all(ids.map(id => this.release(id, hostCwd)));
+    }
+    listActive() {
+        return Array.from(this.allocations.values());
+    }
+}
+export const worktreeManager = new WorktreeManager();
+//# sourceMappingURL=worktree-manager.js.map