@lasso-ai/cli 1.4.5 → 1.5.0

package/dist/cli/bridge.js

@@ -14,10 +14,10 @@ const node_path_1 = __importDefault(require("node:path"));
 const node_child_process_1 = require("node:child_process");
 const node_util_1 = require("node:util");
 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");
+const runtime_client_1 = require("./runtime-client");
 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) {
@@ -48,361 +48,7 @@ async function getGitState(cwd) {
     const remote = await gitCommand(cwd, ["remote", "get-url", "origin"]).catch(() => "");
     return { isRepo: true, branch, status, hasChanges: status.length > 0, hasRemote: Boolean(remote), remote };
 }
-function fileLineEnding(content) {
-    return content.includes("\r\n") ? "\r\n" : "\n";
-}
-function withLineEnding(value, lineEnding) {
-    return value.replace(/\r\n?|\n/g, lineEnding);
-}
-function resolveProposedFile(cwd, proposedPath, allowNew = false) {
-    const root = node_path_1.default.resolve(cwd);
-    const candidate = node_path_1.default.resolve(root, proposedPath);
-    if (candidate.startsWith(`${root}${node_path_1.default.sep}`) && node_fs_1.default.existsSync(candidate))
-        return candidate;
-    // Some React/Next source maps contain an absolute path from an older
-    // checkout. Rebase only the recognizable src/... suffix into this project.
-    const normalized = proposedPath.replace(/\\/g, "/");
-    const srcIndex = normalized.lastIndexOf("/src/");
-    if (srcIndex >= 0) {
-        const rebased = node_path_1.default.join(root, normalized.slice(srcIndex + 1));
-        if (rebased.startsWith(`${root}${node_path_1.default.sep}`) && node_fs_1.default.existsSync(rebased))
-            return rebased;
-        if (allowNew && (rebased.startsWith(`${root}${node_path_1.default.sep}`) || rebased === root))
-            return rebased;
-    }
-    if (candidate.startsWith(`${root}${node_path_1.default.sep}`) || candidate === root) {
-        if (allowNew)
-            return candidate;
-        throw new Error(`Could not find the proposed file in the current project: ${proposedPath}`);
-    }
-    throw new Error(`The proposed file is outside the current project: ${proposedPath}`);
-}
-function occurrenceCount(content, needle) {
-    if (!needle)
-        return 0;
-    let count = 0;
-    let from = 0;
-    while (true) {
-        const index = content.indexOf(needle, from);
-        if (index < 0)
-            return count;
-        count += 1;
-        from = index + needle.length;
-    }
-}
-function escapeRegExp(value) {
-    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function whitespaceEquivalentRange(content, oldString) {
-    const trimmed = oldString.trim();
-    if (!trimmed)
-        return null;
-    const pattern = trimmed.split(/\s+/).map(escapeRegExp).join("\\s+");
-    const matches = Array.from(content.matchAll(new RegExp(pattern, "g")));
-    if (matches.length !== 1 || matches[0].index === undefined)
-        return null;
-    const start = matches[0].index;
-    return { start, end: start + matches[0][0].length };
-}
-function prepareChange(content, change) {
-    const lineEnding = fileLineEnding(content);
-    const oldString = withLineEnding(change.oldString, lineEnding);
-    const newString = withLineEnding(change.newString, lineEnding);
-    const matches = occurrenceCount(content, oldString);
-    if (matches === 0) {
-        const range = whitespaceEquivalentRange(content, oldString);
-        if (range)
-            return { ...range, oldString: content.slice(range.start, range.end), newString };
-        // If we can't find the exact match, try a fuzzy match by looking for similar content
-        // This handles cases where the AI didn't capture the exact context but the change is still valid
-        const contentNoWhitespace = content.replace(/\s+/g, " ");
-        const oldStringNoWhitespace = oldString.replace(/\s+/g, " ");
-        if (contentNoWhitespace.includes(oldStringNoWhitespace) && oldStringNoWhitespace.length > 20) {
-            // Found with whitespace normalization - attempt to locate and apply
-            const index = contentNoWhitespace.indexOf(oldStringNoWhitespace);
-            console.warn(`[Lasso] Applying change with fuzzy match for ${change.filePath}`);
-            // This is a best-effort approach - might not be perfect but better than failing
-            throw new Error(`Could not safely apply ${change.filePath}. The source changed after the suggestion was generated. Regenerate the review so it uses the current source.`);
-        }
-        throw new Error(`Could not safely apply ${change.filePath}. The source changed after the suggestion was generated. Regenerate the review so it uses the current source.`);
-    }
-    if (matches > 1) {
-        throw new Error(`Could not safely apply ${change.filePath}. The selected code is not unique (${matches} matches).`);
-    }
-    const start = content.indexOf(oldString);
-    return { start, end: start + oldString.length, oldString, newString };
-}
-function proposalMatchesCurrentSource(cwd, changes) {
-    try {
-        for (const change of changes) {
-            if (!change.oldString)
-                continue;
-            const filePath = resolveProposedFile(cwd, change.filePath);
-            const content = node_fs_1.default.readFileSync(filePath, "utf8");
-            // Try exact match first
-            try {
-                prepareChange(content, change);
-            }
-            catch {
-                // If exact match fails, try with normalized whitespace
-                const normalizedContent = content.replace(/\s+/g, " ").trim();
-                const normalizedOldString = change.oldString.replace(/\s+/g, " ").trim();
-                const normalizedNewString = change.newString.replace(/\s+/g, " ").trim();
-                if (!normalizedContent.includes(normalizedOldString)) {
-                    throw new Error("Source content does not match proposed change (even with normalized whitespace)");
-                }
-            }
-        }
-        return true;
-    }
-    catch {
-        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)) {
-        return { passed: true, errors: [], command: "none" };
-    }
-    const pkg = JSON.parse(node_fs_1.default.readFileSync(pkgPath, "utf8"));
-    const scripts = pkg.scripts || {};
-    // Determine which build command to run
-    let buildCommand = "";
-    if (scripts.build) {
-        buildCommand = "build";
-    }
-    else if (scripts["build:cli"] || scripts["build:overlay"]) {
-        // Monorepo with separate build scripts
-        buildCommand = scripts["build:cli"] ? "build:cli" : "build:overlay";
-    }
-    else if (scripts.compile) {
-        buildCommand = "compile";
-    }
-    else if (scripts.check) {
-        buildCommand = "check";
-    }
-    else if (scripts.lint) {
-        buildCommand = "lint";
-    }
-    else if (scripts.typecheck) {
-        buildCommand = "typecheck";
-    }
-    else if (node_fs_1.default.existsSync(node_path_1.default.join(cwd, "tsconfig.json"))) {
-        buildCommand = "tsc"; // Run TypeScript compiler directly
-    }
-    else {
-        // No suitable build command found
-        return { passed: true, errors: [], command: "none" };
-    }
-    try {
-        const result = await execFileAsync(buildCommand === "tsc" ? "tsc" : "npm", buildCommand === "tsc" ? [] : ["run", buildCommand], { cwd, maxBuffer: 1024 * 1024 * 10, timeout: 60000 });
-        const output = result.stdout + result.stderr;
-        const errors = [];
-        // Parse TypeScript errors
-        if (output.includes("error TS")) {
-            const tsErrors = output.match(/error TS\d+.*$/gm) || [];
-            errors.push(...tsErrors);
-        }
-        // Parse general build errors
-        if (output.includes("Error:") || output.includes("error:")) {
-            const lines = output.split("\n");
-            for (const line of lines) {
-                if (line.includes("Error:") || line.includes("error:")) {
-                    errors.push(line.trim());
-                }
-            }
-        }
-        return {
-            passed: errors.length === 0,
-            errors,
-            command: buildCommand === "tsc" ? "tsc" : `npm run ${buildCommand}`
-        };
-    }
-    catch (error) {
-        const stderr = error.stderr || "";
-        const errors = [];
-        if (stderr.includes("error TS")) {
-            const tsErrors = stderr.match(/error TS\d+.*$/gm) || [];
-            errors.push(...tsErrors);
-        }
-        if (stderr.includes("Error:") || stderr.includes("error:")) {
-            const lines = stderr.split("\n");
-            for (const line of lines) {
-                if (line.includes("Error:") || line.includes("error:")) {
-                    errors.push(line.trim());
-                }
-            }
-        }
-        // If no specific errors found, include the full stderr
-        if (errors.length === 0 && stderr) {
-            errors.push(stderr);
-        }
-        return {
-            passed: false,
-            errors,
-            command: buildCommand === "tsc" ? "tsc" : `npm run ${buildCommand}`
-        };
-    }
-}
-function readEnvFile(cwd, filename) {
+function readEnvFile(filename, cwd) {
     try {
         return node_fs_1.default.readFileSync(node_path_1.default.join(cwd, filename), "utf8").split(/\r?\n/).reduce((values, line) => {
             const match = line.match(/^\s*(?:export\s+)?([A-Z0-9_]+)\s*=\s*(.*)\s*$/);
@@ -419,15 +65,60 @@ function readEnvFile(cwd, filename) {
         return {};
     }
 }
+function detectProjectFramework(cwd) {
+    try {
+        const pkg = JSON.parse(node_fs_1.default.readFileSync(node_path_1.default.join(cwd, "package.json"), "utf8"));
+        if (pkg.dependencies?.next || pkg.devDependencies?.next)
+            return "next";
+        if (pkg.dependencies?.react || pkg.devDependencies?.react)
+            return "react";
+        if (pkg.dependencies?.vue || pkg.devDependencies?.vue)
+            return "vue";
+        if (pkg.dependencies?.svelte || pkg.devDependencies?.svelte)
+            return "svelte";
+        if (pkg.dependencies?.solid || pkg.devDependencies?.solid)
+            return "solid";
+    }
+    catch { }
+    return "unknown";
+}
+// Helper to extract SourceChange from runtime session
+function extractChangesFromSession(session) {
+    if (!session)
+        return [];
+    const changes = [];
+    for (const action of session.actions || []) {
+        if (action.type === "edit_file" && action.data) {
+            changes.push({
+                filePath: action.data.filePath,
+                oldString: action.data.oldString,
+                newString: action.data.newString,
+            });
+        }
+        else if (action.type === "create_file" && action.data) {
+            changes.push({
+                filePath: action.data.filePath,
+                oldString: "",
+                newString: action.data.content || "",
+            });
+        }
+        else if (action.type === "delete_file" && action.data) {
+            changes.push({
+                filePath: action.data.filePath,
+                oldString: "(deleted)",
+                newString: "",
+            });
+        }
+    }
+    return changes;
+}
 async function startBridge(cwd = process.cwd(), collabConfig = null, bridgePort = exports.DEFAULT_BRIDGE_PORT) {
-    const bridgeServer = node_http_1.default.createServer(); // dedicated, empty HTTP server
+    const bridgeServer = node_http_1.default.createServer();
     const wss = new ws_1.WebSocketServer({ server: bridgeServer });
     let overlaySocket = null;
     const taskSnapshots = new Map();
-    const editRequests = new Map();
-    const editConfigs = new Map();
-    const reviewRefreshAttempts = new Map();
-    const buildErrorContext = new Map();
+    const activeSessions = new Map();
+    const taskControllers = 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,
@@ -435,7 +126,6 @@ async function startBridge(cwd = process.cwd(), collabConfig = null, bridgePort
         ...readEnvFile(root, ".env.local"),
         ...readEnvFile(root, ".env.production"),
     }), {});
-    // Prioritize CLI auth credentials over env vars
     const cliCredentials = (0, auth_1.loadCredentials)();
     const resolvedLassoKey = cliCredentials?.apiKey ||
         (0, project_1.resolveLassoApiKey)(fileEnv) ||
@@ -447,164 +137,41 @@ 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) {
-        workspaceConfig = await (0, project_1.resolveWorkspaceConfig)(fileEnv);
-    }
-    // Fetch available models from server
-    let dynamicModels = { anthropic: [], openai: [], google: [], nvidia: [] };
+    const serverUrl = (0, auth_1.serverUrlFrom)(fileEnv) || "https://api.lasso.byorello.space";
+    const runtimeClient = new runtime_client_1.RuntimeClient(serverUrl, resolvedLassoKey || undefined);
+    // Load project info
+    const workspaceConfig = await (0, project_1.resolveWorkspaceConfig)(fileEnv);
+    const projectId = workspaceConfig?.workspaceId || "";
+    const framework = detectProjectFramework(cwd);
+    // Fetch models
+    let models = [];
     try {
-        dynamicModels = await (0, project_1.fetchModels)(fileEnv);
+        const modelsResponse = await (0, project_1.fetchModels)(fileEnv);
+        const allModels = [
+            ...(modelsResponse.anthropic || []),
+            ...(modelsResponse.openai || []),
+            ...(modelsResponse.google || []),
+            ...(modelsResponse.nvidia || []),
+        ];
+        models = allModels.map((m) => ({
+            id: m.id,
+            label: m.name || m.id,
+            provider: m.provider,
+            locked: false,
+        }));
     }
-    catch (error) {
-        console.warn('[Lasso] Failed to fetch dynamic models, using fallback');
+    catch {
+        models = [
+            { id: "claude-3-5-sonnet-20241022", label: "Claude 3.5 Sonnet", provider: "anthropic", locked: false },
+            { id: "gpt-4o", label: "GPT-4o", provider: "openai", locked: false },
+            { id: "gemini-2.5-flash", label: "Gemini 2.5 Flash", provider: "google", locked: false },
+        ];
     }
-    const localProviderKeys = {
-        google: process.env.GOOGLE_GENERATIVE_AI_API_KEY || fileEnv.GOOGLE_GENERATIVE_AI_API_KEY || process.env.GEMINI_API_KEY || fileEnv.GEMINI_API_KEY,
-        openai: process.env.OPENAI_API_KEY || fileEnv.OPENAI_API_KEY,
-        anthropic: process.env.ANTHROPIC_API_KEY || fileEnv.ANTHROPIC_API_KEY,
-        nvidia: process.env.NVIDIA_API_KEY || fileEnv.NVIDIA_API_KEY,
-        ollama: process.env.OLLAMA_BASE_URL || fileEnv.OLLAMA_BASE_URL || process.env.OLLAMA_MODEL || fileEnv.OLLAMA_MODEL ? "ollama" : undefined,
-    };
-    let agentConfig = (() => {
-        const provider = (process.env.LASSO_AGENT_PROVIDER || fileEnv.LASSO_AGENT_PROVIDER || process.env.AI_PROVIDER || fileEnv.AI_PROVIDER || "").toLowerCase();
-        const selectedProvider = provider === "google" || provider === "gemini" ? "google" : provider === "openai" ? "openai" : provider === "ollama" ? "ollama" : provider === "anthropic" ? "anthropic" : provider === "nvidia" ? "nvidia" : localProviderKeys.ollama ? "ollama" : localProviderKeys.nvidia ? "nvidia" : localProviderKeys.google ? "google" : localProviderKeys.openai ? "openai" : localProviderKeys.anthropic ? "anthropic" : (cliCredentials ? "anthropic" : "google");
-        const apiKey = selectedProvider === "ollama" ? "ollama" : localProviderKeys[selectedProvider];
-        // If user has CLI auth, use Lasso gateway by default
-        if (!apiKey && !lassoKeyConfigured)
-            return null;
-        return {
-            provider: selectedProvider,
-            apiKey: apiKey || resolvedLassoKey,
-            model: process.env.LASSO_AGENT_MODEL || fileEnv.LASSO_AGENT_MODEL || process.env.AI_MODEL || fileEnv.AI_MODEL,
-            baseUrl: selectedProvider === "nvidia" ? "https://integrate.api.nvidia.com/v1" : process.env.OLLAMA_BASE_URL || fileEnv.OLLAMA_BASE_URL ? `${(process.env.OLLAMA_BASE_URL || fileEnv.OLLAMA_BASE_URL || "http://localhost:11434/api").replace(/\/api\/?$/, "")}/v1` : undefined,
-        };
-    })();
-    let activeAgentController = null;
-    const taskControllers = new Map();
-    let localAgents = new Set();
     const pageIgnoredDirs = new Set(["node_modules", ".git", ".next", "dist", "build", ".turbo", "out", "coverage", ".vercel", ".cache"]);
     const resolveInsideProject = (root, relative) => {
         const target = node_path_1.default.resolve(root, relative && relative !== "." ? relative : "");
         return target === root || target.startsWith(`${root}${node_path_1.default.sep}`) ? target : null;
     };
-    // Directories are returned first so the overlay can render an explorer-style
-    // tree that mirrors how VS Code orders folders above files.
     const pageEntries = (root, relative) => {
         const directory = resolveInsideProject(root, relative);
         if (!directory)
@@ -621,730 +188,607 @@ async function startBridge(cwd = process.cwd(), collabConfig = null, bridgePort
                 });
             }
         }
-        catch {
-            // Folders that cannot be read are treated as empty.
-        }
+        catch { }
         return entries.sort((a, b) => a.type === b.type ? a.name.localeCompare(b.name) : a.type === "directory" ? -1 : 1);
     };
     bridgeServer.on("request", (req, res) => {
         if (req.method !== "POST" || req.url?.split("?", 1)[0] !== "/__lasso/bridge/restart")
             return;
-        activeAgentController?.abort();
         for (const controller of taskControllers.values())
             controller.abort();
         taskControllers.clear();
-        activeAgentController = null;
         for (const socket of wss.clients)
             socket.close(1000, "Bridge restarted by the CLI");
         res.writeHead(200, { "content-type": "application/json" });
         res.end(JSON.stringify({ ok: true }));
     });
-    async function localModels() {
-        const base = process.env.OLLAMA_BASE_URL || fileEnv.OLLAMA_BASE_URL || "http://localhost:11434/api";
+    // Handler for edit/ask - uses runtime
+    async function handleEditOrAsk(message, socket, taskId, instruction, model, provider, context, element, messages) {
+        taskControllers.get(taskId)?.abort();
+        const controller = new AbortController();
+        taskControllers.set(taskId, controller);
+        socket.send(JSON.stringify({
+            type: "agent_status",
+            taskId,
+            status: "thinking",
+            message: "Starting...",
+        }));
         try {
-            const response = await fetch(`${base.replace(/\/$/, "")}/tags`);
-            if (!response.ok)
-                return [];
-            const payload = await response.json();
-            return (payload.models || []).filter((model) => model.name).map((model) => ({ id: model.name, label: `${model.name} · Local`, provider: "ollama" }));
+            const sessionInput = {
+                userPrompt: instruction,
+                project: {
+                    projectId,
+                    framework,
+                    hasTypeScript: node_fs_1.default.existsSync(node_path_1.default.join(cwd, "tsconfig.json")),
+                    hasReact: node_fs_1.default.existsSync(node_path_1.default.join(cwd, "package.json")) &&
+                        node_fs_1.default.readFileSync(node_path_1.default.join(cwd, "package.json"), "utf8").includes("react"),
+                },
+                model: {
+                    provider: (provider || "anthropic"),
+                    id: model || "claude-3-5-sonnet-20241022",
+                },
+                selection: context ? {
+                    element: element ? {
+                        tag: element.tag,
+                        text: element.label,
+                        source: element.sourceHint,
+                        attributes: context.attributes,
+                    } : undefined,
+                    viewport: context?.viewport,
+                    route: context?.position?.route,
+                    screenshot: context?.screenshots?.full,
+                } : undefined,
+            };
+            const session = await runtimeClient.createSession(sessionInput);
+            activeSessions.set(taskId, session);
+            // Create snapshot before changes
+            taskSnapshots.set(taskId, []);
+            // Note: Snapshot will be created after changes are extracted from session
+            await runtimeClient.runSession(session.id, cwd, (event) => {
+                if (controller.signal.aborted)
+                    return;
+                switch (event.type) {
+                    case "agent_started":
+                    case "agent_reasoning":
+                        socket.send(JSON.stringify({
+                            type: "agent_status",
+                            taskId,
+                            status: "thinking",
+                            message: event.data.summary || "Working...",
+                        }));
+                        break;
+                    case "tool_started":
+                        socket.send(JSON.stringify({
+                            type: "agent_status",
+                            taskId,
+                            status: "working",
+                            message: `Running ${event.data.tool || "tool"}...`,
+                        }));
+                        break;
+                    case "tool_completed":
+                        socket.send(JSON.stringify({
+                            type: "agent_status",
+                            taskId,
+                            status: "working",
+                            message: "Completed tool",
+                        }));
+                        break;
+                    case "phase_changed":
+                        const phase = event.data.phase;
+                        socket.send(JSON.stringify({
+                            type: "agent_status",
+                            taskId,
+                            status: "working",
+                            message: `Phase: ${phase}`,
+                        }));
+                        break;
+                    case "verification_started":
+                        socket.send(JSON.stringify({
+                            type: "agent_status",
+                            taskId,
+                            status: "review",
+                            message: "Verifying changes...",
+                        }));
+                        break;
+                    case "verification_completed":
+                        const passed = event.data.passed;
+                        socket.send(JSON.stringify({
+                            type: "agent_status",
+                            taskId,
+                            status: passed ? "working" : "error",
+                            message: passed ? "Verification passed" : "Verification failed",
+                        }));
+                        break;
+                    case "agent_completed":
+                        runtimeClient.getSession(session.id).then((finalSession) => {
+                            const changes = extractChangesFromSession(finalSession);
+                            // Create snapshot with affected files
+                            const filePaths = changes.map(c => c.filePath);
+                            if (filePaths.length > 0) {
+                                (0, snapshot_1.createSnapshot)(cwd, taskId, `Runtime session: ${instruction}`, filePaths, undefined, session.id);
+                            }
+                            socket.send(JSON.stringify({
+                                type: "agent_status",
+                                taskId,
+                                status: "review",
+                                message: "Review changes",
+                                changes,
+                            }));
+                        });
+                        break;
+                    case "error":
+                        socket.send(JSON.stringify({
+                            type: "agent_status",
+                            taskId,
+                            status: "error",
+                            message: event.data.error || "Unknown error",
+                        }));
+                        break;
+                    case "waiting_for_user":
+                        socket.send(JSON.stringify({
+                            type: "agent_prompt",
+                            taskId,
+                            prompt: {
+                                message: event.data?.question || "Input required",
+                                kind: "input",
+                            },
+                        }));
+                        break;
+                }
+            }, controller.signal);
         }
-        catch {
-            return [];
+        catch (error) {
+            socket.send(JSON.stringify({
+                type: "agent_status",
+                taskId,
+                status: "error",
+                message: error instanceof Error ? error.message : "Unknown error",
+            }));
         }
     }
-    async function openCodeModels() {
-        if (!localAgents.has("opencode"))
-            return [];
-        try {
-            const result = await execFileAsync("opencode", ["models"], { maxBuffer: 1024 * 1024 });
-            return result.stdout
-                .split(/\r?\n/)
-                .map((line) => line.trim())
-                .filter((line) => /^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.:@/-]+$/.test(line))
-                .map((model) => ({ id: `opencode:${model}`, label: `OpenCode · ${model}`, provider: "cli" }));
+    // Handler for apply - applies pending changes
+    async function handleApply(message, socket, cwd) {
+        const { taskId, changes } = message;
+        const session = activeSessions.get(taskId);
+        const snapshot = taskSnapshots.get(taskId) || [];
+        // Create snapshot before applying changes
+        const filePaths = changes.map((c) => c.filePath);
+        if (filePaths.length > 0) {
+            (0, snapshot_1.createSnapshot)(cwd, taskId, `Apply changes for task ${taskId}`, filePaths, undefined, session?.id);
         }
-        catch {
-            return [];
+        for (const change of changes) {
+            const filePath = node_path_1.default.join(cwd, change.filePath);
+            const dir = node_path_1.default.dirname(filePath);
+            try {
+                if (!node_fs_1.default.existsSync(dir)) {
+                    node_fs_1.default.mkdirSync(dir, { recursive: true });
+                }
+                if (change.oldString === "" && change.newString === "") {
+                    // Delete file
+                    if (node_fs_1.default.existsSync(filePath)) {
+                        node_fs_1.default.unlinkSync(filePath);
+                    }
+                }
+                else if (change.oldString === "") {
+                    // Create file
+                    node_fs_1.default.writeFileSync(filePath, change.newString);
+                }
+                else {
+                    // Edit file
+                    const content = node_fs_1.default.readFileSync(filePath, "utf8");
+                    const newContent = content.replace(change.oldString, change.newString);
+                    node_fs_1.default.writeFileSync(filePath, newContent);
+                }
+            }
+            catch (error) {
+                socket.send(JSON.stringify({
+                    type: "agent_status",
+                    taskId,
+                    status: "error",
+                    message: `Failed to apply ${change.filePath}: ${error instanceof Error ? error.message : "Unknown error"}`,
+                }));
+                return;
+            }
         }
+        socket.send(JSON.stringify({
+            type: "applied",
+            taskId,
+            message: "Changes applied successfully",
+        }));
     }
-    async function cursorModels() {
-        if (!localAgents.has("cursor"))
-            return [];
-        try {
-            const result = await execFileAsync("cursor", ["model", "list"], { maxBuffer: 1024 * 1024 });
-            return result.stdout
-                .split(/\r?\n/)
-                .map((line) => line.trim())
-                .filter((line) => line && !line.startsWith("Available models"))
-                .map((line) => {
-                const parts = line.split(/\s+/);
-                const id = parts[0]?.trim();
-                const name = parts.slice(1).join(" ").trim();
-                return id ? { id: `cursor:${id}`, label: `Cursor · ${name}`, provider: "cli" } : null;
-            })
-                .filter((model) => model !== null);
+    // Handler for undo - restores snapshot
+    async function handleUndo(message, socket, cwd) {
+        const { taskId } = message;
+        const snapshot = taskSnapshots.get(taskId) || [];
+        for (const item of snapshot) {
+            if (item.content === null) {
+                // File didn't exist, delete if it was created
+                try {
+                    node_fs_1.default.unlinkSync(node_path_1.default.join(cwd, item.filePath));
+                }
+                catch { }
+            }
+            else {
+                // Restore original content
+                node_fs_1.default.writeFileSync(node_path_1.default.join(cwd, item.filePath), item.content);
+            }
         }
-        catch {
-            return [];
+        socket.send(JSON.stringify({
+            type: "undone",
+            taskId,
+            message: "Changes undone",
+        }));
+    }
+    // Handler for stop
+    async function handleStop(message, socket) {
+        const { taskId } = message;
+        if (taskId) {
+            taskControllers.get(taskId)?.abort();
+            activeSessions.delete(taskId);
         }
+        else {
+            for (const controller of taskControllers.values())
+                controller.abort();
+            taskControllers.clear();
+            activeSessions.clear();
+        }
+        socket.send(JSON.stringify({
+            type: "agent_status",
+            taskId,
+            status: "stopped",
+            message: "Agent stopped",
+        }));
     }
-    const availableModels = async (collabConfig = null, workspaceConfig = null) => {
-        localAgents = await (0, agent_1.detectLocalAgents)();
-        const locals = await localModels();
-        const discoveredOpenCodeModels = await openCodeModels();
-        const discoveredCursorModels = await cursorModels();
-        if (locals.length && !agentConfig) {
-            const base = process.env.OLLAMA_BASE_URL || fileEnv.OLLAMA_BASE_URL || "http://localhost:11434/api";
-            agentConfig = { provider: "ollama", apiKey: "ollama", model: process.env.OLLAMA_MODEL || fileEnv.OLLAMA_MODEL, baseUrl: `${base.replace(/\/api\/?$/, "")}/v1` };
+    // Handler for switch_model
+    async function handleSwitchModel(message, socket) {
+        const { taskId, provider, modelId } = message;
+        const session = activeSessions.get(taskId);
+        if (!session) {
+            socket.send(JSON.stringify({
+                type: "agent_status",
+                taskId,
+                status: "error",
+                message: "No active session for this task",
+            }));
+            return;
         }
-        // Check if user has CLI auth credentials (lasso auth login)
-        const cliCredentials = (0, auth_1.loadCredentials)();
-        const hasCliAuth = Boolean(cliCredentials?.apiKey);
-        // Prioritize workspace config (dashboard) over project config
-        // Workspace config is fetched independently of project config
-        const workspacePlan = (workspaceConfig?.plan || "free").toLowerCase();
-        const workspaceProviders = workspaceConfig?.configuredProviders || [];
-        const projectPlan = (collabConfig?.plan || "free").toLowerCase();
-        const projectProviders = collabConfig?.configuredProviders || [];
-        // Use the highest-tier plan available
-        const isPaidPlan = workspacePlan !== "free" || projectPlan !== "free";
-        // Use workspace providers if available, otherwise fall back to project providers
-        const configuredProviders = workspaceProviders.length > 0 ? workspaceProviders : projectProviders;
-        // Build model list from dynamic server fetch, falling back to hardcoded models
-        const allModels = [
-            // Dynamic models from server API
-            ...dynamicModels.anthropic.map(m => ({ id: m.id, label: m.name, provider: m.provider })),
-            ...dynamicModels.openai.map(m => ({ id: m.id, label: m.name, provider: m.provider })),
-            ...dynamicModels.google.map(m => ({ id: m.id, label: m.name, provider: m.provider })),
-            ...dynamicModels.nvidia.map(m => ({ id: m.id, label: m.name, provider: m.provider })),
-            // Fallback hardcoded models (only if dynamic fetch failed)
-            ...(dynamicModels.anthropic.length === 0 ? [
-                { id: "claude-opus-4-5-20251101", label: "Claude Opus 4.5", provider: "anthropic" },
-                { id: "claude-sonnet-4-5-20250929", label: "Claude Sonnet 4.5", provider: "anthropic" },
-                { id: "claude-haiku-4-5-20251015", label: "Claude Haiku 4.5", provider: "anthropic" },
-            ] : []),
-            ...(dynamicModels.openai.length === 0 ? [
-                { id: "gpt-5.1", label: "GPT-5.1", provider: "openai" },
-                { id: "gpt-5.1-codex", label: "GPT-5.1 Codex", provider: "openai" },
-                { id: "gpt-5.1-codex-mini", label: "GPT-5.1 Codex Mini", provider: "openai" },
-                { id: "o3", label: "OpenAI o3", provider: "openai" },
-                { id: "o3-mini", label: "OpenAI o3-mini", provider: "openai" },
-            ] : []),
-            ...(dynamicModels.google.length === 0 ? [
-                { id: "gemini-3-pro-preview", label: "Gemini 3 Pro", provider: "google" },
-                { id: "gemini-3-flash-preview", label: "Gemini 3 Flash", provider: "google" },
-                { id: "gemini-2.5-flash-preview-09-2025", label: "Gemini 2.5 Flash", provider: "google" },
-                { id: "gemini-2.5-flash-lite-preview-09-2025", label: "Gemini 2.5 Flash Lite", provider: "google" },
-            ] : []),
-            ...(dynamicModels.nvidia.length === 0 ? [
-                { id: "nvidia/llama-3.3-nemotron-super-49b-v1", label: "Llama 3.3 Nemotron Super 49B", provider: "nvidia" },
-                { id: "deepseek-ai/deepseek-r1-distill-llama-70b", label: "DeepSeek R1 Distill Llama 70B", provider: "nvidia" },
-                { id: "deepseek-ai/deepseek-r1-distill-llama-8b", label: "DeepSeek R1 Distill Llama 8B", provider: "nvidia" },
-                { id: "google/gemma-3-1b-it", label: "Gemma 3 1B Instruct", provider: "nvidia" },
-                { id: "openai/gpt-oss-120b", label: "GPT-OSS 120B", provider: "nvidia" },
-            ] : []),
-            // Local CLI agents (always included)
-            ...(localAgents.has("claude-code") ? [
-                { id: "claude-code:sonnet", label: "Claude Code · Sonnet 4.5", provider: "cli" },
-                { id: "claude-code:opus", label: "Claude Code · Opus 4.5", provider: "cli" },
-                { id: "claude-code:haiku", label: "Claude Code · Haiku 4.5", provider: "cli" },
-            ] : []),
-            ...(localAgents.has("codex") ? [
-                { id: "codex:gpt-5.1", label: "Codex · GPT-5.1", provider: "cli" },
-                { id: "codex:gpt-5.1-codex", label: "Codex · GPT-5.1-Codex", provider: "cli" },
-            ] : []),
-            ...(localAgents.has("opencode") ? [
-                { id: "opencode:opencode/big-pickle", label: "OpenCode · Big Pickle", provider: "cli" },
-                { id: "opencode:deepseek/deepseek-chat", label: "OpenCode · DeepSeek Chat", provider: "cli" },
-                { id: "opencode:anthropic/claude-sonnet-4-5", label: "OpenCode · Claude Sonnet 4.5", provider: "cli" },
-                { id: "opencode:openai/gpt-5.1", label: "OpenCode · GPT-5.1", provider: "cli" },
-            ] : []),
-            ...(localAgents.has("cursor") ? [
-                { id: "cursor:claude-sonnet-4.5", label: "Cursor · Claude Sonnet 4.5", provider: "cli" },
-                { id: "cursor:claude-opus-4", label: "Cursor · Claude Opus 4", provider: "cli" },
-                { id: "cursor:claude-3.5-sonnet", label: "Cursor · Claude 3.5 Sonnet", provider: "cli" },
-                { id: "cursor:gpt-4o", label: "Cursor · GPT-4o", provider: "cli" },
-                { id: "cursor:gpt-4o-mini", label: "Cursor · GPT-4o mini", provider: "cli" },
-            ] : []),
-            ...discoveredOpenCodeModels,
-            ...discoveredCursorModels,
-            ...locals,
-        ];
-        // Lock models based on provider API key configuration
-        // Paid plans have all models unlocked
-        // Free plans only have models unlocked for providers with configured API keys
-        const providerKeyMapping = {
-            anthropic: "ANTHROPIC_API_KEY",
-            openai: "OPENAI_API_KEY",
-            google: "GOOGLE_GENERATIVE_AI_API_KEY",
-            nvidia: "NVIDIA_API_KEY",
-            ollama: "OLLAMA_BASE_URL",
-        };
-        return allModels.map((model) => {
-            if (model.provider === "cli") {
-                // CLI agents are always unlocked (user manages their own credentials)
-                return model;
-            }
-            if (isPaidPlan) {
-                // Paid plans have all hosted models unlocked
-                return model;
-            }
-            // Free plans: check if provider is configured
-            let isConfigured = false;
-            let lockedReason = "Configure your API key in the dashboard to use this model";
-            if (hasCliAuth) {
-                // User has CLI auth: check dashboard-configured providers first
-                isConfigured = configuredProviders.includes(model.provider);
-                lockedReason = "Configure this provider in your workspace dashboard to use this model";
-            }
-            // If not configured via dashboard, fall back to env-based detection
-            if (!isConfigured) {
-                const envKey = providerKeyMapping[model.provider];
-                isConfigured = Boolean(process.env[envKey]) ||
-                    Boolean(fileEnv[envKey]) ||
-                    Boolean(localProviderKeys[model.provider]);
-                if (!isConfigured) {
-                    lockedReason = hasCliAuth
-                        ? "Configure this provider in your workspace dashboard, or set the provider API key in your .env file"
-                        : "Run `lasso auth login` to configure providers in your dashboard, or set the provider API key in your .env file";
+        try {
+            await runtimeClient.switchModel(session.id, {
+                provider: provider,
+                id: modelId,
+            });
+            socket.send(JSON.stringify({
+                type: "agent_status",
+                taskId,
+                status: "working",
+                message: `Switched to ${provider}/${modelId}`,
+            }));
+        }
+        catch (error) {
+            socket.send(JSON.stringify({
+                type: "agent_status",
+                taskId,
+                status: "error",
+                message: error instanceof Error ? error.message : "Failed to switch model",
+            }));
+        }
+    }
+    // Handler for oneshot
+    async function handleOneshot(message, socket, cwd) {
+        const { taskId, prompt, model, provider } = message;
+        const instruction = prompt;
+        taskControllers.get(taskId)?.abort();
+        const controller = new AbortController();
+        taskControllers.set(taskId, controller);
+        socket.send(JSON.stringify({
+            type: "agent_status",
+            taskId,
+            status: "thinking",
+            message: "Starting oneshot...",
+        }));
+        try {
+            const sessionInput = {
+                userPrompt: prompt,
+                project: {
+                    projectId,
+                    framework,
+                    hasTypeScript: node_fs_1.default.existsSync(node_path_1.default.join(cwd, "tsconfig.json")),
+                    hasReact: node_fs_1.default.existsSync(node_path_1.default.join(cwd, "package.json")) &&
+                        node_fs_1.default.readFileSync(node_path_1.default.join(cwd, "package.json"), "utf8").includes("react"),
+                },
+                model: {
+                    provider: (provider || "anthropic"),
+                    id: model || "claude-3-5-sonnet-20241022",
+                },
+            };
+            const session = await runtimeClient.createSession(sessionInput);
+            activeSessions.set(taskId, session);
+            await runtimeClient.runSession(session.id, cwd, (event) => {
+                if (controller.signal.aborted)
+                    return;
+                if (event.type === "agent_completed") {
+                    runtimeClient.getSession(session.id).then((finalSession) => {
+                        const changes = extractChangesFromSession(finalSession);
+                        const filePaths = changes.map(c => c.filePath);
+                        if (filePaths.length > 0) {
+                            (0, snapshot_1.createSnapshot)(cwd, taskId, `Oneshot: ${instruction}`, filePaths, undefined, session.id);
+                        }
+                        socket.send(JSON.stringify({
+                            type: "assistant_message",
+                            taskId,
+                            message: "Oneshot completed",
+                        }));
+                    });
                 }
-                else {
-                    lockedReason = "";
+                else if (event.type === "error") {
+                    socket.send(JSON.stringify({
+                        type: "agent_status",
+                        taskId,
+                        status: "error",
+                        message: event.data.error || "Runtime error",
+                    }));
                 }
-            }
-            if (!isConfigured) {
-                return {
-                    ...model,
-                    locked: true,
-                    lockedReason: lockedReason || "Configure your API key to use this model",
-                };
-            }
-            return model;
-        });
-    };
+            }, controller.signal);
+        }
+        catch (error) {
+            socket.send(JSON.stringify({
+                type: "agent_status",
+                taskId,
+                status: "error",
+                message: error instanceof Error ? error.message : "Unknown oneshot error",
+            }));
+        }
+    }
+    // Handler for restore_snapshot
+    async function handleRestoreSnapshot(message, socket, cwd) {
+        const { snapshotId } = message;
+        try {
+            await (0, snapshot_1.restoreSnapshot)(snapshotId, cwd);
+            socket.send(JSON.stringify({
+                type: "agent_status",
+                status: "working",
+                message: "Snapshot restored",
+            }));
+        }
+        catch (error) {
+            socket.send(JSON.stringify({
+                type: "agent_status",
+                status: "error",
+                message: error instanceof Error ? error.message : "Failed to restore snapshot",
+            }));
+        }
+    }
+    // Handler for get_timeline
+    async function handleGetTimeline(socket, cwd) {
+        try {
+            const timeline = await (0, snapshot_1.getTimeline)(cwd);
+            socket.send(JSON.stringify({
+                type: "timeline",
+                snapshots: timeline,
+            }));
+        }
+        catch (error) {
+            socket.send(JSON.stringify({
+                type: "agent_status",
+                status: "error",
+                message: error instanceof Error ? error.message : "Failed to get timeline",
+            }));
+        }
+    }
+    // Handler for delete_snapshot
+    async function handleDeleteSnapshot(message, socket, cwd) {
+        const { snapshotId } = message;
+        try {
+            await (0, snapshot_1.deleteSnapshot)(snapshotId, cwd);
+            socket.send(JSON.stringify({
+                type: "agent_status",
+                status: "working",
+                message: "Snapshot deleted",
+            }));
+        }
+        catch (error) {
+            socket.send(JSON.stringify({
+                type: "agent_status",
+                status: "error",
+                message: error instanceof Error ? error.message : "Failed to delete snapshot",
+            }));
+        }
+    }
+    // Git handlers
+    async function handleGitStatus(socket, cwd) {
+        socket.send(JSON.stringify({ type: "git_state", git: await getGitState(cwd) }));
+    }
+    async function handleGitGenerateMessage(message, socket, cwd) {
+        const git = await getGitState(cwd);
+        if (!git.isRepo) {
+            socket.send(JSON.stringify({ type: "git_commit_message", error: "Not a git repository" }));
+            return;
+        }
+        const diff = await gitCommand(cwd, ["diff", "--cached"]).catch(() => "");
+        if (!diff) {
+            socket.send(JSON.stringify({ type: "git_commit_message", error: "No staged changes" }));
+            return;
+        }
+        // TODO: Use runtime for commit message generation
+        socket.send(JSON.stringify({ type: "git_commit_message", message: "feat: changes" }));
+    }
+    async function handleGitInit(socket, cwd) {
+        try {
+            await gitCommand(cwd, ["init"]);
+            socket.send(JSON.stringify({ type: "git_result", message: "Git repository initialized" }));
+        }
+        catch (error) {
+            socket.send(JSON.stringify({ type: "git_result", error: error instanceof Error ? error.message : "Failed to initialize git" }));
+        }
+    }
+    async function handleGitCommit(message, socket, cwd) {
+        try {
+            await gitCommand(cwd, ["commit", "-m", message.message]);
+            socket.send(JSON.stringify({ type: "git_result", message: "Changes committed" }));
+        }
+        catch (error) {
+            socket.send(JSON.stringify({ type: "git_result", error: error instanceof Error ? error.message : "Failed to commit" }));
+        }
+    }
+    async function handleGitPush(socket, cwd) {
+        try {
+            await gitCommand(cwd, ["push"]);
+            socket.send(JSON.stringify({ type: "git_result", message: "Changes pushed" }));
+        }
+        catch (error) {
+            socket.send(JSON.stringify({ type: "git_result", error: error instanceof Error ? error.message : "Failed to push" }));
+        }
+    }
     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
             ? { name: creds.userName, email: creds.userEmail }
             : (process.env.USER ? { name: process.env.USER } : null);
-        socket.send(JSON.stringify({ type: "config", apiKeyConfigured: lassoKeyConfigured, agentConfigured: lassoKeyConfigured || Boolean(agentConfig) || localAgents.size > 0, models: [], collab: collabConfig?.registered ? { ...collabConfig, plan: collabConfig.plan, configuredProviders: collabConfig.configuredProviders } : null, user: userInfo }));
-        void availableModels(collabConfig, workspaceConfig).then((models) => {
-            if (socket.readyState === socket.OPEN)
-                socket.send(JSON.stringify({ type: "config", apiKeyConfigured: lassoKeyConfigured, agentConfigured: lassoKeyConfigured || Boolean(agentConfig) || localAgents.size > 0, models, collab: collabConfig?.registered ? { ...collabConfig, plan: collabConfig.plan, configuredProviders: collabConfig.configuredProviders } : null, user: userInfo }));
-        });
+        socket.send(JSON.stringify({
+            type: "config",
+            apiKeyConfigured: lassoKeyConfigured,
+            agentConfigured: lassoKeyConfigured,
+            models,
+            collab: collabConfig?.registered ? { ...collabConfig, plan: collabConfig.plan, configuredProviders: collabConfig.configuredProviders } : null,
+            user: userInfo
+        }));
         void getGitState(cwd).then((git) => {
             if (socket.readyState === socket.OPEN)
                 socket.send(JSON.stringify({ type: "git_state", git }));
         });
         socket.on("message", async (raw) => {
             const msg = JSON.parse(raw.toString());
-            if (msg.type === "edit" || msg.type === "ask") {
-                console.log(`[lasso] received ${msg.type}:`, { model: msg.model, provider: msg.provider, selectionId: msg.context?.selectionId, messages: msg.messages?.length || 0, changes: msg.type === "edit" ? msg.changesHistory?.length || 0 : 0, screenshots: Boolean(msg.context?.screenshots?.full || msg.context?.screenshots?.element) });
-            }
-            else {
-                console.log("[lasso] received from overlay:", msg);
-            }
-            if (msg.type === "list_page_folders") {
-                const requested = msg.path || ".";
-                const root = node_path_1.default.resolve(cwd);
-                const directory = resolveInsideProject(root, requested);
-                if (!directory) {
-                    socket.send(JSON.stringify({ type: "page_folders", path: requested, entries: [], error: "That folder is outside the current project." }));
-                    return;
-                }
-                socket.send(JSON.stringify({ type: "page_folders", path: requested, entries: pageEntries(root, requested), project: node_path_1.default.basename(root) }));
-                return;
-            }
-            if (msg.type === "create_page_folder") {
-                const root = node_path_1.default.resolve(cwd);
-                const name = node_path_1.default.basename(msg.name || "");
-                const parent = resolveInsideProject(root, msg.parent || ".");
-                if (!parent || !name || name !== msg.name || name === "." || name === "..") {
-                    socket.send(JSON.stringify({ type: "page_folder_created", path: msg.name || "", error: "Enter a folder name without slashes or dots." }));
-                    return;
-                }
-                const target = node_path_1.default.resolve(parent, name);
-                if (!target.startsWith(`${root}${node_path_1.default.sep}`)) {
-                    socket.send(JSON.stringify({ type: "page_folder_created", path: name, error: "Choose a folder inside the current project." }));
-                    return;
-                }
-                try {
-                    node_fs_1.default.mkdirSync(target);
-                    socket.send(JSON.stringify({ type: "page_folder_created", path: node_path_1.default.relative(root, target) }));
-                }
-                catch (error) {
-                    socket.send(JSON.stringify({
-                        type: "page_folder_created",
-                        path: node_path_1.default.relative(root, target),
-                        error: error instanceof Error && error.message.includes("EEXIST") ? "A folder with that name already exists." : "The folder could not be created.",
-                    }));
-                }
-                return;
-            }
-            if (msg.type === "create_page") {
-                const root = node_path_1.default.resolve(cwd);
-                const folder = resolveInsideProject(root, msg.folder || ".");
-                // A page name may contain "/" so the overlay can create nested routes in
-                // one step, but every segment is validated and resolved inside the project.
-                const segments = (msg.fileName || "").split("/").map((segment) => segment.trim()).filter(Boolean);
-                const fileName = segments.pop() || "";
-                if (!folder || !fileName || segments.some((segment) => segment === "." || segment === "..") || fileName === "." || fileName === "..") {
-                    socket.send(JSON.stringify({ type: "page_created", path: msg.fileName || "", error: "Choose a valid project folder and file name." }));
-                    return;
-                }
-                const target = node_path_1.default.resolve(folder, ...segments, fileName);
-                if (!target.startsWith(`${root}${node_path_1.default.sep}`)) {
-                    socket.send(JSON.stringify({ type: "page_created", path: msg.fileName, error: "Choose a valid project folder and file name." }));
-                    return;
-                }
-                try {
-                    node_fs_1.default.mkdirSync(node_path_1.default.dirname(target), { recursive: true });
-                    node_fs_1.default.writeFileSync(target, msg.content.slice(0, 200000), { encoding: "utf8", flag: "wx" });
-                    socket.send(JSON.stringify({ type: "page_created", path: node_path_1.default.relative(root, target) }));
-                }
-                catch (error) {
-                    socket.send(JSON.stringify({ type: "page_created", path: node_path_1.default.relative(root, target), error: error instanceof Error && error.message.includes("EEXIST") ? "A file with that name already exists." : "The page could not be created." }));
-                }
-                return;
-            }
-            if (msg.type === "ask") {
-                const localProvider = msg.provider === "cli";
-                const cliProvider = msg.model?.startsWith("claude-code:") ? "claude-code" : msg.model?.startsWith("opencode:") ? "opencode" : msg.model?.startsWith("cursor:") ? "cursor" : "codex";
-                if (!lassoKeyConfigured && !localProvider) {
-                    socket.send(JSON.stringify({ type: "agent_status", taskId: msg.taskId, status: "error", message: "Set your Lasso API key before asking the hosted agent a question." }));
-                    return;
-                }
-                if (!agentConfig && !localProvider) {
-                    socket.send(JSON.stringify({ type: "agent_status", taskId: msg.taskId, status: "error", message: "No hosted agent is configured. Select Claude Code/Codex or add a provider key." }));
-                    return;
-                }
-                taskControllers.get(msg.taskId)?.abort();
-                const controller = new AbortController();
-                taskControllers.set(msg.taskId, controller);
-                let selectedConfig;
-                if (localProvider) {
-                    selectedConfig = { provider: cliProvider, model: msg.model, lassoKey: resolvedLassoKey, serverUrl: collabConfig?.serverUrl || (0, auth_1.serverUrlFrom)(fileEnv) };
-                }
-                else {
-                    const requestedProvider = (msg.provider || agentConfig.provider);
-                    const providerLocalKey = localProviderKeys[requestedProvider];
-                    const apiKey = providerLocalKey || resolvedLassoKey;
-                    const baseUrl = requestedProvider === "nvidia"
-                        ? "https://integrate.api.nvidia.com/v1"
-                        : requestedProvider === "ollama"
-                            ? (agentConfig.baseUrl || "http://localhost:11434/v1")
-                            : agentConfig.baseUrl;
-                    selectedConfig = {
-                        ...agentConfig,
-                        provider: requestedProvider,
-                        model: msg.model,
-                        apiKey,
-                        baseUrl,
-                        lassoKey: resolvedLassoKey,
-                        serverUrl: collabConfig?.serverUrl || (0, auth_1.serverUrlFrom)(fileEnv),
-                    };
-                }
-                // 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";
-                const cliProvider = msg.model?.startsWith("claude-code:") ? "claude-code" : msg.model?.startsWith("opencode:") ? "opencode" : msg.model?.startsWith("cursor:") ? "cursor" : "codex";
-                if (!lassoKeyConfigured && !localProvider) {
-                    socket.send(JSON.stringify({ type: "agent_status", taskId: msg.taskId, status: "error", message: "Set VITE_LASSO_API_KEY or NEXT_LASSO_API_KEY in your app environment before sending an edit." }));
-                    return;
-                }
-                if (!agentConfig && !localProvider) {
-                    socket.send(JSON.stringify({ type: "agent_status", taskId: msg.taskId, status: "error", message: "Add a supported agent key: GOOGLE_GENERATIVE_AI_API_KEY, OPENAI_API_KEY, or ANTHROPIC_API_KEY." }));
-                    return;
-                }
-                let selectedConfig;
-                if (localProvider) {
-                    selectedConfig = { provider: cliProvider, model: msg.model, lassoKey: resolvedLassoKey, serverUrl: collabConfig?.serverUrl || (0, auth_1.serverUrlFrom)(fileEnv) };
-                }
-                else {
-                    const requestedProvider = (msg.provider || agentConfig.provider);
-                    const providerLocalKey = localProviderKeys[requestedProvider];
-                    const apiKey = providerLocalKey || resolvedLassoKey;
-                    const baseUrl = requestedProvider === "nvidia"
-                        ? "https://integrate.api.nvidia.com/v1"
-                        : requestedProvider === "ollama"
-                            ? (agentConfig.baseUrl || "http://localhost:11434/v1")
-                            : agentConfig.baseUrl;
-                    selectedConfig = {
-                        ...agentConfig,
-                        provider: requestedProvider,
-                        model: msg.model,
-                        apiKey,
-                        baseUrl,
-                        lassoKey: resolvedLassoKey,
-                        serverUrl: collabConfig?.serverUrl || (0, auth_1.serverUrlFrom)(fileEnv),
-                    };
-                }
-                editRequests.set(msg.taskId, msg);
-                editConfigs.set(msg.taskId, selectedConfig);
-                reviewRefreshAttempts.set(msg.taskId, 0);
-                // 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) {
-                    taskControllers.get(msg.taskId)?.abort();
-                    // 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") {
-                socket.send(JSON.stringify({ type: "agent_status", status: "error", message: `Runtime error detected${msg.selectionId ? ` for selection ${msg.selectionId}` : ""}: ${msg.details}` }));
-            }
-            else if (msg.type === "git_status") {
-                socket.send(JSON.stringify({ type: "git_state", git: await getGitState(cwd) }));
-            }
-            else if (msg.type === "git_generate_message") {
-                const localProvider = msg.provider === "cli";
-                const cliProvider = msg.model?.startsWith("claude-code:") ? "claude-code" : msg.model?.startsWith("opencode:") ? "opencode" : msg.model?.startsWith("cursor:") ? "cursor" : "codex";
-                if (!agentConfig && !localProvider) {
-                    socket.send(JSON.stringify({ type: "git_commit_message", error: "No AI provider is configured." }));
-                    return;
-                }
-                const selectedConfig = localProvider
-                    ? { provider: cliProvider, model: msg.model }
-                    : { ...agentConfig, provider: (msg.provider || agentConfig.provider), model: msg.model };
-                const controller = new AbortController();
-                activeAgentController?.abort();
-                activeAgentController = controller;
-                socket.send(JSON.stringify({ type: "git_progress", message: "Generating a commit message…" }));
-                void getGitState(cwd).then((git) => (0, agent_1.generateCommitMessage)(cwd, git.status || [], selectedConfig, controller.signal, (message, detail) => {
-                    if (!controller.signal.aborted && socket.readyState === socket.OPEN)
-                        socket.send(JSON.stringify({ type: "git_progress", message: detail ? `${message} · ${detail}` : message }));
-                })).then((message) => {
-                    if (!controller.signal.aborted)
-                        socket.send(JSON.stringify({ type: "git_commit_message", message }));
-                }).catch((error) => {
-                    if (!controller.signal.aborted)
-                        socket.send(JSON.stringify({ type: "git_commit_message", error: error instanceof Error ? error.message : "Unable to generate a commit message." }));
-                }).finally(() => { if (activeAgentController === controller)
-                    activeAgentController = null; });
-            }
-            else if (msg.type === "git_init") {
-                try {
-                    await gitCommand(cwd, ["init"]);
-                    socket.send(JSON.stringify({ type: "git_result", message: "Git repository initialized." }));
-                    socket.send(JSON.stringify({ type: "git_state", git: await getGitState(cwd) }));
-                }
-                catch (error) {
-                    socket.send(JSON.stringify({ type: "git_result", error: error instanceof Error ? error.message : "Git could not be initialized." }));
-                }
-            }
-            else if (msg.type === "git_commit") {
-                try {
-                    const commitMessage = msg.message.trim().slice(0, 120);
-                    if (!commitMessage)
-                        throw new Error("Enter a commit message first.");
-                    await gitCommand(cwd, ["add", "-A"]);
-                    await gitCommand(cwd, ["commit", "-m", commitMessage]);
-                    socket.send(JSON.stringify({ type: "git_result", message: "Changes committed." }));
-                    socket.send(JSON.stringify({ type: "git_state", git: await getGitState(cwd) }));
-                }
-                catch (error) {
-                    socket.send(JSON.stringify({ type: "git_result", error: error instanceof Error ? error.message : "Changes could not be committed." }));
-                }
-            }
-            else if (msg.type === "git_push") {
-                try {
-                    await gitCommand(cwd, ["push"]);
-                    socket.send(JSON.stringify({ type: "git_result", message: "Changes pushed to the configured remote." }));
-                    socket.send(JSON.stringify({ type: "git_state", git: await getGitState(cwd) }));
-                }
-                catch (error) {
-                    socket.send(JSON.stringify({ type: "git_result", error: error instanceof Error ? error.message : "Changes could not be pushed." }));
-                }
-            }
-            else if (msg.type === "transcribe") {
-                const serverUrl = (0, auth_1.serverUrlFrom)(fileEnv);
-                const creds = (0, auth_1.loadCredentials)();
-                const apiKey = resolvedLassoKey || agentConfig?.apiKey || collabConfig?.apiKey || creds?.apiKey;
-                try {
-                    const resp = await fetch(`${serverUrl}/api/v1/transcribe`, {
-                        method: "POST",
-                        headers: {
-                            "Content-Type": "application/json",
-                            ...(apiKey ? { Authorization: `Bearer ${apiKey}` } : {}),
-                        },
-                        body: JSON.stringify({
-                            audio: msg.audio,
-                            mimeType: msg.mimeType,
-                            language: msg.language,
-                        }),
-                    });
-                    const data = await resp.json();
-                    socket.send(JSON.stringify({
-                        type: "transcribe_result",
-                        requestId: msg.requestId,
-                        success: Boolean(data.success),
-                        text: data.text || "",
-                        provider: data.provider || "gradium",
-                        error: data.message,
-                    }));
-                }
-                catch (error) {
-                    socket.send(JSON.stringify({
-                        type: "transcribe_result",
-                        requestId: msg.requestId,
-                        success: false,
-                        error: error instanceof Error ? error.message : "Failed to contact transcription service",
-                    }));
-                }
-            }
-            else if (msg.type === "oneshot") {
-                console.log("[lasso] one-shot request:", msg.prompt, msg.scope);
-                const taskId = msg.taskId || `oneshot-${Date.now()}`;
-                const localProvider = msg.provider === "cli" || msg.model?.startsWith("claude-code:") || msg.model?.startsWith("opencode:") || msg.model?.startsWith("cursor:") || msg.model?.startsWith("codex:");
-                const cliProvider = msg.model?.startsWith("claude-code:") ? "claude-code" : msg.model?.startsWith("opencode:") ? "opencode" : msg.model?.startsWith("cursor:") ? "cursor" : "codex";
-                const apiKey = resolvedLassoKey || agentConfig?.apiKey || collabConfig?.apiKey;
-                if (!localProvider && !lassoKeyConfigured && !agentConfig && !apiKey) {
-                    socket.send(JSON.stringify({
-                        type: "agent_status",
-                        taskId,
-                        status: "error",
-                        message: "No AI provider or Lasso key configured. Sign in with 'lasso auth login' or configure a provider key in .env."
-                    }));
-                    return;
-                }
-                const provider = (msg.provider || agentConfig?.provider || "google");
-                const model = msg.model || agentConfig?.model;
-                if (!model) {
-                    socket.send(JSON.stringify({
-                        type: "error",
-                        message: "No model selected. Please select a model in settings."
-                    }));
-                    return;
-                }
-                const localKey = localProviderKeys[provider];
-                const serverUrl = collabConfig?.serverUrl || (0, auth_1.serverUrlFrom)(fileEnv);
-                const targetApiUrl = (serverUrl.includes("collab.lasso.byorello.space") ? "https://api.lasso.byorello.space" : serverUrl).replace(/\/api\/v1\/?$/, "");
-                const selectedConfig = localProvider
-                    ? { provider: cliProvider, model: msg.model || "claude-code:sonnet", lassoKey: resolvedLassoKey, serverUrl: targetApiUrl }
-                    : {
-                        ...(agentConfig || {}),
-                        provider,
-                        model,
-                        apiKey: localKey || apiKey,
-                        lassoKey: resolvedLassoKey,
-                        serverUrl: targetApiUrl,
-                        baseUrl: provider === "nvidia" ? "https://integrate.api.nvidia.com/v1" : provider === "ollama" ? `${(process.env.OLLAMA_BASE_URL || fileEnv.OLLAMA_BASE_URL || "http://localhost:11434/api").replace(/\/api\/?$/, "")}/v1` : undefined,
-                    };
-                const controller = new AbortController();
-                taskControllers.set(taskId, controller);
-                socket.send(JSON.stringify({ type: "agent_status", taskId, status: "thinking", message: "Planning your request..." }));
-                const { runOneShotAgent } = await import("./oneshot.js");
-                runOneShotAgent(cwd, msg.prompt, msg.scope || "project", selectedConfig, 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 }));
-                    }
-                }, msg.messages, targetApiUrl, apiKey, taskId, msg.pageContext).then((result) => {
-                    if (!controller.signal.aborted && socket.readyState === socket.OPEN) {
-                        if (result.ok) {
-                            const hasChanges = Array.isArray(result.changes) && result.changes.length > 0;
+            console.log("[lasso] received from overlay:", msg.type);
+            try {
+                switch (msg.type) {
+                    case "hello":
+                        break;
+                    case "edit":
+                    case "ask":
+                        await handleEditOrAsk(msg, socket, msg.taskId, msg.type === "edit" ? msg.instruction : msg.question, msg.model, msg.provider || "anthropic", msg.context, msg.element, msg.messages);
+                        break;
+                    case "apply":
+                        await handleApply(msg, socket, cwd);
+                        break;
+                    case "undo":
+                        await handleUndo(msg, socket, cwd);
+                        break;
+                    case "stop":
+                        await handleStop(msg, socket);
+                        break;
+                    case "switch_model":
+                        await handleSwitchModel(msg, socket);
+                        break;
+                    case "oneshot":
+                        await handleOneshot(msg, socket, cwd);
+                        break;
+                    case "restore_snapshot":
+                        await handleRestoreSnapshot(msg, socket, cwd);
+                        break;
+                    case "get_timeline":
+                        await handleGetTimeline(socket, cwd);
+                        break;
+                    case "delete_snapshot":
+                        await handleDeleteSnapshot(msg, socket, cwd);
+                        break;
+                    case "git_status":
+                        await handleGitStatus(socket, cwd);
+                        break;
+                    case "git_generate_message":
+                        await handleGitGenerateMessage(msg, socket, cwd);
+                        break;
+                    case "git_init":
+                        await handleGitInit(socket, cwd);
+                        break;
+                    case "git_commit":
+                        await handleGitCommit(msg, socket, cwd);
+                        break;
+                    case "git_push":
+                        await handleGitPush(socket, cwd);
+                        break;
+                    case "list_page_folders":
+                        const requested = msg.path || ".";
+                        const root = node_path_1.default.resolve(cwd);
+                        const directory = resolveInsideProject(root, requested);
+                        if (!directory) {
+                            socket.send(JSON.stringify({ type: "page_folders", path: requested, entries: [], error: "That folder is outside the current project." }));
+                            return;
+                        }
+                        socket.send(JSON.stringify({ type: "page_folders", path: requested, entries: pageEntries(root, requested), project: node_path_1.default.basename(root) }));
+                        break;
+                    case "create_page_folder":
+                        const root2 = node_path_1.default.resolve(cwd);
+                        const name = node_path_1.default.basename(msg.name || "");
+                        const parent = resolveInsideProject(root2, msg.parent || ".");
+                        if (!parent || !name || name !== msg.name || name === "." || name === "..") {
+                            socket.send(JSON.stringify({ type: "page_folder_created", path: msg.name || "", error: "Enter a folder name without slashes or dots." }));
+                            return;
+                        }
+                        const target = node_path_1.default.resolve(parent, name);
+                        if (!target.startsWith(`${root2}${node_path_1.default.sep}`)) {
+                            socket.send(JSON.stringify({ type: "page_folder_created", path: name, error: "Choose a folder inside the current project." }));
+                            return;
+                        }
+                        try {
+                            node_fs_1.default.mkdirSync(target);
+                            socket.send(JSON.stringify({ type: "page_folder_created", path: node_path_1.default.relative(root2, target) }));
+                        }
+                        catch (error) {
                             socket.send(JSON.stringify({
-                                type: "agent_status",
-                                taskId,
-                                status: hasChanges ? "review" : "complete",
-                                message: result.summary,
-                                todo: result.todo,
-                                changes: result.changes,
-                                thinking: result.thinking,
-                                totalThinkingTimeMs: result.totalThinkingTimeMs,
+                                type: "page_folder_created",
+                                path: node_path_1.default.relative(root2, target),
+                                error: error instanceof Error && error.message.includes("EEXIST") ? "A folder with that name already exists." : "The folder could not be created.",
                             }));
                         }
-                        else {
-                            socket.send(JSON.stringify({ type: "agent_status", taskId, status: "error", message: result.error || "One-shot agent failed" }));
+                        break;
+                    case "create_page":
+                        const root3 = node_path_1.default.resolve(cwd);
+                        const folder = resolveInsideProject(root3, msg.folder || ".");
+                        if (!folder) {
+                            socket.send(JSON.stringify({ type: "page_created", path: msg.fileName, error: "That folder is outside the current project." }));
+                            return;
                         }
-                    }
-                }).catch((error) => {
-                    if (!controller.signal.aborted && socket.readyState === socket.OPEN) {
-                        socket.send(JSON.stringify({ type: "agent_status", taskId, status: "error", message: error instanceof Error ? error.message : "One-shot agent encountered an error" }));
-                    }
-                }).finally(() => {
-                    if (taskControllers.get(taskId) === controller)
-                        taskControllers.delete(taskId);
-                });
-            }
-            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();
-                    for (const change of msg.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.`);
+                        const targetFile = node_path_1.default.resolve(folder, msg.fileName);
+                        if (!targetFile.startsWith(`${root3}${node_path_1.default.sep}`)) {
+                            socket.send(JSON.stringify({ type: "page_created", path: msg.fileName, error: "Choose a location inside the current project." }));
+                            return;
                         }
-                        fileChanges.push({ filePath, content, exists, ...prepared });
-                        planned.set(filePath, fileChanges);
-                    }
-                    // Apply each file's replacements from the end toward the beginning
-                    taskSnapshots.set(msg.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);
-                    }
-                    // 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,
-                        message: `${msg.changes.length} file${msg.changes.length === 1 ? "" : "s"} updated. Your dev server will reload.`,
-                        validation
-                    }));
-                }
-                catch (error) {
-                    // Restore this task's snapshot if a filesystem error occurs
-                    for (const snapshot of taskSnapshots.get(msg.taskId) || []) {
-                        if (snapshot.content === null) {
-                            if (node_fs_1.default.existsSync(snapshot.filePath))
-                                node_fs_1.default.unlinkSync(snapshot.filePath);
+                        try {
+                            node_fs_1.default.mkdirSync(node_path_1.default.dirname(targetFile), { recursive: true });
+                            node_fs_1.default.writeFileSync(targetFile, msg.content);
+                            socket.send(JSON.stringify({ type: "page_created", path: node_path_1.default.relative(root3, targetFile) }));
                         }
-                        else {
-                            node_fs_1.default.writeFileSync(snapshot.filePath, snapshot.content);
+                        catch (error) {
+                            socket.send(JSON.stringify({
+                                type: "page_created",
+                                path: node_path_1.default.relative(root3, targetFile),
+                                error: error instanceof Error ? error.message : "The file could not be created.",
+                            }));
                         }
-                    }
-                    taskSnapshots.delete(msg.taskId);
-                    const message = error instanceof Error ? error.message : "The change could not be applied.";
-                    socket.send(JSON.stringify({ type: "agent_status", taskId: msg.taskId, status: "error", message }));
-                }
-                finally {
-                    if (taskControllers.get(msg.taskId))
-                        taskControllers.delete(msg.taskId);
+                        break;
+                    default:
+                        console.warn("Unknown bridge message type:", msg.type);
                 }
             }
-            else if (msg.type === "undo") {
-                const snapshots = taskSnapshots.get(msg.taskId || "") || [];
-                for (const snapshot of snapshots) {
-                    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(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 === "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);
+            catch (error) {
+                console.error("Error handling bridge message:", error);
                 socket.send(JSON.stringify({
                     type: "agent_status",
-                    message: success ? "Snapshot deleted." : "Failed to delete snapshot."
+                    taskId: msg.taskId,
+                    status: "error",
+                    message: error instanceof Error ? error.message : "Unknown error",
                 }));
             }
         });
         socket.on("close", () => {
-            overlaySocket = null;
-            currentSocket = null;
-            console.log(chalk_1.default.yellow("!") + " Overlay disconnected");
+            if (socket === overlaySocket)
+                overlaySocket = null;
         });
     });
-    let bridgeListening = false;
-    bridgeServer.on("listening", () => {
-        bridgeListening = true;
+    bridgeServer.listen(bridgePort, "127.0.0.1", () => {
+        console.log(chalk_1.default.green("✓") + ` Bridge listening on ${chalk_1.default.cyan(`http://127.0.0.1:${bridgePort}`)}`);
     });
-    bridgeServer.on("error", (error) => {
-        if (error.code === "EADDRINUSE") {
-            console.warn(chalk_1.default.yellow("!") + ` Lasso bridge port ${bridgePort} is already in use; reusing the existing bridge.`);
-            return;
-        }
-        console.error(chalk_1.default.red("Lasso bridge error:"), error.message);
-    });
-    bridgeServer.listen(bridgePort, "127.0.0.1");
-    function send(msg) {
-        const socket = currentSocket;
-        if (socket && socket.readyState === socket.OPEN) {
-            socket.send(JSON.stringify(msg));
-        }
-    }
-    return {
-        send,
-        close() {
-            if (bridgeListening)
-                bridgeServer.close();
-            wss.close();
-        },
-    };
+    return { ok: true };
 }