@lasso-ai/cli 1.3.1 → 1.3.3

package/dist/cli/bridge.js

@@ -17,6 +17,7 @@ const chalk_1 = __importDefault(require("chalk"));
 const agent_1 = require("./agent");
 const project_1 = require("./project");
 const auth_1 = require("./auth");
+const snapshot_1 = require("./snapshot");
 exports.DEFAULT_BRIDGE_PORT = 3056;
 const execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
 async function restartBridge(port = exports.DEFAULT_BRIDGE_PORT) {
@@ -147,6 +148,164 @@ function proposalMatchesCurrentSource(cwd, changes) {
         return false;
     }
 }
+async function triggerBuildFix(cwd, taskId, buildErrors, buildCommand, originalChanges, resolvedLassoKey, agentConfig, collabConfig, socket, taskControllers, taskSnapshots, buildErrorContext) {
+    const MAX_RETRIES = 3;
+    const context = buildErrorContext.get(taskId);
+    if (!context)
+        return;
+    context.retryCount += 1;
+    if (context.retryCount > MAX_RETRIES) {
+        // Max retries reached - revert changes and show error
+        for (const snapshot of taskSnapshots.get(taskId) || []) {
+            if (snapshot.content === null) {
+                if (node_fs_1.default.existsSync(snapshot.filePath))
+                    node_fs_1.default.unlinkSync(snapshot.filePath);
+            }
+            else {
+                node_fs_1.default.writeFileSync(snapshot.filePath, snapshot.content);
+            }
+        }
+        taskSnapshots.delete(taskId);
+        buildErrorContext.delete(taskId);
+        socket.send(JSON.stringify({
+            type: "agent_status",
+            taskId,
+            status: "error",
+            message: `⚠️ Build validation failed after ${MAX_RETRIES} attempts. The change was reverted. Errors:\n${buildErrors.slice(0, 5).join("\n")}${buildErrors.length > 5 ? `\n... and ${buildErrors.length - 5} more errors` : ""}`
+        }));
+        return;
+    }
+    // Re-apply the original changes
+    try {
+        const planned = new Map();
+        for (const change of originalChanges) {
+            const isNew = !change.oldString;
+            const filePath = resolveProposedFile(cwd, change.filePath, true);
+            const exists = node_fs_1.default.existsSync(filePath);
+            const content = exists ? node_fs_1.default.readFileSync(filePath, "utf8") : "";
+            const prepared = (!exists || isNew)
+                ? { start: 0, end: content.length, oldString: content, newString: change.newString }
+                : prepareChange(content, change);
+            const fileChanges = planned.get(filePath) || [];
+            if (fileChanges.some((item) => prepared.start < item.end && item.start < prepared.end)) {
+                throw new Error(`Could not safely apply ${change.filePath}. Proposed changes overlap.`);
+            }
+            fileChanges.push({ filePath, content, exists, ...prepared });
+            planned.set(filePath, fileChanges);
+        }
+        for (const [filePath, changes] of planned) {
+            const exists = changes[0].exists;
+            const content = changes[0].content;
+            const nextContent = exists
+                ? [...changes]
+                    .sort((a, b) => b.start - a.start)
+                    .reduce((value, change) => value.slice(0, change.start) + change.newString + value.slice(change.end), content)
+                : changes[0].newString;
+            node_fs_1.default.mkdirSync(node_path_1.default.dirname(filePath), { recursive: true });
+            node_fs_1.default.writeFileSync(filePath, nextContent);
+        }
+    }
+    catch (applyError) {
+        socket.send(JSON.stringify({
+            type: "agent_status",
+            taskId,
+            status: "error",
+            message: `Failed to re-apply original changes: ${applyError instanceof Error ? applyError.message : "Unknown error"}`
+        }));
+        return;
+    }
+    // Run agent to fix build errors
+    const { runOneShotAgent } = await import("./oneshot.js");
+    const fixPrompt = `The previous change caused build errors. Please fix them. Build command: ${buildCommand}\n\nBuild errors:\n${buildErrors.slice(0, 10).join("\n")}${buildErrors.length > 10 ? `\n... and ${buildErrors.length - 10} more errors` : ""}\n\nFix these errors by making minimal changes to the files. Attempt ${context.retryCount} of ${MAX_RETRIES}.`;
+    const controller = new AbortController();
+    taskControllers.set(taskId, controller);
+    socket.send(JSON.stringify({ type: "agent_status", taskId, status: "thinking", message: `Fixing build errors (attempt ${context.retryCount}/${MAX_RETRIES})...` }));
+    try {
+        const result = await runOneShotAgent(cwd, fixPrompt, "project", { provider: "google", model: "gemini-2.5-flash", lassoKey: resolvedLassoKey, serverUrl: "https://api.lasso.byorello.space" }, controller.signal, (status, message, detail) => {
+            if (!controller.signal.aborted && socket.readyState === socket.OPEN) {
+                socket.send(JSON.stringify({ type: "agent_status", taskId, status, message, detail }));
+            }
+        }, (prompt) => {
+            if (!controller.signal.aborted && socket.readyState === socket.OPEN) {
+                socket.send(JSON.stringify({ type: "agent_prompt", taskId, prompt }));
+            }
+        }, undefined, "https://api.lasso.byorello.space", resolvedLassoKey || agentConfig?.apiKey || collabConfig?.apiKey, taskId, undefined);
+        if (result.ok && result.changes && result.changes.length > 0) {
+            // Apply the fix
+            const snapshots = [];
+            const planned = new Map();
+            for (const change of result.changes) {
+                const isNew = !change.oldString;
+                const filePath = resolveProposedFile(cwd, change.filePath, true);
+                const exists = node_fs_1.default.existsSync(filePath);
+                const content = exists ? node_fs_1.default.readFileSync(filePath, "utf8") : "";
+                const prepared = (!exists || isNew)
+                    ? { start: 0, end: content.length, oldString: content, newString: change.newString }
+                    : prepareChange(content, change);
+                const fileChanges = planned.get(filePath) || [];
+                if (fileChanges.some((item) => prepared.start < item.end && item.start < prepared.end)) {
+                    throw new Error(`Could not safely apply ${change.filePath}. Proposed changes overlap.`);
+                }
+                fileChanges.push({ filePath, content, exists, ...prepared });
+                planned.set(filePath, fileChanges);
+            }
+            taskSnapshots.set(taskId, snapshots);
+            for (const [filePath, changes] of planned) {
+                const exists = changes[0].exists;
+                const content = changes[0].content;
+                snapshots.push({ filePath, content: exists ? content : null });
+                const nextContent = exists
+                    ? [...changes]
+                        .sort((a, b) => b.start - a.start)
+                        .reduce((value, change) => value.slice(0, change.start) + change.newString + value.slice(change.end), content)
+                    : changes[0].newString;
+                node_fs_1.default.mkdirSync(node_path_1.default.dirname(filePath), { recursive: true });
+                node_fs_1.default.writeFileSync(filePath, nextContent);
+            }
+            // Validate the fix
+            const validation = await validateBuild(cwd);
+            if (validation.passed) {
+                // Build fixed!
+                buildErrorContext.delete(taskId);
+                socket.send(JSON.stringify({
+                    type: "applied",
+                    taskId,
+                    message: `Build errors fixed after ${context.retryCount} attempt${context.retryCount > 1 ? "s" : ""}. ${result.changes.length} file${result.changes.length === 1 ? "" : "s"} updated.`,
+                    validation
+                }));
+            }
+            else {
+                // Still failing - trigger another retry
+                socket.send(JSON.stringify({
+                    type: "agent_status",
+                    taskId,
+                    status: "working",
+                    message: `⚠️ Build still failing. Retrying...`,
+                    detail: `Build command: ${validation.command}\nErrors:\n${validation.errors.slice(0, 5).join("\n")}${validation.errors.length > 5 ? `\n... and ${validation.errors.length - 5} more errors` : ""}`
+                }));
+                // Update context with new errors
+                buildErrorContext.set(taskId, {
+                    errors: validation.errors,
+                    command: validation.command,
+                    originalChanges: originalChanges,
+                    retryCount: context.retryCount
+                });
+                await triggerBuildFix(cwd, taskId, validation.errors, validation.command, originalChanges, resolvedLassoKey, agentConfig, collabConfig, socket, taskControllers, taskSnapshots, buildErrorContext);
+            }
+        }
+        else {
+            // Agent failed to produce a fix
+            socket.send(JSON.stringify({ type: "agent_status", taskId, status: "error", message: result.error || "Failed to fix build errors" }));
+        }
+    }
+    catch (error) {
+        socket.send(JSON.stringify({ type: "agent_status", taskId, status: "error", message: error instanceof Error ? error.message : "Build fix encountered an error" }));
+    }
+    finally {
+        if (taskControllers.get(taskId) === controller)
+            taskControllers.delete(taskId);
+    }
+}
 async function validateBuild(cwd) {
     const pkgPath = node_path_1.default.join(cwd, "package.json");
     if (!node_fs_1.default.existsSync(pkgPath)) {
@@ -257,6 +416,7 @@ async function startBridge(cwd = process.cwd(), collabConfig = null, bridgePort
     const editRequests = new Map();
     const editConfigs = new Map();
     const reviewRefreshAttempts = new Map();
+    const buildErrorContext = new Map();
     const envRoots = [cwd, node_path_1.default.join(cwd, "web"), node_path_1.default.join(cwd, "server")];
     const fileEnv = envRoots.reduce((values, root) => ({
         ...values,
@@ -276,6 +436,120 @@ async function startBridge(cwd = process.cwd(), collabConfig = null, bridgePort
         fileEnv.NEXT_LASSO_API_KEY ||
         "";
     const lassoKeyConfigured = Boolean(resolvedLassoKey);
+    // Task queue for concurrent execution
+    const MAX_CONCURRENT_TASKS = 3;
+    const taskQueue = [];
+    const runningTasks = new Set();
+    const taskPriority = new Map(); // Lower number = higher priority
+    // Will be set when WebSocket connects
+    let currentSocket = null;
+    function processTaskQueue() {
+        if (runningTasks.size >= MAX_CONCURRENT_TASKS || taskQueue.length === 0 || !currentSocket)
+            return;
+        const socket = currentSocket; // Capture non-null reference
+        taskQueue.sort((a, b) => {
+            const priorityA = taskPriority.get(a.taskId) ?? 999;
+            const priorityB = taskPriority.get(b.taskId) ?? 999;
+            return priorityA - priorityB;
+        });
+        const task = taskQueue.shift();
+        if (!task)
+            return;
+        runningTasks.add(task.taskId);
+        if (task.message.type === "edit") {
+            const request = task.message;
+            taskControllers.get(request.taskId)?.abort();
+            const controller = new AbortController();
+            taskControllers.set(request.taskId, controller);
+            if (socket.readyState === socket.OPEN) {
+                socket.send(JSON.stringify({ type: "agent_status", taskId: request.taskId, status: "working", message: "Working…" }));
+            }
+            void (0, agent_1.proposeChanges)(cwd, request, task.config, controller.signal, (message, detail, level) => {
+                if (!controller.signal.aborted && socket.readyState === socket.OPEN) {
+                    socket.send(JSON.stringify({ type: "agent_status", taskId: request.taskId, status: level === "error" ? "error" : "working", message, detail }));
+                }
+            }, (prompt) => {
+                if (!controller.signal.aborted && socket.readyState === socket.OPEN) {
+                    socket.send(JSON.stringify({ type: "agent_prompt", taskId: request.taskId, prompt }));
+                }
+            })
+                .then((proposal) => {
+                if (controller.signal.aborted || socket.readyState !== socket.OPEN)
+                    return;
+                if (!proposalMatchesCurrentSource(cwd, proposal.changes)) {
+                    const refreshAttempts = reviewRefreshAttempts.get(request.taskId) || 0;
+                    const MAX_REFRESH_ATTEMPTS = 3;
+                    if (refreshAttempts < MAX_REFRESH_ATTEMPTS) {
+                        reviewRefreshAttempts.set(request.taskId, refreshAttempts + 1);
+                        setTimeout(() => {
+                            if (!controller.signal.aborted && socket.readyState === socket.OPEN) {
+                                enqueueTask(request.taskId, request, task.config, 0);
+                                socket.send(JSON.stringify({ type: "agent_status", taskId: request.taskId, status: "working", message: `The source changed while the proposal was being prepared. Refreshing the review… (${refreshAttempts + 1}/${MAX_REFRESH_ATTEMPTS})` }));
+                            }
+                        }, 500 * (refreshAttempts + 1));
+                    }
+                    else {
+                        socket.send(JSON.stringify({ type: "agent_status", taskId: request.taskId, status: "error", message: "The source is still changing after multiple refresh attempts. Stop the dev-server edit or try the request again." }));
+                    }
+                    return;
+                }
+                socket.send(JSON.stringify({ type: "agent_status", taskId: request.taskId, status: "review", message: proposal.summary, changes: proposal.changes }));
+            })
+                .catch((error) => {
+                if (socket.readyState !== socket.OPEN)
+                    return;
+                if (controller.signal.aborted) {
+                    socket.send(JSON.stringify({ type: "agent_status", taskId: request.taskId, status: "stopped", message: "Agent stopped." }));
+                    return;
+                }
+                socket.send(JSON.stringify({ type: "agent_status", taskId: request.taskId, status: "error", message: error instanceof Error ? error.message : "The agent could not prepare a change." }));
+            })
+                .finally(() => {
+                if (taskControllers.get(request.taskId) === controller)
+                    taskControllers.delete(request.taskId);
+                runningTasks.delete(request.taskId);
+                taskPriority.delete(request.taskId);
+                processTaskQueue();
+            });
+        }
+        else if (task.message.type === "ask") {
+            const controller = new AbortController();
+            taskControllers.set(task.taskId, controller);
+            socket.send(JSON.stringify({ type: "agent_status", taskId: task.taskId, status: "working", message: "Working…" }));
+            void (0, agent_1.answerQuestion)(cwd, {
+                taskId: task.taskId,
+                question: task.message.question,
+                context: task.message.context,
+                element: task.message.element,
+                messages: task.message.messages,
+            }, task.config, controller.signal, (message, detail, level) => {
+                if (!controller.signal.aborted && socket.readyState === socket.OPEN) {
+                    socket.send(JSON.stringify({ type: "agent_status", taskId: task.taskId, status: level === "error" ? "error" : "working", message, detail }));
+                }
+            }, (prompt) => {
+                if (!controller.signal.aborted && socket.readyState === socket.OPEN) {
+                    socket.send(JSON.stringify({ type: "agent_prompt", taskId: task.taskId, prompt }));
+                }
+            }).then((answer) => {
+                if (!controller.signal.aborted)
+                    socket.send(JSON.stringify({ type: "assistant_message", taskId: task.taskId, message: answer }));
+            }).catch((error) => {
+                if (!controller.signal.aborted)
+                    socket.send(JSON.stringify({ type: "agent_status", taskId: task.taskId, status: "error", message: error instanceof Error ? error.message : "The agent could not answer." }));
+            }).finally(() => {
+                if (taskControllers.get(task.taskId) === controller)
+                    taskControllers.delete(task.taskId);
+                runningTasks.delete(task.taskId);
+                taskPriority.delete(task.taskId);
+                processTaskQueue();
+            });
+        }
+    }
+    function enqueueTask(taskId, message, config, priority = 0) {
+        taskPriority.set(taskId, priority);
+        taskQueue.push({ taskId, message, config });
+        processTaskQueue();
+    }
     // Fetch workspace configuration from server (dashboard-configured providers)
     let workspaceConfig = null;
     if (lassoKeyConfigured) {
@@ -539,6 +813,7 @@ async function startBridge(cwd = process.cwd(), collabConfig = null, bridgePort
     };
     wss.on("connection", (socket) => {
         overlaySocket = socket;
+        currentSocket = socket;
         console.log(chalk_1.default.green("✓") + " Overlay connected");
         const creds = (0, auth_1.loadCredentials)();
         const userInfo = creds?.userName
@@ -553,57 +828,6 @@ async function startBridge(cwd = process.cwd(), collabConfig = null, bridgePort
             if (socket.readyState === socket.OPEN)
                 socket.send(JSON.stringify({ type: "git_state", git }));
         });
-        const runEditReview = (request, config, statusMessage) => {
-            taskControllers.get(request.taskId)?.abort();
-            const controller = new AbortController();
-            taskControllers.set(request.taskId, controller);
-            if (socket.readyState === socket.OPEN) {
-                socket.send(JSON.stringify({ type: "agent_status", taskId: request.taskId, status: "working", message: statusMessage || "Working…" }));
-            }
-            void (0, agent_1.proposeChanges)(cwd, request, config, controller.signal, (message, detail, level) => {
-                if (!controller.signal.aborted && socket.readyState === socket.OPEN) {
-                    socket.send(JSON.stringify({ type: "agent_status", taskId: request.taskId, status: level === "error" ? "error" : "working", message, detail }));
-                }
-            }, (prompt) => {
-                if (!controller.signal.aborted && socket.readyState === socket.OPEN) {
-                    socket.send(JSON.stringify({ type: "agent_prompt", taskId: request.taskId, prompt }));
-                }
-            })
-                .then((proposal) => {
-                if (controller.signal.aborted || socket.readyState !== socket.OPEN)
-                    return;
-                if (!proposalMatchesCurrentSource(cwd, proposal.changes)) {
-                    const refreshAttempts = reviewRefreshAttempts.get(request.taskId) || 0;
-                    const MAX_REFRESH_ATTEMPTS = 3;
-                    if (refreshAttempts < MAX_REFRESH_ATTEMPTS) {
-                        reviewRefreshAttempts.set(request.taskId, refreshAttempts + 1);
-                        setTimeout(() => {
-                            if (!controller.signal.aborted && socket.readyState === socket.OPEN) {
-                                runEditReview(request, config, `The source changed while the proposal was being prepared. Refreshing the review… (${refreshAttempts + 1}/${MAX_REFRESH_ATTEMPTS})`);
-                            }
-                        }, 500 * (refreshAttempts + 1));
-                    }
-                    else {
-                        socket.send(JSON.stringify({ type: "agent_status", taskId: request.taskId, status: "error", message: "The source is still changing after multiple refresh attempts. Stop the dev-server edit or try the request again." }));
-                    }
-                    return;
-                }
-                socket.send(JSON.stringify({ type: "agent_status", taskId: request.taskId, status: "review", message: proposal.summary, changes: proposal.changes }));
-            })
-                .catch((error) => {
-                if (socket.readyState !== socket.OPEN)
-                    return;
-                if (controller.signal.aborted) {
-                    socket.send(JSON.stringify({ type: "agent_status", taskId: request.taskId, status: "stopped", message: "Agent stopped." }));
-                    return;
-                }
-                socket.send(JSON.stringify({ type: "agent_status", taskId: request.taskId, status: "error", message: error instanceof Error ? error.message : "The agent could not prepare a change." }));
-            })
-                .finally(() => {
-                if (taskControllers.get(request.taskId) === controller)
-                    taskControllers.delete(request.taskId);
-            });
-        };
         socket.on("message", async (raw) => {
             const msg = JSON.parse(raw.toString());
             if (msg.type === "edit" || msg.type === "ask") {
@@ -712,23 +936,8 @@ async function startBridge(cwd = process.cwd(), collabConfig = null, bridgePort
                         serverUrl: collabConfig?.serverUrl || (0, auth_1.serverUrlFrom)(fileEnv),
                     };
                 }
-                socket.send(JSON.stringify({ type: "agent_status", taskId: msg.taskId, status: "working", message: "Working…" }));
-                void (0, agent_1.answerQuestion)(cwd, { taskId: msg.taskId, question: msg.question, context: msg.context, element: msg.element, messages: msg.messages }, selectedConfig, controller.signal, (message, detail, level) => {
-                    if (!controller.signal.aborted && socket.readyState === socket.OPEN)
-                        socket.send(JSON.stringify({ type: "agent_status", taskId: msg.taskId, status: level === "error" ? "error" : "working", message, detail }));
-                }, (prompt) => {
-                    if (!controller.signal.aborted && socket.readyState === socket.OPEN)
-                        socket.send(JSON.stringify({ type: "agent_prompt", taskId: msg.taskId, prompt }));
-                }).then((answer) => {
-                    if (!controller.signal.aborted)
-                        socket.send(JSON.stringify({ type: "assistant_message", taskId: msg.taskId, message: answer }));
-                }).catch((error) => {
-                    if (!controller.signal.aborted)
-                        socket.send(JSON.stringify({ type: "agent_status", taskId: msg.taskId, status: "error", message: error instanceof Error ? error.message : "The agent could not answer." }));
-                }).finally(() => {
-                    if (taskControllers.get(msg.taskId) === controller)
-                        taskControllers.delete(msg.taskId);
-                });
+                // Enqueue task for concurrent execution
+                enqueueTask(msg.taskId, msg, selectedConfig, 1); // Priority 1 for ask tasks
             }
             else if (msg.type === "edit") {
                 const localProvider = msg.provider === "cli";
@@ -767,17 +976,29 @@ async function startBridge(cwd = process.cwd(), collabConfig = null, bridgePort
                 editRequests.set(msg.taskId, msg);
                 editConfigs.set(msg.taskId, selectedConfig);
                 reviewRefreshAttempts.set(msg.taskId, 0);
-                runEditReview(msg, selectedConfig);
+                // Enqueue task for concurrent execution with higher priority (0)
+                enqueueTask(msg.taskId, msg, selectedConfig, 0);
             }
             else if (msg.type === "agent_prompt_response") {
                 (0, agent_1.respondToAgentPrompt)(msg.taskId, msg.response);
             }
             else if (msg.type === "stop") {
-                if (msg.taskId)
+                if (msg.taskId) {
                     taskControllers.get(msg.taskId)?.abort();
-                else
+                    // Remove from queue and running tasks
+                    const queueIndex = taskQueue.findIndex(t => t.taskId === msg.taskId);
+                    if (queueIndex !== -1)
+                        taskQueue.splice(queueIndex, 1);
+                    runningTasks.delete(msg.taskId);
+                    taskPriority.delete(msg.taskId);
+                }
+                else {
                     for (const controller of taskControllers.values())
                         controller.abort();
+                    taskQueue.length = 0;
+                    runningTasks.clear();
+                    taskPriority.clear();
+                }
                 socket.send(JSON.stringify({ type: "agent_status", taskId: msg.taskId, status: "stopped", message: "Agent stopped." }));
             }
             else if (msg.type === "runtime_error") {
@@ -962,8 +1183,28 @@ async function startBridge(cwd = process.cwd(), collabConfig = null, bridgePort
             }
             else if (msg.type === "apply") {
                 try {
+                    // Create snapshot before applying changes
+                    const filePaths = [...new Set(msg.changes.map(c => c.filePath))];
+                    const parentSnapshot = (0, snapshot_1.getSnapshotByTaskId)(cwd, msg.taskId);
+                    // Create pre-apply snapshot
+                    const preSnapshot = (0, snapshot_1.createSnapshot)(cwd, msg.taskId, `Pre-apply: ${msg.changes.length} file${msg.changes.length === 1 ? "" : "s"}`, filePaths, parentSnapshot?.id);
                     const snapshots = [];
                     const planned = new Map();
+                    // Check for conflicts before applying
+                    const expectedFiles = msg.changes.map(change => ({
+                        filePath: change.filePath,
+                        content: change.oldString || null,
+                    }));
+                    const conflicts = (0, snapshot_1.detectConflicts)(cwd, expectedFiles);
+                    if (conflicts.length > 0) {
+                        socket.send(JSON.stringify({
+                            type: "conflict_detected",
+                            taskId: msg.taskId,
+                            conflicts,
+                            message: `Conflict detected in ${conflicts.length} file${conflicts.length === 1 ? "" : "s"}. The source has changed since the suggestion was generated.`
+                        }));
+                        return;
+                    }
                     for (const change of msg.changes) {
                         const isNew = !change.oldString;
                         const filePath = resolveProposedFile(cwd, change.filePath, true);
@@ -994,8 +1235,31 @@ async function startBridge(cwd = process.cwd(), collabConfig = null, bridgePort
                         node_fs_1.default.mkdirSync(node_path_1.default.dirname(filePath), { recursive: true });
                         node_fs_1.default.writeFileSync(filePath, nextContent);
                     }
+                    // Create post-apply snapshot
+                    (0, snapshot_1.createSnapshot)(cwd, msg.taskId, `Applied: ${msg.changes.length} file${msg.changes.length === 1 ? "" : "s"}`, filePaths, preSnapshot.id);
                     // Run build validation after applying changes
                     const validation = await validateBuild(cwd);
+                    if (!validation.passed) {
+                        // Build failed - automatically trigger retry with build error context
+                        const errorContext = validation.errors.slice(0, 10).join("\n");
+                        socket.send(JSON.stringify({
+                            type: "agent_status",
+                            taskId: msg.taskId,
+                            status: "working",
+                            message: `⚠️ Build validation failed. Attempting to fix build errors automatically...`,
+                            detail: `Build command: ${validation.command}\nErrors:\n${errorContext}${validation.errors.length > 10 ? `\n... and ${validation.errors.length - 10} more errors` : ""}`
+                        }));
+                        // Store context for retry
+                        buildErrorContext.set(msg.taskId, {
+                            errors: validation.errors,
+                            command: validation.command,
+                            originalChanges: msg.changes,
+                            retryCount: 0
+                        });
+                        // Trigger automatic build fix
+                        await triggerBuildFix(cwd, msg.taskId, validation.errors, validation.command, msg.changes, resolvedLassoKey, agentConfig, collabConfig, socket, taskControllers, taskSnapshots, buildErrorContext);
+                        return;
+                    }
                     socket.send(JSON.stringify({
                         type: "applied",
                         taskId: msg.taskId,
@@ -1023,7 +1287,8 @@ async function startBridge(cwd = process.cwd(), collabConfig = null, bridgePort
                     const refreshAttempts = reviewRefreshAttempts.get(msg.taskId) || 0;
                     if (sourceChanged && editRequest && editConfig && refreshAttempts < 1) {
                         reviewRefreshAttempts.set(msg.taskId, refreshAttempts + 1);
-                        runEditReview(editRequest, editConfig, "The source changed. Refreshing the review against the current file…");
+                        enqueueTask(msg.taskId, editRequest, editConfig, 0);
+                        socket.send(JSON.stringify({ type: "agent_status", taskId: msg.taskId, status: "working", message: "The source changed. Refreshing the review against the current file…" }));
                     }
                     else {
                         socket.send(JSON.stringify({ type: "agent_status", taskId: msg.taskId, status: "error", message }));
@@ -1044,9 +1309,117 @@ async function startBridge(cwd = process.cwd(), collabConfig = null, bridgePort
                 taskSnapshots.delete(msg.taskId || "");
                 socket.send(JSON.stringify({ type: "undone", taskId: msg.taskId, message: snapshots.length ? "The accepted change was reverted." : "There is no accepted change to undo." }));
             }
+            else if (msg.type === "resolve_conflict") {
+                const { taskId, action, conflicts } = msg;
+                if (action === "retry") {
+                    // Re-run the edit request with current file content
+                    const editRequest = editRequests.get(taskId);
+                    const editConfig = editConfigs.get(taskId);
+                    if (editRequest && editConfig) {
+                        reviewRefreshAttempts.set(taskId, 0);
+                        enqueueTask(taskId, editRequest, editConfig, 0);
+                        socket.send(JSON.stringify({ type: "agent_status", taskId, status: "working", message: "Retrying with current file content..." }));
+                    }
+                    else {
+                        socket.send(JSON.stringify({ type: "agent_status", taskId, status: "error", message: "Could not retry: original request not found." }));
+                    }
+                }
+                else if (action === "force") {
+                    // Force apply despite conflicts (user's choice)
+                    try {
+                        const snapshots = [];
+                        const planned = new Map();
+                        // Get the original changes from the edit request
+                        const editRequest = editRequests.get(taskId);
+                        if (!editRequest) {
+                            socket.send(JSON.stringify({ type: "agent_status", taskId, status: "error", message: "Could not force apply: original request not found." }));
+                            return;
+                        }
+                        // Re-prepare changes with current content (may fail, but that's expected)
+                        for (const change of editRequest.changesHistory?.[editRequest.changesHistory.length - 1]?.changes || []) {
+                            const isNew = !change.oldString;
+                            const filePath = resolveProposedFile(cwd, change.filePath, true);
+                            const exists = node_fs_1.default.existsSync(filePath);
+                            const content = exists ? node_fs_1.default.readFileSync(filePath, "utf8") : "";
+                            const prepared = (!exists || isNew)
+                                ? { start: 0, end: content.length, oldString: content, newString: change.newString }
+                                : prepareChange(content, change);
+                            const fileChanges = planned.get(filePath) || [];
+                            if (fileChanges.some((item) => prepared.start < item.end && item.start < prepared.end)) {
+                                throw new Error(`Could not safely apply ${change.filePath}. Proposed changes overlap.`);
+                            }
+                            fileChanges.push({ filePath, content, exists, ...prepared });
+                            planned.set(filePath, fileChanges);
+                        }
+                        taskSnapshots.set(taskId, snapshots);
+                        for (const [filePath, changes] of planned) {
+                            const exists = changes[0].exists;
+                            const content = changes[0].content;
+                            snapshots.push({ filePath, content: exists ? content : null });
+                            const nextContent = exists
+                                ? [...changes]
+                                    .sort((a, b) => b.start - a.start)
+                                    .reduce((value, change) => value.slice(0, change.start) + change.newString + value.slice(change.end), content)
+                                : changes[0].newString;
+                            node_fs_1.default.mkdirSync(node_path_1.default.dirname(filePath), { recursive: true });
+                            node_fs_1.default.writeFileSync(filePath, nextContent);
+                        }
+                        socket.send(JSON.stringify({
+                            type: "applied",
+                            taskId,
+                            message: "Changes force-applied despite conflicts."
+                        }));
+                    }
+                    catch (error) {
+                        for (const snapshot of taskSnapshots.get(taskId) || []) {
+                            if (snapshot.content === null) {
+                                if (node_fs_1.default.existsSync(snapshot.filePath))
+                                    node_fs_1.default.unlinkSync(snapshot.filePath);
+                            }
+                            else {
+                                node_fs_1.default.writeFileSync(snapshot.filePath, snapshot.content);
+                            }
+                        }
+                        taskSnapshots.delete(taskId);
+                        socket.send(JSON.stringify({ type: "agent_status", taskId, status: "error", message: error instanceof Error ? error.message : "Force apply failed." }));
+                    }
+                }
+                else if (action === "rebase") {
+                    // User wants to rebase - re-run the edit with updated context
+                    const editRequest = editRequests.get(taskId);
+                    const editConfig = editConfigs.get(taskId);
+                    if (editRequest && editConfig) {
+                        reviewRefreshAttempts.set(taskId, 0);
+                        enqueueTask(taskId, editRequest, editConfig, 0);
+                        socket.send(JSON.stringify({ type: "agent_status", taskId, status: "working", message: "Rebasing changes against current file content..." }));
+                    }
+                    else {
+                        socket.send(JSON.stringify({ type: "agent_status", taskId, status: "error", message: "Could not rebase: original request not found." }));
+                    }
+                }
+            }
+            else if (msg.type === "restore_snapshot") {
+                const success = (0, snapshot_1.restoreSnapshot)(cwd, msg.snapshotId);
+                socket.send(JSON.stringify({
+                    type: "agent_status",
+                    message: success ? "Snapshot restored successfully." : "Failed to restore snapshot."
+                }));
+            }
+            else if (msg.type === "get_timeline") {
+                const timeline = (0, snapshot_1.getTimeline)(cwd);
+                socket.send(JSON.stringify({ type: "timeline", snapshots: timeline }));
+            }
+            else if (msg.type === "delete_snapshot") {
+                const success = (0, snapshot_1.deleteSnapshot)(cwd, msg.snapshotId);
+                socket.send(JSON.stringify({
+                    type: "agent_status",
+                    message: success ? "Snapshot deleted." : "Failed to delete snapshot."
+                }));
+            }
         });
         socket.on("close", () => {
             overlaySocket = null;
+            currentSocket = null;
             console.log(chalk_1.default.yellow("!") + " Overlay disconnected");
         });
     });
@@ -1063,8 +1436,9 @@ async function startBridge(cwd = process.cwd(), collabConfig = null, bridgePort
     });
     bridgeServer.listen(bridgePort, "127.0.0.1");
     function send(msg) {
-        if (overlaySocket?.readyState === overlaySocket?.OPEN) {
-            overlaySocket.send(JSON.stringify(msg));
+        const socket = currentSocket;
+        if (socket && socket.readyState === socket.OPEN) {
+            socket.send(JSON.stringify(msg));
         }
     }
     return {